Font fallback for UI

ui/gfx/font_fallback_win.cc

 // Copyright (c) 2012 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 "ui/gfx/font_fallback_win.h"
 
+#include <dwrite_2.h>
 #include <usp10.h>
+#include <wrl.h>
 
 #include <map>
 
 #include "base/macros.h"
 #include "base/memory/singleton.h"
 #include "base/profiler/scoped_tracker.h"
 #include "base/strings/string_split.h"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/win/registry.h"
+#include "base/win/scoped_comptr.h"
 #include "ui/gfx/font.h"
 #include "ui/gfx/font_fallback.h"
+#include "ui/gfx/platform_font_win.h"

[msw, 2016/06/23 20:59:37]

q: what is this used for?

[Ilya Kulshin, 2016/06/24 20:48:24]

This is needed for GetFamilyNameFromDirectWriteFont().

[msw, 2016/06/27 20:45:36]

Acknowledged.

+#include "ui/gfx/win/direct_write.h"
+#include "ui/gfx/win/dwrite_text_analysis_source.h"
 
 namespace gfx {
 
 namespace {
 
 // Queries the registry to get a mapping from font filenames to font names.
 void QueryFontsFromRegistry(std::map<std::string, std::string>* map) {
   const wchar_t* kFonts =
       L"Software\\Microsoft\\Windows NT\\CurrentVersion\\Fonts";
 
@@ skipping 138 matching lines @@
                               int table_entries,
                               LPARAM log_font) {
   if (record->iType == EMR_EXTCREATEFONTINDIRECTW) {
     const EMREXTCREATEFONTINDIRECTW* create_font_record =
         reinterpret_cast<const EMREXTCREATEFONTINDIRECTW*>(record);
     *reinterpret_cast<LOGFONT*>(log_font) = create_font_record->elfw.elfLogFont;
   }
   return 1;
 }
 
+bool GetUniscribeFallbackFont(const Font& font,
+                              const wchar_t* text,
+                              int text_length,
+                              Font* result) {
+  // Adapted from WebKit's |FontCache::GetFontDataForCharacters()|.
+  // Uniscribe doesn't expose a method to query fallback fonts, so this works by
+  // drawing the text to an EMF object with Uniscribe's ScriptStringOut and then
+  // inspecting the EMF object to figure out which font Uniscribe used.
+  //
+  // DirectWrite in Windows 8.1 provides a cleaner alternative:
+  // http://msdn.microsoft.com/en-us/library/windows/desktop/dn280480.aspx
+
+  static HDC hdc = CreateCompatibleDC(NULL);
+
+  // Use a meta file to intercept the fallback font chosen by Uniscribe.
+  HDC meta_file_dc = CreateEnhMetaFile(hdc, NULL, NULL, NULL);
+  if (!meta_file_dc)
+    return false;
+
+  SelectObject(meta_file_dc, font.GetNativeFont());
+
+  SCRIPT_STRING_ANALYSIS script_analysis;
+  HRESULT hresult =
+      ScriptStringAnalyse(meta_file_dc, text, text_length, 0, -1,
+                          SSA_METAFILE | SSA_FALLBACK | SSA_GLYPHS | SSA_LINK,
+                          0, NULL, NULL, NULL, NULL, NULL, &script_analysis);
+
+  if (SUCCEEDED(hresult)) {
+    hresult = ScriptStringOut(script_analysis, 0, 0, 0, NULL, 0, 0, FALSE);
+    ScriptStringFree(&script_analysis);
+  }
+
+  bool found_fallback = false;
+  HENHMETAFILE meta_file = CloseEnhMetaFile(meta_file_dc);
+  if (SUCCEEDED(hresult)) {
+    LOGFONT log_font;
+    log_font.lfFaceName[0] = 0;
+    EnumEnhMetaFile(0, meta_file, MetaFileEnumProc, &log_font, NULL);
+    if (log_font.lfFaceName[0]) {
+      *result =
+          Font(base::UTF16ToUTF8(log_font.lfFaceName), font.GetFontSize());
+      found_fallback = true;
+    }
+  }
+  DeleteEnhMetaFile(meta_file);
+
+  return found_fallback;
+}
+
 }  // namespace
 
 namespace internal {
 
 void ParseFontLinkEntry(const std::string& entry,
                         std::string* filename,
                         std::string* font_name) {
   std::vector<std::string> parts = base::SplitString(
       entry, ",", base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL);
   filename->clear();
@@ skipping 87 matching lines @@
 
   // LinkedFontsIterator doesn't care about the font size, so we always pass 10.
   internal::LinkedFontsIterator linked_fonts(Font(font_family, 10));
   std::vector<Font> fallback_fonts;
   Font current;
   while (linked_fonts.NextFont(&current))
     fallback_fonts.push_back(current);
   return fallback_fonts;
 }
 
-bool GetUniscribeFallbackFont(const Font& font,
-                              const wchar_t* text,
-                              int text_length,
-                              Font* result) {
-  // Adapted from WebKit's |FontCache::GetFontDataForCharacters()|.
-  // Uniscribe doesn't expose a method to query fallback fonts, so this works by
-  // drawing the text to an EMF object with Uniscribe's ScriptStringOut and then
-  // inspecting the EMF object to figure out which font Uniscribe used.
-  //
-  // DirectWrite in Windows 8.1 provides a cleaner alternative:
-  // http://msdn.microsoft.com/en-us/library/windows/desktop/dn280480.aspx
+bool GetFallbackFont(const Font& font,
+                     const wchar_t* text,
+                     int text_length,
+                     Font* result) {
+  // Creating a DirectWrite font fallback can be expensive. It's ok in the
+  // browser process because we can use the shared system fallback, but in the
+  // renderer this can cause hangs. Code that needs font fallback in the
+  // renderer should instead use the font proxy.
+  DCHECK(base::MessageLoopForUI::IsCurrent());
 
-  static HDC hdc = CreateCompatibleDC(NULL);
-
-  // Use a meta file to intercept the fallback font chosen by Uniscribe.
-  HDC meta_file_dc = CreateEnhMetaFile(hdc, NULL, NULL, NULL);
-  if (!meta_file_dc)
-    return false;
-
-  SelectObject(meta_file_dc, font.GetNativeFont());
-
-  SCRIPT_STRING_ANALYSIS script_analysis;
-  HRESULT hresult =
-      ScriptStringAnalyse(meta_file_dc, text, text_length, 0, -1,
-                          SSA_METAFILE | SSA_FALLBACK | SSA_GLYPHS | SSA_LINK,
-                          0, NULL, NULL, NULL, NULL, NULL, &script_analysis);
-
-  if (SUCCEEDED(hresult)) {
-    hresult = ScriptStringOut(script_analysis, 0, 0, 0, NULL, 0, 0, FALSE);
-    ScriptStringFree(&script_analysis);
+  base::win::ScopedComPtr<IDWriteFactory> factory;
+  gfx::win::CreateDWriteFactory(factory.Receive());

[msw, 2016/06/23 20:59:38]

Is it unreasonably expensive for every fallback attempt to call LoadLibraryW?
Can we instead get the instance cached with PlatformFontWin?

[Ilya Kulshin, 2016/06/24 20:48:24]

Now that we no longer need to support XP and Vista, I'm working on a change to
link to dwrite.dll directly, without having to call LoadLibrary. Not in this
change, but should happen soon.

[msw, 2016/06/27 20:45:36]

Is it not easily feasible to cache an instance in the mean time? If we need to
LoadLibrary every time, I'd like to know roughly how much it will regress
performance, especially for users encountering many strings that require
fallback. Can you try caching or run some quick numbers on the perf impact?

[msw, 2016/06/28 18:37:23]

Ping?

[Ilya Kulshin, 2016/06/28 20:32:52]

Sorry, didn't notice this comment. I did some measurements, and it looks like
the calls to LoadLibrary add about 10-15 microseconds (direct write is usually
loaded already anyway). Not sure if that would really matter, but added a cache
anyway.

+  base::win::ScopedComPtr<IDWriteFactory2> factory2;
+  factory.QueryInterface(factory2.Receive());
+  if (!factory2) {
+    // IDWriteFactory2 is not available before Win8.1
+    return GetUniscribeFallbackFont(font, text, text_length, result);
   }
 
-  bool found_fallback = false;
-  HENHMETAFILE meta_file = CloseEnhMetaFile(meta_file_dc);
-  if (SUCCEEDED(hresult)) {
-    LOGFONT log_font;
-    log_font.lfFaceName[0] = 0;
-    EnumEnhMetaFile(0, meta_file, MetaFileEnumProc, &log_font, NULL);
-    if (log_font.lfFaceName[0]) {
-      *result = Font(base::UTF16ToUTF8(log_font.lfFaceName),
-                     font.GetFontSize());
-      found_fallback = true;
-    }
+  base::win::ScopedComPtr<IDWriteFontFallback> fallback;
+  factory2->GetSystemFontFallback(fallback.Receive());
+
+  base::win::ScopedComPtr<IDWriteNumberSubstitution> number_substitution;
+  factory2->CreateNumberSubstitution(
+      DWRITE_NUMBER_SUBSTITUTION_METHOD_NONE, L"" /* locale */,

[msw, 2016/06/23 20:59:37]

Can/should we use the actual locale from base::18n or icu?

[Ilya Kulshin, 2016/06/24 20:48:24]

Done.

+      true /* ignoreUserOverride */, number_substitution.Receive());
+
+  uint32_t mapped_length = 0;
+  base::win::ScopedComPtr<IDWriteFont> mapped_font;
+  float scale = 0;
+  base::win::ScopedComPtr<IDWriteTextAnalysisSource> text_analysis;
+  Microsoft::WRL::MakeAndInitialize<gfx::win::TextAnalysisSource>(

[msw, 2016/06/23 20:59:38]

This can fail; try uniscribe (or bail?) if it doesn't succeed.

[Ilya Kulshin, 2016/06/24 20:48:24]

This would only fail if we fail to alloc memory. I'll add checks so this bails,
but I don't think it's worth trying to fallback to uniscribe.

[msw, 2016/06/27 20:45:36]

Acknowledged.

+      text_analysis.Receive(), text, L"" /* locale */,

[msw, 2016/06/23 20:59:37]

ditto locale q

[Ilya Kulshin, 2016/06/24 20:48:24]

Done.

+      number_substitution.get(), DWRITE_READING_DIRECTION_LEFT_TO_RIGHT);

[msw, 2016/06/23 20:59:38]

Can/should we use the actual text direction here?

[Ilya Kulshin, 2016/06/24 20:48:24]

Done.

+  base::string16 original_name = base::UTF8ToUTF16(font.GetFontName());
+  fallback->MapCharacters(text_analysis.get(), 0, text_length, nullptr,
+                          original_name.c_str(), DWRITE_FONT_WEIGHT_NORMAL,

[msw, 2016/06/23 20:59:37]

Can/should we use the weight and style of the input font?

[Ilya Kulshin, 2016/06/24 20:48:24]

Weight was fairly simple to pipe through. Style was manageable, although
DirectWrite apparently doesn't care about potential underline for purposes of
fallback, so I'm ignoring underline style. As far as I can tell |Font| has no
concept of font stretch, so I'm hardcoding font_stretch_normal. Since this API
only needs to be get the right font family that should be sufficient.

[msw, 2016/06/27 20:45:36]

Acknowledged.

+                          DWRITE_FONT_STYLE_NORMAL, DWRITE_FONT_STRETCH_NORMAL,
+                          &mapped_length, mapped_font.Receive(), &scale);
+
+  if (mapped_font) {
+    base::string16 family_name;
+    GetFamilyNameFromDirectWriteFont(mapped_font.get(), &family_name);

[msw, 2016/06/23 20:59:38]

Check the result here (or remove the result and just return the name?)

[Ilya Kulshin, 2016/06/24 20:48:24]

Done.

+    *result = Font(base::UTF16ToUTF8(family_name), font.GetFontSize() * scale);
+    return true;
   }
-  DeleteEnhMetaFile(meta_file);
-
-  return found_fallback;
+  return false;

[msw, 2016/06/23 20:59:38]

Fall back to uniscribe here?

[Ilya Kulshin, 2016/06/24 20:48:24]

DirectWrite returns a null mapped_font if it cannot find any font to render the
requested characters. If that happens, it is highly unlikely that uniscribe
would find anything.

[msw, 2016/06/27 20:45:36]

Acknowledged.

 }
 
 }  // namespace gfx