Connect Linux Font Unique Name Lookup to Blink

Provide a new subclass for font unique name lookup for Linux. Connect
via WebSandboxSupport to FontLoader which provides the out of process
fontconfig calls for us. Tested by content_browsertests with a DevTools
based test checking used fonts. This test was previously active on
Android and is enabled for Linux in this CL.

Bug: 880832
Change-Id: I04d72fc1cfcfa55a01a9877ac8a3a45dbff38771
Reviewed-on: https://chromium-review.googlesource.com/1206337
Commit-Queue: Dominik Röttsches <drott@chromium.org>
Reviewed-by: Dmitry Gozman <dgozman@chromium.org>
Reviewed-by: Emil A Eklund <eae@chromium.org>
Cr-Commit-Position: refs/heads/master@{#589482}

components/services/font/font_service_app.cc

@@ -210,9 +210,12 @@ void FontServiceApp::MatchFontByPostscriptNameOrFullFontName(
   base::Optional<FontConfigLocalMatching::FontConfigMatchResult> match_result =
       FontConfigLocalMatching::FindFontByPostscriptNameOrFullFontName(family);
   if (match_result) {
-    mojom::FontIdentityPtr font_identity = mojom::FontIdentityPtr(
-        mojom::FontIdentity::New(0, match_result->ttc_index,
-                                 match_result->file_path.AsUTF8Unsafe()));
+    uint32_t fontconfig_interface_id =
+        FindOrAddPath(SkString(match_result->file_path.value().c_str()));
+    mojom::FontIdentityPtr font_identity =
+        mojom::FontIdentityPtr(mojom::FontIdentity::New(
+            fontconfig_interface_id, match_result->ttc_index,
+            match_result->file_path.value()));
     std::move(callback).Run(std::move(font_identity));
     return;
   }

content/browser/font_unique_name_lookup/font_unique_name_browsertest.cc

@@ -16,6 +16,7 @@
 namespace content {
 namespace {
 
+#if defined(OS_ANDROID)
 const char* kExpectedFontFamilyNames[] = {"AndroidClock",
                                           "Roboto",
                                           "Droid Sans Mono",
@@ -59,6 +60,34 @@ const char* kExpectedFontFamilyNames[] = {"AndroidClock",
                                           "Roboto Condensed",
                                           "Roboto Condensed",
                                           "Roboto"};
+#elif defined(OS_LINUX)
+const char* kExpectedFontFamilyNames[] = {"Ahem",
+                                          "Arimo",
+                                          "Arimo",
+                                          "Arimo",
+                                          "Arimo",
+                                          "Cousine",
+                                          "Cousine",
+                                          "Cousine",
+                                          "Cousine",
+                                          "DejaVu Sans",
+                                          "DejaVu Sans",
+                                          "Garuda",
+                                          "Gelasio",
+                                          "Gelasio",
+                                          "Gelasio",
+                                          "Gelasio",
+                                          "Lohit Devanagari",
+                                          "Lohit Gurmukhi",
+                                          "Lohit Tamil",
+                                          "Noto Sans Khmer",
+                                          "Tinos",
+                                          "Tinos",
+                                          "Tinos",
+                                          "Tinos",
+                                          "Mukti Narrow",
+                                          "Tinos"};
+#endif
 
 }  // namespace
 
@@ -80,13 +109,9 @@ class FontUniqueNameBrowserTest : public DevToolsProtocolTest {
   base::test::ScopedFeatureList feature_list_;
 };
 
-#if defined(OS_ANDROID)
-#define MAYBE_ContentLocalFontsMatching ContentLocalFontsMatching
-#else
-#define MAYBE_ContentLocalFontsMatching DISABLED_ContentLocalFontsMatching
-#endif
-IN_PROC_BROWSER_TEST_F(FontUniqueNameBrowserTest,
-                       MAYBE_ContentLocalFontsMatching) {
+// TODO(drott): Enable this on all platforms.
+#if defined(OS_ANDROID) || defined(OS_LINUX)
+IN_PROC_BROWSER_TEST_F(FontUniqueNameBrowserTest, ContentLocalFontsMatching) {
   LoadAndWait("/font_src_local_matching.html");
   Attach();
 
@@ -136,5 +161,6 @@ IN_PROC_BROWSER_TEST_F(FontUniqueNameBrowserTest,
     ASSERT_EQ(first_font_name->GetString(), kExpectedFontFamilyNames[i]);
   }
 }
+#endif
 
 }  // namespace content

content/child/child_process_sandbox_support_impl_linux.cc

@@ -94,4 +94,23 @@ void GetRenderStyleForStrike(sk_sp<font_service::FontLoader> font_loader,
       static_cast<char>(font_render_style->use_subpixel_positioning);
 }
 
+void MatchFontByPostscriptNameOrFullFontName(
+    sk_sp<font_service::FontLoader> font_loader,
+    const char* font_unique_name,
+    blink::OutOfProcessFont* fallback_font) {
+  font_service::mojom::FontIdentityPtr font_identity;
+  std::string family_name;
+  if (!font_loader->MatchFontByPostscriptNameOrFullFontName(font_unique_name,
+                                                            &font_identity)) {
+    LOG(ERROR) << "FontService unique font name matching request did not "
+                  "receive a response.";
+    return;
+  }
+
+  fallback_font->fontconfig_interface_id = font_identity->id;
+  fallback_font->filename.Assign(font_identity->str_representation.c_str(),
+                                 font_identity->str_representation.length());
+  fallback_font->ttc_index = font_identity->ttc_index;
+}
+
 }  // namespace content

content/child/child_process_sandbox_support_impl_linux.h

@@ -38,6 +38,16 @@ void GetRenderStyleForStrike(sk_sp<font_service::FontLoader> font_loader,
                              float device_scale_factor,
                              blink::WebFontRenderStyle* out);
 
+// Matches a font uniquely by postscript name or full font name.  Used in Blink
+// for @font-face { src: local(arg) } matching.  Provide full font name or
+// postscript name as argument font_unique_name in UTF-8. fallback_font contains
+// a filename and fontconfig interface id if a match was found. The filename is
+// empty and the interface id is zero if no match is found.
+void MatchFontByPostscriptNameOrFullFontName(
+    sk_sp<font_service::FontLoader> font_loader,
+    const char* font_unique_name,
+    blink::OutOfProcessFont* uniquely_matched_font);
+
 };  // namespace content
 
 #endif  // CONTENT_CHILD_CHILD_PROCESS_SANDBOX_SUPPORT_IMPL_LINUX_H_

content/ppapi_plugin/ppapi_blink_platform_impl.cc

@@ -54,6 +54,9 @@ class PpapiBlinkPlatformImpl::SandboxSupport : public WebSandboxSupport {
       WebUChar32 character,
       const char* preferred_locale,
       blink::OutOfProcessFont* fallbackFont) override;
+  void MatchFontByPostscriptNameOrFullFontName(
+      const char* font_unique_name,
+      blink::OutOfProcessFont* fallback_font) override;
   void GetWebFontRenderStyleForStrike(const char* family,
                                       int size,
                                       bool is_bold,
@@ -124,6 +127,14 @@ void PpapiBlinkPlatformImpl::SandboxSupport::GetWebFontRenderStyleForStrike(
                           device_scale_factor, out);
 }
 
+void PpapiBlinkPlatformImpl::SandboxSupport::
+    MatchFontByPostscriptNameOrFullFontName(
+        const char* font_unique_name,
+        blink::OutOfProcessFont* uniquely_matched_font) {
+  content::MatchFontByPostscriptNameOrFullFontName(
+      font_loader_, font_unique_name, uniquely_matched_font);
+}
+
 #endif
 
 #endif  // !defined(OS_ANDROID) && !defined(OS_WIN)

content/renderer/renderer_blink_platform_impl.cc

@@ -223,6 +223,9 @@ class RendererBlinkPlatformImpl::SandboxSupport
       blink::WebUChar32 character,
       const char* preferred_locale,
       blink::OutOfProcessFont* fallbackFont) override;
+  void MatchFontByPostscriptNameOrFullFontName(
+      const char* font_unique_name,
+      blink::OutOfProcessFont* fallback_font) override;
   void GetWebFontRenderStyleForStrike(const char* family,
                                       int size,
                                       bool is_bold,
@@ -627,6 +630,14 @@ void RendererBlinkPlatformImpl::SandboxSupport::GetFallbackFontForCharacter(
   unicode_font_families_.insert(std::make_pair(character, *fallbackFont));
 }
 
+void RendererBlinkPlatformImpl::SandboxSupport::
+    MatchFontByPostscriptNameOrFullFontName(
+        const char* font_unique_name,
+        blink::OutOfProcessFont* fallback_font) {
+  content::MatchFontByPostscriptNameOrFullFontName(
+      font_loader_, font_unique_name, fallback_font);
+}
+
 void RendererBlinkPlatformImpl::SandboxSupport::GetWebFontRenderStyleForStrike(
     const char* family,
     int size,

content/test/data/font_src_local_matching.html

@@ -4,7 +4,7 @@
 <body>
 <script>
 function getFontsWithTestCharsForOS() {
-  if (navigator.userAgent.indexOf("Android") !== -1)
+  if (navigator.userAgent.indexOf("Android") !== -1) {
     // Intersection of available fonts of Android Kitkat to Oreo that kept the
     // same family names to compare against for these postscript or full font
     // names. (RobotoThin* and RobotoLight* had differing family names on
@@ -54,6 +54,37 @@ function getFontsWithTestCharsForOS() {
       ["RobotoCondensed-Regular", "0"],
       ["Roboto-Italic", "0"],
     ];
+  } else if (navigator.userAgent.indexOf("Linux") !== -1
+             || navigator.userAgent.indexOf("CrOS") !== -1) {
+    return [
+      ["Ahem", "0"],
+      ["Arimo-Bold", "0"],
+      ["Arimo-BoldItalic", "0"],
+      ["Arimo-Italic", "0"],
+      ["Arimo-Regular", "0"],
+      ["Cousine-Bold", "0"],
+      ["Cousine-BoldItalic", "0"],
+      ["Cousine-Italic", "0"],
+      ["Cousine-Regular", "0"],
+      ["DejaVuSans", "0"],
+      ["DejaVuSans-Bold", "0"],
+      ["Garuda", "0"],
+      ["Gelasio-Bold", "0"],
+      ["Gelasio-BoldItalic", "0"],
+      ["Gelasio-Italic", "0"],
+      ["Gelasio-Regular", "0"],
+      ["Lohit-Devanagari", "0"],
+      ["Lohit-Gurmukhi", "0"],
+      ["Lohit-Tamil", "0"],
+      ["NotoSansKhmer-Regular", "០"],
+      ["Tinos-Bold", "0"],
+      ["Tinos-BoldItalic", "0"],
+      ["Tinos-Italic", "0"],
+      ["Tinos-Regular", "0"],
+      ["muktinarrow", "0"],
+      ["Tinos-Regular", "0"]
+    ];
+  }
   return [];
 }
 

content/utility/utility_blink_platform_with_sandbox_support_impl.cc

@@ -45,6 +45,9 @@ class UtilityBlinkPlatformWithSandboxSupportImpl::SandboxSupport
       blink::WebUChar32 character,
       const char* preferred_locale,
       blink::OutOfProcessFont* fallbackFont) override;
+  void MatchFontByPostscriptNameOrFullFontName(
+      const char* font_unique_name,
+      blink::OutOfProcessFont* uniquely_matched_font) override;
   void GetWebFontRenderStyleForStrike(const char* family,
                                       int size,
                                       bool is_bold,
@@ -133,6 +136,14 @@ void UtilityBlinkPlatformWithSandboxSupportImpl::SandboxSupport::
                           device_scale_factor, out);
 }
 
+void UtilityBlinkPlatformWithSandboxSupportImpl::SandboxSupport::
+    MatchFontByPostscriptNameOrFullFontName(
+        const char* font_unique_name,
+        blink::OutOfProcessFont* uniquely_matched_font) {
+  content::MatchFontByPostscriptNameOrFullFontName(
+      font_loader_, font_unique_name, uniquely_matched_font);
+}
+
 #endif
 
 }  // namespace content

