RenderTextHarfBuzz: Implement font fallback for Win and Linux

ui/gfx/render_text_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/render_text_win.h"
 
 #include <algorithm>
 
 #include "base/i18n/break_iterator.h"
 #include "base/i18n/char_iterator.h"
@@ skipping 19 matching lines @@
 const size_t kMaxUniscribeTextLength = 10000;
 
 // The initial guess and maximum supported number of runs; arbitrary values.
 // TODO(msw): Support more runs, determine a better initial guess, etc.
 const int kGuessRuns = 100;
 const size_t kMaxRuns = 10000;
 
 // The maximum number of glyphs per run; ScriptShape fails on larger values.
 const size_t kMaxGlyphs = 65535;
 
-// 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;
-}
-
-// Finds a fallback font to use to render the specified |text| with respect to
-// an initial |font|. Returns the resulting font via out param |result|. Returns
-// |true| if a fallback font was found.
-// Adapted from WebKit's |FontCache::GetFontDataForCharacters()|.
-// TODO(asvitkine): This should be moved to font_fallback_win.cc.
-bool ChooseFallbackFont(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;
-}
-
 // Changes |font| to have the specified |font_size| (or |font_height| on Windows
 // XP) and |font_style| if it is not the case already. Only considers bold and
 // italic styles, since the underlined style has no effect on glyph shaping.
 void DeriveFontIfNecessary(int font_size,
                            int font_height,
                            int font_style,
                            Font* font) {
   const int kStyleMask = (Font::BOLD | Font::ITALIC);
   const int target_style = (font_style & kStyleMask);
 
@@ skipping 939 matching lines @@
     run->width = abc.abcA + abc.abcB + abc.abcC;
     preceding_run_widths += run->width;
   }
   string_width_ = preceding_run_widths;
 }
 
 void RenderTextWin::LayoutTextRun(internal::TextRun* run) {
   const size_t run_length = run->range.length();
   const wchar_t* run_text = &(GetLayoutText()[run->range.start()]);
   Font original_font = run->font;
-  LinkedFontsIterator fonts(original_font);
+  std::vector<std::string> fonts =
+      GetFallbackFontFamilies(original_font.GetFontName());

[Alexei Svitkine (slow), 2014/07/18 13:08:48]

Nit: Can this be moved down right above the loop over it? That way, if original
font or the cached or substitute font works, we don't need to pay the cost of
querying this / copying the vector.

[ckocagil, 2014/07/18 15:50:11]

Done.

 
   run->logical_clusters.reset(new WORD[run_length]);
 
   // Try to shape with the first font in the fallback list, which is
   // |original_font|.
-  Font current_font;
-  fonts.NextFont(&current_font);
+  Font current_font(fonts[0], original_font.GetFontSize());

[Alexei Svitkine (slow), 2014/07/18 13:08:48]

With the suggestion above, this can just be initialized to |original_font|.

[ckocagil, 2014/07/18 15:50:11]

Done.

   int missing_count = CountCharsWithMissingGlyphs(run,
       ShapeTextRunWithFont(run, current_font));
   if (missing_count == 0)
     return;
 
   // Keep track of the font that is able to display the greatest number of
   // characters for which ScriptShape() returned S_OK. This font will be used
   // in the case where no font is able to display the entire run.
   int best_partial_font_missing_char_count = missing_count;
   Font best_partial_font = current_font;
 
   // Try to shape with the cached font from previous runs, if any.
   std::map<std::string, Font>::const_iterator it =
       successful_substitute_fonts_.find(original_font.GetFontName());
   if (it != successful_substitute_fonts_.end()) {
     current_font = it->second;
     missing_count = CountCharsWithMissingGlyphs(run,
         ShapeTextRunWithFont(run, current_font));
     if (missing_count == 0)
       return;
     if (missing_count < best_partial_font_missing_char_count) {
       best_partial_font_missing_char_count = missing_count;
       best_partial_font = current_font;
     }
   }
 
   // Try finding a fallback font using a meta file.
   // TODO(msw|asvitkine): Support RenderText's font_list()?
-  if (ChooseFallbackFont(cached_hdc_, run->font, run_text, run_length,
-                         &current_font)) {
+  if (GetUniscribeFallbackFont(run->font, run_text, run_length,
+                               &current_font)) {
     missing_count = CountCharsWithMissingGlyphs(run,
         ShapeTextRunWithFont(run, current_font));
     if (missing_count == 0) {
       successful_substitute_fonts_[original_font.GetFontName()] = current_font;
       return;
     }
     if (missing_count < best_partial_font_missing_char_count) {
       best_partial_font_missing_char_count = missing_count;
       best_partial_font = current_font;
     }
   }
 
   // Try the rest of fonts in the fallback list.
-  while (fonts.NextFont(&current_font)) {
+  for (size_t i = 1; i < fonts.size(); ++i) {
     missing_count = CountCharsWithMissingGlyphs(run,
-        ShapeTextRunWithFont(run, current_font));
+        ShapeTextRunWithFont(run, Font(fonts[i], original_font.GetFontSize())));
     if (missing_count == 0) {
       successful_substitute_fonts_[original_font.GetFontName()] = current_font;
       return;
     }
     if (missing_count < best_partial_font_missing_char_count) {
       best_partial_font_missing_char_count = missing_count;
       best_partial_font = current_font;
     }
   }
 
@@ skipping 159 matching lines @@
   size_t position = LayoutIndexToTextIndex(run->range.end());
   position = IndexOfAdjacentGrapheme(position, CURSOR_BACKWARD);
   return SelectionModel(position, CURSOR_FORWARD);
 }
 
 RenderText* RenderText::CreateNativeInstance() {
   return new RenderTextWin;
 }
 
 }  // namespace gfx