Break runs by clusters rather than iteration over code points

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 "base/i18n/bidi_line_iterator.h"
 #include "base/i18n/break_iterator.h"
@@ skipping 281 matching lines @@
         AdvanceLine();
     }
   }
 
   // Starting from |start_char|, finds a suitable line break position at or
   // before available width using word break. If the current position is at the
   // beginning of a line, this function will not roll back to |start_char| and
   // |*next_char| will be greater than |start_char| (to avoid constructing empty
   // lines).
   // Returns whether to skip the line before |*next_char|.
-  // TODO(ckocagil): Check clusters to avoid breaking ligatures and diacritics.
   // TODO(ckocagil): We might have to reshape after breaking at ligatures.
   //                 See whether resolving the TODO above resolves this too.
   // TODO(ckocagil): Do not reserve width for whitespace at the end of lines.
   bool BreakRunAtWidth(const internal::TextRunHarfBuzz& run,
                        size_t start_char,
                        SkScalar* width,
                        size_t* next_char) {
     DCHECK(words_);
     DCHECK(run.range.Contains(Range(start_char, start_char + 1)));
     SkScalar available_width = max_width_ - line_x_;
     BreakList<size_t>::const_iterator word = words_->GetBreak(start_char);
     BreakList<size_t>::const_iterator next_word = word + 1;
     // Width from |std::max(word->first, start_char)| to the current character.
     SkScalar word_width = 0;
     *width = 0;
 
-    for (size_t i = start_char; i < run.range.end(); ++i) {
+    Range char_range;
+    for (size_t i = start_char; i < run.range.end(); i += char_range.length()) {
       // |word| holds the word boundary at or before |i|, and |next_word| holds
       // the word boundary right after |i|. Advance both |word| and |next_word|
       // when |i| reaches |next_word|.
       if (next_word != words_->breaks().end() && i >= next_word->first) {
         word = next_word++;
         word_width = 0;
       }
 
-      Range glyph_range = run.CharRangeToGlyphRange(Range(i, i + 1));
+      Range glyph_range;
+      run.GetClusterAt(i, &char_range, &glyph_range);
+      DCHECK_LT(0U, char_range.length());
+
       SkScalar char_width = ((glyph_range.end() >= run.glyph_count)
                                  ? SkFloatToScalar(run.width)
                                  : run.positions[glyph_range.end()].x()) -
                             run.positions[glyph_range.start()].x();
 
       *width += char_width;
       word_width += char_width;
 
       if (*width > available_width) {
         if (line_x_ != 0 || word_width < *width) {
           // Roll back one word.
           *width -= word_width;
           *next_char = std::max(word->first, start_char);
         } else if (char_width < *width) {
           // Roll back one character.
           *width -= char_width;
           *next_char = i;
         } else {
           // Continue from the next character.
-          *next_char = i + 1;
+          *next_char = i + char_range.length();
         }
         return true;
       }
     }
 
     *next_char = run.range.end();
     return false;
   }
 
   // RTL runs are broken in logical order but displayed in visual order. To find
@@ skipping 1160 matching lines @@
   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