Optimize some code in RenderTextHarfbuzz.

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 <limits>
 #include <set>
 
 #include "base/i18n/bidi_line_iterator.h"
@@ skipping 627 matching lines @@
   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);
 }
 
-RangeF TextRunHarfBuzz::GetGraphemeBounds(
-    base::i18n::BreakIterator* grapheme_iterator,
-    size_t text_index) {
+RangeF TextRunHarfBuzz::GetGraphemeBounds(RenderTextHarfBuzz* render_text,
+                                          size_t text_index) {
   DCHECK_LT(text_index, range.end());
   if (glyph_count == 0)
     return RangeF(preceding_run_widths, preceding_run_widths + width);
 
   Range chars;
   Range glyphs;
   GetClusterAt(text_index, &chars, &glyphs);
   const float cluster_begin_x = positions[glyphs.start()].x();
   const float cluster_end_x = glyphs.end() < glyph_count ?
       positions[glyphs.end()].x() : SkFloatToScalar(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
   // graphemes. In order to place the cursor at a grapheme boundary inside the
   // cluster, we simply divide the cluster width by the number of graphemes.
-  if (chars.length() > 1 && grapheme_iterator) {
+  // Note: The first call to GetGraphemeIterator() can be expensive, so avoid
+  // doing it unless it's actually needed (when length > 1).
+  if (chars.length() > 1 && render_text->GetGraphemeIterator()) {
     int before = 0;
     int total = 0;
+    base::i18n::BreakIterator* grapheme_iterator =
+        render_text->GetGraphemeIterator();
     for (size_t i = chars.start(); i < chars.end(); ++i) {
       if (grapheme_iterator->IsGraphemeBoundary(i)) {
         if (i < text_index)
           ++before;
         ++total;
       }
     }
     DCHECK_GT(total, 0);
     if (total > 1) {
       if (is_rtl)
@@ skipping 183 matching lines @@
 Range RenderTextHarfBuzz::GetGlyphBounds(size_t index) {
   EnsureLayout();
   const size_t run_index =
       GetRunContainingCaret(SelectionModel(index, CURSOR_FORWARD));
   internal::TextRunList* run_list = GetRunList();
   // Return edge bounds if the index is invalid or beyond the layout text size.
   if (run_index >= run_list->size())
     return Range(GetStringSize().width());
   const size_t layout_index = TextIndexToDisplayIndex(index);
   internal::TextRunHarfBuzz* run = run_list->runs()[run_index];
-  RangeF bounds =
-      run->GetGraphemeBounds(GetGraphemeIterator(), layout_index);
+  RangeF bounds = run->GetGraphemeBounds(this, layout_index);
   // If cursor is enabled, extend the last glyph up to the rightmost cursor
   // position since clients expect them to be contiguous.
   if (cursor_enabled() && run_index == run_list->size() - 1 &&
       index == (run->is_rtl ? run->range.start() : run->range.end() - 1))
     bounds.set_end(std::ceil(bounds.end()));
   return run->is_rtl ? RangeF(bounds.end(), bounds.start()).Round()
                      : bounds.Round();
 }
 
+base::i18n::BreakIterator* RenderTextHarfBuzz::GetGraphemeIterator() {
+  if (update_grapheme_iterator_) {
+    update_grapheme_iterator_ = false;
+    grapheme_iterator_.reset(new base::i18n::BreakIterator(
+        GetDisplayText(), base::i18n::BreakIterator::BREAK_CHARACTER));
+    if (!grapheme_iterator_->Init())
+      grapheme_iterator_.reset();
+  }
+  return grapheme_iterator_.get();
+}
+
 int RenderTextHarfBuzz::GetDisplayTextBaseline() {
   EnsureLayout();
   return lines()[0].baseline;
 }
 
 SelectionModel RenderTextHarfBuzz::AdjacentCharSelectionModel(
     const SelectionModel& selection,
     VisualCursorDirection direction) {
   DCHECK(!update_display_run_list_);
 
@@ skipping 119 matching lines @@
   for (size_t i = 0; i < run_list->size(); ++i) {
     internal::TextRunHarfBuzz* run =
         run_list->runs()[run_list->visual_to_logical(i)];
     Range intersection = run->range.Intersect(layout_range);
     if (!intersection.IsValid())
       continue;
     DCHECK(!intersection.is_reversed());
     const size_t left_index =
         run->is_rtl ? intersection.end() - 1 : intersection.start();
     const Range leftmost_character_x =
-        run->GetGraphemeBounds(GetGraphemeIterator(), left_index).Round();
+        run->GetGraphemeBounds(this, left_index).Round();
     const size_t right_index =
         run->is_rtl ? intersection.start() : intersection.end() - 1;
     const Range rightmost_character_x =
-        run->GetGraphemeBounds(GetGraphemeIterator(), right_index).Round();
+        run->GetGraphemeBounds(this, right_index).Round();
     Range range_x(leftmost_character_x.start(), rightmost_character_x.end());
     DCHECK(!range_x.is_reversed());
     if (range_x.is_empty())
       continue;
 
     // Union this with the last range if they're adjacent.
     DCHECK(bounds.empty() || bounds.back().GetMax() <= range_x.GetMin());
     if (!bounds.empty() && bounds.back().GetMax() == range_x.GetMin()) {
       range_x = Range(bounds.back().GetMin(), range_x.GetMax());
       bounds.pop_back();
@@ skipping 524 matching lines @@
     update_display_text_ = true;
     update_layout_run_list_ = false;
   }
   if (update_display_text_) {
     UpdateDisplayText(multiline() ? 0 : layout_run_list_.width());
     update_display_text_ = false;
     update_display_run_list_ = text_elided();
   }
 }
 
-base::i18n::BreakIterator* RenderTextHarfBuzz::GetGraphemeIterator() {
-  if (update_grapheme_iterator_) {
-    update_grapheme_iterator_ = false;
-    grapheme_iterator_.reset(new base::i18n::BreakIterator(
-        GetDisplayText(),
-        base::i18n::BreakIterator::BREAK_CHARACTER));
-    if (!grapheme_iterator_->Init())
-      grapheme_iterator_.reset();
-  }
-  return grapheme_iterator_.get();
-}
-
 internal::TextRunList* RenderTextHarfBuzz::GetRunList() {
   DCHECK(!update_layout_run_list_);
   DCHECK(!update_display_run_list_);
   return text_elided() ? display_run_list_.get() : &layout_run_list_;
 }
 
 const internal::TextRunList* RenderTextHarfBuzz::GetRunList() const {
   return const_cast<RenderTextHarfBuzz*>(this)->GetRunList();
 }
 
 }  // namespace gfx