RenderTextHarfBuzz: Implement font fallback for Win and Linux

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 <usp10.h>
+
 #include <map>
 
 #include "base/memory/singleton.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 "ui/gfx/font.h"
+#include "ui/gfx/font_fallback.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 117 matching lines @@
   QueryLinkedFontsFromRegistry(font, &cached_system_fonts_, linked_fonts);
   return linked_fonts;
 }
 
 CachedFontLinkSettings::CachedFontLinkSettings() {
 }
 
 CachedFontLinkSettings::~CachedFontLinkSettings() {
 }
 
+// Callback to |EnumEnhMetaFile()| to intercept font creation.
+int CALLBACK MetaFileEnumProc(HDC hdc,
+                              HANDLETABLE* table,
+                              CONST ENHMETARECORD* record,
+                              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;
+}
+
 }  // namespace
 
 namespace internal {
 
 void ParseFontLinkEntry(const std::string& entry,
                         std::string* filename,
                         std::string* font_name) {
   std::vector<std::string> parts;
   base::SplitString(entry, ',', &parts);
   filename->clear();
@@ skipping 17 matching lines @@
   if (!font_names->empty()) {
     const size_t index = font_names->back().find('(');
     if (index != std::string::npos) {
       font_names->back().resize(index);
       base::TrimWhitespace(font_names->back(), base::TRIM_TRAILING,
                            &font_names->back());
     }
   }
 }
 
-}  // namespace internal
-
 LinkedFontsIterator::LinkedFontsIterator(Font font)
     : original_font_(font),
       next_font_set_(false),
       linked_fonts_(NULL),
       linked_font_index_(0) {
   SetNextFont(original_font_);
 }
 
 LinkedFontsIterator::~LinkedFontsIterator() {
 }
@@ skipping 35 matching lines @@
   //
   // Note: One possibility would be to always merge both lists of fonts,
   //       but it is not clear whether there are any real world scenarios
   //       where this would actually help.
   if (fonts->empty())
     fonts = font_link->GetLinkedFonts(current_font_);
 
   return fonts;
 }
 
+}  // namespace internal
+
+std::vector<std::string> GetFallbackFontFamilies(std::string font_family) {

[msw, 2014/07/12 17:41:11]

In another patch, it might make sense to expose a cross-platform
LinkedFontsIterator. Otherwise, each time we shape a run, we're going through
the whole fallback process, even though the initial font might be perfectly
fine. LinkedFontsIterator would allow more fonts to be requested as needed.

[ckocagil, 2014/07/12 19:53:26]

I don't see how this would improve performance (we seem to cache the important
bits on Win and Linux). It would simplify the code however.

Is the code below similar to what you have in mind?
FallbackFonts fonts(primary_font, text, text_length);
while (fonts.NextFont(&current_font))
  ...;

[msw, 2014/07/12 22:03:38]

Your comment in RenderTextHarfBuzz illustrates my concern, where my request to
make GetFallbackFontFamilies call GetUniscribeFallbackFont, would make us "issue
a call to GetUniscribeFallbackFont every time we shape something". So, perhaps
what you have in the latest patch set is good for now.
Yes, (but eventually using the the whole |font_list()| instead of the
|primary_font|). Anyway, let's use the latest patch set as-is for this first
implementation.

+  internal::LinkedFontsIterator linked_fonts(Font(font_family, 10));
+  std::vector<std::string> fallback_fonts;
+  Font current;
+  while (linked_fonts.NextFont(&current))
+    fallback_fonts.push_back(current.GetFontName());
+  return fallback_fonts;
+}
+
+// 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 GetUniscribeFallbackFont(HDC hdc,
+                              const Font& font,
+                              const wchar_t* text,
+                              int text_length,
+                              Font* result) {
+  // 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 gfx