third_party/blink/public/platform/linux/web_sandbox_support.h

@@ -58,6 +58,17 @@ class WebSandboxSupport {
                                            const char* preferred_locale,
                                            OutOfProcessFont*) = 0;
 
+  // Get a OutOfProcessFont specification for a font uniquely identified by full
+  // font name or postscript name.  Specify full font name or postscript name as
+  // argument in UTF-8.
+  //
+  // The OutOfProcessFont out parameter will contain a filename, ttc index and
+  // fontconfig interface id, with the italic and bold members set always
+  // initialised to false.
+  virtual void MatchFontByPostscriptNameOrFullFontName(
+      const char* font_unique_name,
+      OutOfProcessFont*) = 0;
+
   // Fill out the given WebFontRenderStyle with the user's preferences for
   // rendering the given font at the given size (in pixels), given weight and
   // given slant and given device scale factor. The device scale factor is

third_party/blink/renderer/platform/BUILD.gn

@@ -660,6 +660,8 @@ jumbo_component("platform") {
     "fonts/generic_font_family_settings.h",
     "fonts/glyph_metrics_map.h",
     "fonts/linux/font_cache_linux.cc",
+    "fonts/linux/font_unique_name_lookup_linux.cc",
+    "fonts/linux/font_unique_name_lookup_linux.h",
     "fonts/mac/core_text_variations_support.cc",
     "fonts/mac/core_text_variations_support.h",
     "fonts/mac/font_cache_mac.mm",

third_party/blink/renderer/platform/fonts/font_unique_name_lookup.cc

@@ -8,6 +8,8 @@
 
 #if defined(OS_ANDROID)
 #include "third_party/blink/renderer/platform/fonts/android/font_unique_name_lookup_android.h"
+#elif defined(OS_LINUX)
+#include "third_party/blink/renderer/platform/fonts/linux/font_unique_name_lookup_linux.h"
 #endif
 
 namespace blink {
@@ -19,6 +21,8 @@ std::unique_ptr<FontUniqueNameLookup>
 FontUniqueNameLookup::GetPlatformUniqueNameLookup() {
 #if defined(OS_ANDROID)
   return std::make_unique<FontUniqueNameLookupAndroid>();
+#elif defined(OS_LINUX)
+  return std::make_unique<FontUniqueNameLookupLinux>();
 #else
   NOTREACHED();
   return nullptr;

third_party/blink/renderer/platform/fonts/linux/font_unique_name_lookup_linux.cc

+// Copyright 2018 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "third_party/blink/renderer/platform/fonts/linux/font_unique_name_lookup_linux.h"
+#include "third_party/blink/public/platform/linux/out_of_process_font.h"
+#include "third_party/blink/public/platform/linux/web_sandbox_support.h"
+#include "third_party/blink/public/platform/platform.h"
+#include "third_party/blink/renderer/platform/graphics/paint/paint_typeface.h"
+
+namespace blink {
+
+FontUniqueNameLookupLinux::~FontUniqueNameLookupLinux() = default;
+
+sk_sp<SkTypeface> FontUniqueNameLookupLinux::MatchUniqueName(
+    const String& font_unique_name) {
+  OutOfProcessFont uniquely_matched_font;
+  if (!Platform::Current()->GetSandboxSupport()) {
+    LOG(ERROR) << "@font-face src: local() instantiation only available when "
+                  "connected to browser process.";
+    DCHECK(Platform::Current()->GetSandboxSupport());
+    return nullptr;
+  }
+
+  Platform::Current()
+      ->GetSandboxSupport()
+      ->MatchFontByPostscriptNameOrFullFontName(
+          font_unique_name.Utf8(WTF::kStrictUTF8Conversion).data(),
+          &uniquely_matched_font);
+  if (!uniquely_matched_font.filename.size())
+    return nullptr;
+
+  cc::PaintTypeface paint_typeface =
+      cc::PaintTypeface::FromFontConfigInterfaceIdAndTtcIndex(
+          uniquely_matched_font.fontconfig_interface_id,
+          uniquely_matched_font.ttc_index);
+
+  return paint_typeface.ToSkTypeface();
+}
+
+}  // namespace blink

third_party/blink/renderer/platform/fonts/linux/font_unique_name_lookup_linux.h

+// Copyright 2018 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef THIRD_PARTY_BLINK_RENDERER_PLATFORM_FONTS_LINUX_FONT_UNIQUE_NAME_LOOKUP_LINUX_H_
+#define THIRD_PARTY_BLINK_RENDERER_PLATFORM_FONTS_LINUX_FONT_UNIQUE_NAME_LOOKUP_LINUX_H_
+
+#include "third_party/blink/renderer/platform/fonts/font_unique_name_lookup.h"
+
+#include <memory>
+
+namespace blink {
+
+class FontUniqueNameLookupLinux : public FontUniqueNameLookup {
+ public:
+  FontUniqueNameLookupLinux() = default;
+  ~FontUniqueNameLookupLinux() override;
+  sk_sp<SkTypeface> MatchUniqueName(const String& font_unique_name) override;
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(FontUniqueNameLookupLinux);
+};
+
+}  // namespace blink
+
+#endif

third_party/blink/renderer/platform/fonts/skia/font_cache_skia.cc

@@ -57,7 +57,7 @@
 
 namespace blink {
 
-#if defined(OS_ANDROID)
+#if defined(OS_ANDROID) || defined(OS_LINUX)
 namespace {
 
 static PaintTypeface CreateTypefaceFromUniqueName(
@@ -299,7 +299,7 @@ std::unique_ptr<FontPlatformData> FontCache::CreateFontPlatformData(
   CString name;
 
   PaintTypeface paint_tf;
-#if defined(OS_ANDROID)
+#if defined(OS_ANDROID) || defined(OS_LINUX)
   if (alternate_name == AlternateFontName::kLocalUniqueFace &&
       RuntimeEnabledFeatures::FontSrcLocalMatchingEnabled()) {
     paint_tf = CreateTypefaceFromUniqueName(creation_params, name);

third_party/blink/renderer/platform/runtime_enabled_features.json5

@@ -477,7 +477,8 @@
     },
     {
       name: "FontSrcLocalMatching",
-      status: "test",
+      // No status, as the web platform runtime enabled feature is controlled by
+      // a Chromium level feature.
     },
     // For simulating Android's overlay fullscreen video in layout tests on Linux.
     {