RenderTextHarfBuzz: Check CreateSkiaTypeface return value against NULL

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"
@@ skipping 436 matching lines @@
 
 TextRunHarfBuzz::~TextRunHarfBuzz() {}
 
 void TextRunHarfBuzz::GetClusterAt(size_t pos,
                                    Range* chars,
                                    Range* glyphs) const {
   DCHECK(range.Contains(Range(pos, pos + 1)));
   DCHECK(chars);
   DCHECK(glyphs);
 
+  if (glyph_count == 0) {
+    *chars = range;
+    *glyphs = Range();
+    return;
+  }
+
   if (is_rtl) {
     GetClusterAtImpl(pos, range, glyph_to_char.rbegin(), glyph_to_char.rend(),
         true, chars, glyphs);
     return;
   }
 
   GetClusterAtImpl(pos, range, glyph_to_char.begin(), glyph_to_char.end(),
       false, chars, glyphs);
 }
 
@@ skipping 17 matching lines @@
   size_t missing = 0;
   for (size_t i = 0; i < glyph_count; ++i)
     missing += (glyphs[i] == kMissingGlyphId) ? 1 : 0;
   return missing;
 }
 
 Range TextRunHarfBuzz::GetGraphemeBounds(
     base::i18n::BreakIterator* grapheme_iterator,
     size_t text_index) {
   DCHECK_LT(text_index, range.end());
+  if (glyph_count == 0)
+    return Range(preceding_run_widths, preceding_run_widths + width);
 
   Range chars;
   Range glyphs;
   GetClusterAt(text_index, &chars, &glyphs);
   const int cluster_begin_x = SkScalarRoundToInt(positions[glyphs.start()].x());
   const int cluster_end_x = glyphs.end() < glyph_count ?
       SkScalarRoundToInt(positions[glyphs.end()].x()) : width;
 
   // A cluster consists of a number of code points and corresponds to a number
   // of glyphs that should be drawn together. A cluster can contain multiple
@@ skipping 497 matching lines @@
   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();
   const std::string primary_font_name = primary_font.GetFontName();
   run->font_size = primary_font.GetFontSize();
 
+  size_t best_font_missing = std::numeric_limits<size_t>::max();
+  std::string best_font;
+  std::string current_font;
+
   // Try shaping with |primary_font|.
-  ShapeRunWithFont(run, primary_font_name);
-  size_t best_font_missing = run->CountMissingGlyphs();
-  if (best_font_missing == 0)
-    return;
-  std::string best_font = primary_font_name;
+  if (ShapeRunWithFont(run, primary_font_name)) {
+    current_font = primary_font_name;
+    size_t current_missing = run->CountMissingGlyphs();
+    if (current_missing == 0)
+      return;
+    if (current_missing < best_font_missing) {
+      best_font_missing = current_missing;
+      best_font = primary_font_name;

[msw, 2014/08/02 18:05:33]

nit: s/primary_font_name/current_font/

[ckocagil, 2014/08/03 03:36:54]

Done.

+    }
+  }
 
 #if defined(OS_WIN)
   Font uniscribe_font;
   const base::char16* run_text = &(GetLayoutText()[run->range.start()]);
   if (GetUniscribeFallbackFont(primary_font, run_text, run->range.length(),
-                               &uniscribe_font)) {
-    ShapeRunWithFont(run, uniscribe_font.GetFontName());
+                               &uniscribe_font) &&
+      ShapeRunWithFont(run, uniscribe_font.GetFontName())) {
+    current_font = 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();

[msw, 2014/08/02 18:05:33]

nit: s/uniscribe_font.GetFontName()/current_font/

[ckocagil, 2014/08/03 03:36:54]

Done.

     }
   }
 #endif
 
   // Try shaping with the fonts in the fallback list except the first, which is
   // |primary_font|.
   std::vector<std::string> fonts = GetFallbackFontFamilies(primary_font_name);
   for (size_t i = 1; i < fonts.size(); ++i) {
-    ShapeRunWithFont(run, fonts[i]);
+    if (!ShapeRunWithFont(run, fonts[i]))
+      continue;
+    current_font = 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];

[msw, 2014/08/02 18:05:33]

nit: s/fonts[i]/current_font/

[ckocagil, 2014/08/03 03:36:54]

Done.

     }
   }
 
-  ShapeRunWithFont(run, best_font);
+  if (!best_font.empty() &&
+      (best_font == current_font || ShapeRunWithFont(run, best_font))) {
+    return;
+  }
+
+  run->glyph_count = 0;
+  run->width = 0;
 }
 
-void RenderTextHarfBuzz::ShapeRunWithFont(internal::TextRunHarfBuzz* run,
+bool RenderTextHarfBuzz::ShapeRunWithFont(internal::TextRunHarfBuzz* run,
                                           const std::string& font_family) {
   const base::string16& text = GetLayoutText();
-  run->skia_face = internal::CreateSkiaTypeface(font_family, run->font_style);
+  skia::RefPtr<SkTypeface> skia_face =
+      internal::CreateSkiaTypeface(font_family, run->font_style);
+  if (skia_face == NULL)
+    return false;
+  run->skia_face = skia_face;
   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));
@@ skipping 22 matching lines @@
         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);
+  return true;
 }
 
 }  // namespace gfx