RenderTextHarfBuzz: Implement font fallback for Win and Linux

ui/gfx/render_text_harfbuzz.cc

 // Copyright 2014 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_harfbuzz.h"
 
 #include <map>
 
 #include "base/debug/leak_annotations.h"
 #include "base/i18n/bidi_line_iterator.h"
 #include "base/i18n/break_iterator.h"
 #include "base/i18n/char_iterator.h"
 #include "base/lazy_instance.h"
 #include "third_party/harfbuzz-ng/src/hb.h"
 #include "third_party/icu/source/common/unicode/ubidi.h"
 #include "third_party/skia/include/core/SkColor.h"
 #include "third_party/skia/include/core/SkTypeface.h"
 #include "ui/gfx/canvas.h"
+#include "ui/gfx/font_fallback.h"
 #include "ui/gfx/font_render_params.h"
 #include "ui/gfx/utf16_indexing.h"
 
+#if defined(OS_WIN)
+#include "ui/gfx/font_fallback_win.h"
+#endif
+
 namespace gfx {
 
 namespace {
 
 // The maximum number of scripts a Unicode character can belong to. This value
 // is arbitrarily chosen to be a good limit because it is unlikely for a single
 // character to belong to more scripts.
 const size_t kMaxScripts = 5;
 
 // Maps from code points to glyph indices in a font.
@@ skipping 424 matching lines @@
 
   first = CharToGlyph(char_range.start());
   for (size_t i = char_range.end(); i < range.end(); ++i) {
     last = CharToGlyph(i);
     if (first != last)
       return Range(first, last);
   }
   return Range(first, glyph_count);
 }
 
-// Returns whether the given shaped run contains any missing glyphs.
-bool TextRunHarfBuzz::HasMissingGlyphs() const {
+size_t TextRunHarfBuzz::CountMissingGlyphs() const {
   static const int kMissingGlyphId = 0;
-  for (size_t i = 0; i < glyph_count; ++i) {
-    if (glyphs[i] == kMissingGlyphId)
-      return true;
-  }
-  return false;
+  size_t missing = 0;
+  for (size_t i = 0; i < glyph_count; ++i)
+    missing += (glyphs[i] == kMissingGlyphId) ? 1 : 0;
+  return missing;
 }
 
 int TextRunHarfBuzz::GetGlyphXBoundary(size_t text_index, bool trailing) const {
   if (text_index == range.end()) {
     trailing = true;
     --text_index;
   }
   Range glyph_range = CharRangeToGlyphRange(Range(text_index, text_index + 1));
   const size_t glyph_pos = (is_rtl == trailing) ?
       glyph_range.start() : glyph_range.end();
@@ skipping 457 matching lines @@
   std::vector<UBiDiLevel> levels(num_runs);
   for (size_t i = 0; i < num_runs; ++i)
     levels[i] = runs_[i]->level;
   visual_to_logical_.resize(num_runs);
   ubidi_reorderVisual(&levels[0], num_runs, &visual_to_logical_[0]);
   logical_to_visual_.resize(num_runs);
   ubidi_reorderLogical(&levels[0], num_runs, &logical_to_visual_[0]);
 }
 
 void RenderTextHarfBuzz::ShapeRun(internal::TextRunHarfBuzz* run) {
+  const Font& primary_font = font_list().GetPrimaryFont();
+  run->font_size = primary_font.GetFontSize();
+  std::vector<std::string> fonts =
+      GetFallbackFontFamilies(primary_font.GetFontName());

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

Let's only call this if |primary_font| doesn't shape all the glyphs (for perf)

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

Done.

+  std::string best_font = primary_font.GetFontName();
+  size_t best_font_missing = -1;
+
+  // Try shaping with the first font in the list, which is |primary_font|.
+  ShapeRunWithFont(run, fonts[0]);
+  size_t current_missing = run->CountMissingGlyphs();
+  if (current_missing == 0)
+    return;
+  if (current_missing < best_font_missing) {
+    best_font_missing = current_missing;
+    best_font = fonts[0];
+  }
+
+#if defined(OS_WIN)
+  Font uniscribe_font;
+  if (GetUniscribeFallbackFont(NULL, primary_font,

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

Could font_fallback_win insert any Uniscribe fallback to the vector returned by
GetFallbackFontFamilies? That would avoid platform-specific code here. (it would
also let you restore the single loop over |fonts|)

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

This would issue a call to GetUniscribeFallbackFont every time we shape
something, and that isn't a trivial function. We currently don't have a good way
to cache the Uniscribe lookup results.

We could merge the ifdef with the loop below it though, but there's still the
issue of hiding (or getting rid of) the passed HDC.

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

You're right, forget this for now, we can consider more cleanup later.
When we address this later, we could either have font_fallback_win cache its own
HDC (if it doesn't need to actually share one with RenderText). Otherwise,
perhaps we could pass the RenderText HDC to the LinkedFontsIterator instance on
windows, like:

  FallbackFonts fonts(primary_font, text, text_length);
#if defined(OS_WIN)
  fonts.set_hdc(cached_hdc_);
#endif
  while (fonts.NextFont(&current_font))
    ...

+          &(GetLayoutText()[run->range.start()]), run->range.length(),
+          &uniscribe_font)) {
+    ShapeRunWithFont(run, uniscribe_font.GetFontName());
+    size_t current_missing = run->CountMissingGlyphs();
+    if (current_missing == 0)
+      return;
+    if (current_missing < best_font_missing) {
+      best_font_missing = current_missing;
+      best_font = uniscribe_font.GetFontName();
+    }
+  }
+#endif
+
+  // Try shaping with the rest of the fonts in the list.
+  for (size_t i = 1; i < fonts.size(); ++i) {
+    ShapeRunWithFont(run, fonts[i]);
+    size_t current_missing = run->CountMissingGlyphs();
+    if (current_missing == 0)
+      return;
+    if (current_missing < best_font_missing) {
+      best_font_missing = current_missing;
+      best_font = fonts[i];
+    }
+  }
+
+  ShapeRunWithFont(run, best_font);
+}
+
+void RenderTextHarfBuzz::ShapeRunWithFont(internal::TextRunHarfBuzz* run,
+                                          std::string font) {
   const base::string16& text = GetLayoutText();
-  // TODO(ckocagil|yukishiino): Implement font fallback.
-  const Font& primary_font = font_list().GetPrimaryFont();
-  run->skia_face = internal::CreateSkiaTypeface(primary_font.GetFontName(),
-                                                run->font_style);
-  run->font_size = primary_font.GetFontSize();
-
+  run->skia_face = internal::CreateSkiaTypeface(font, run->font_style);
   hb_font_t* harfbuzz_font = CreateHarfBuzzFont(run->skia_face.get(),
                                                 run->font_size);
 
   // Create a HarfBuzz buffer and add the string to be shaped. The HarfBuzz
   // buffer holds our text, run information to be used by the shaping engine,
   // and the resulting glyph data.
   hb_buffer_t* buffer = hb_buffer_create();
   hb_buffer_add_utf16(buffer, reinterpret_cast<const uint16*>(text.c_str()),
                       text.length(), run->range.start(), run->range.length());
   hb_buffer_set_script(buffer, ICUScriptToHBScript(run->script));
   hb_buffer_set_direction(buffer,
       run->is_rtl ? HB_DIRECTION_RTL : HB_DIRECTION_LTR);
-  // TODO(ckocagil): Should we determine the actual language?
-  hb_buffer_set_language(buffer, hb_language_get_default());
+  // TODO(ckocagil): Should we call |hb_buffer_set_language()| here?
 
   // Shape the text.
   hb_shape(harfbuzz_font, buffer, NULL, 0);
 
   // Populate the run fields with the resulting glyph data in the buffer.
-  unsigned int glyph_count = 0;
-  hb_glyph_info_t* infos = hb_buffer_get_glyph_infos(buffer, &glyph_count);
-  hb_glyph_position_t* hb_positions = hb_buffer_get_glyph_positions(buffer,
-                                                                    NULL);
-  run->glyph_count = glyph_count;
+  hb_glyph_info_t* infos = hb_buffer_get_glyph_infos(buffer, &run->glyph_count);
+  hb_glyph_position_t* hb_positions =
+      hb_buffer_get_glyph_positions(buffer, NULL);
   run->glyphs.reset(new uint16[run->glyph_count]);
   run->glyph_to_char.reset(new uint32[run->glyph_count]);
   run->positions.reset(new SkPoint[run->glyph_count]);
+  run->width = 0;
   for (size_t i = 0; i < run->glyph_count; ++i) {
     run->glyphs[i] = infos[i].codepoint;
     run->glyph_to_char[i] = infos[i].cluster;
     const int x_offset =
         SkScalarRoundToInt(SkFixedToScalar(hb_positions[i].x_offset));
     const int y_offset =
         SkScalarRoundToInt(SkFixedToScalar(hb_positions[i].y_offset));
-    run->positions[i].set(run->width + x_offset, -y_offset);
+    run->positions[i].set(run->width + x_offset, y_offset);
     run->width +=
         SkScalarRoundToInt(SkFixedToScalar(hb_positions[i].x_advance));
   }
 
   hb_buffer_destroy(buffer);
   hb_font_destroy(harfbuzz_font);
 }
 
 }  // namespace gfx