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/utf16_indexing.h"
 
 #if defined(OS_WIN)
 #include "ui/gfx/font_smoothing_win.h"
 #endif
 
 namespace gfx {
 
 namespace {
 
@@ skipping 431 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;
+  size_t missing = 0;
   for (size_t i = 0; i < glyph_count; ++i) {
     if (glyphs[i] == kMissingGlyphId)

[msw, 2014/07/07 22:52:46]

optional nit: missing += glyphs[i] == kMissingGlyphId ? 1 : 0;
(you can remove the curly braces if you do that one-liner)

[ckocagil, 2014/07/12 11:47:54]

Done.

-      return true;
+      ++missing;
   }
-  return false;
+  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 464 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());
+  std::string best_font = primary_font.GetFontName();
+  size_t best_font_missing = -1;
+
+  for (size_t i = 0; 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());

[msw, 2014/07/07 22:52:46]

q: why are you removing this? Is |buffer| already initialized with
hb_language_get_default by hb_buffer_create, making this a trivial no-op?

[ckocagil, 2014/07/12 11:47:54]

Added back.

I had no idea what this did, so I decided to remove it and possibly add it back
when I got to the TODO. But I know what it does now, it is used to enable
language specific shaping features (even though Arabic and Urdu use the same
script, they look different).

+  // 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->width +=
         SkScalarRoundToInt(SkFixedToScalar(hb_positions[i].x_advance));
   }
 
   hb_buffer_destroy(buffer);
   hb_font_destroy(harfbuzz_font);
 }
 
 }  // namespace gfx