Stop combining text runs which are connected by 'COMMON' blocks.

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 31 matching lines @@
 // 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;
 
 // Returns true if characters of |block_code| may trigger font fallback.
 // Dingbats and emoticons can be rendered through the color emoji font file,
 // therefore it needs to be trigerred as fallbacks. See crbug.com/448909
 bool IsUnusualBlockCode(UBlockCode block_code) {
   return block_code == UBLOCK_GEOMETRIC_SHAPES ||
-         block_code == UBLOCK_MISCELLANEOUS_SYMBOLS ||
-         block_code == UBLOCK_DINGBATS ||
-         block_code == UBLOCK_EMOTICONS;
+         block_code == UBLOCK_MISCELLANEOUS_SYMBOLS;
 }
 
 bool IsBracket(UChar32 character) {
   static const char kBrackets[] = { '(', ')', '{', '}', '<', '>', };
   static const char* kBracketsEnd = kBrackets + arraysize(kBrackets);
   return std::find(kBrackets, kBracketsEnd, character) != kBracketsEnd;
 }
 
 // Returns the boundary between a special and a regular character. Special
 // characters are brackets or characters that satisfy |IsUnusualBlockCode|.
@@ skipping 18 matching lines @@
     const bool block_break = current_block != first_block &&
         (first_block_unusual || IsUnusualBlockCode(current_block));
     if (block_break || current_char == '\n' ||
         first_bracket != IsBracket(current_char)) {
       return run_start + iter.array_pos();
     }
   }
   return run_break;
 }
 
-// If the given scripts match, returns the one that isn't USCRIPT_COMMON or
-// USCRIPT_INHERITED, i.e. the more specific one. Otherwise returns
+// If the given scripts match, returns the one that isn't USCRIPT_INHERITED,
+// i.e. the more specific one. Otherwise returns
 // USCRIPT_INVALID_CODE.
 UScriptCode ScriptIntersect(UScriptCode first, UScriptCode second) {
-  if (first == second ||
-      (second > USCRIPT_INVALID_CODE && second <= USCRIPT_INHERITED)) {
+  if (first == second || second == USCRIPT_INHERITED)
     return first;
-  }
-  if (first > USCRIPT_INVALID_CODE && first <= USCRIPT_INHERITED)
+  if (first == USCRIPT_INHERITED)
     return second;
   return USCRIPT_INVALID_CODE;
 }
 
 // Writes the script and the script extensions of the character with the
 // Unicode |codepoint|. Returns the number of written scripts.
 int GetScriptExtensions(UChar32 codepoint, UScriptCode* scripts) {
   UErrorCode icu_error = U_ZERO_ERROR;
   // ICU documentation incorrectly states that the result of
   // |uscript_getScriptExtensions| will contain the regular script property.
@@ skipping 47 matching lines @@
                    UScriptCode* script) {
   DCHECK_GT(length, 0U);
 
   UScriptCode scripts[kMaxScripts] = { USCRIPT_INVALID_CODE };
 
   base::i18n::UTF16CharIterator char_iterator(text.c_str() + start, length);
   size_t scripts_size = GetScriptExtensions(char_iterator.get(), scripts);
   *script = scripts[0];
 
   while (char_iterator.Advance()) {
+    // Special handling to merge white space into the previous run.
+    if (u_isUWhiteSpace(char_iterator.get()))
+      continue;
     ScriptSetIntersect(char_iterator.get(), scripts, &scripts_size);
     if (scripts_size == 0U)
       return char_iterator.array_pos();
     *script = scripts[0];
   }
 
   return length;
 }
 
 // A port of hb_icu_script_to_script because harfbuzz on CrOS is built without
@@ skipping 50 matching lines @@
                       const BreakList<size_t>* words,
                       const internal::TextRunList& run_list)
       : max_width_((max_width == 0) ? SK_ScalarMax : SkIntToScalar(max_width)),
         min_baseline_(min_baseline),
         min_height_(min_height),
         multiline_(multiline),
         word_wrap_behavior_(word_wrap_behavior),
         text_(text),
         words_(words),
         run_list_(run_list),
+        max_descent_(0),
+        max_ascent_(0),
         text_x_(0),
-        line_x_(0),
-        max_descent_(0),
-        max_ascent_(0) {
+        available_width_(max_width_) {
     DCHECK_EQ(multiline_, (words_ != nullptr));
-    AdvanceLine();
+    RunLineBreaking();
   }
 
-  // Breaks the run at given |run_index| into Line structs.
-  void AddRun(int run_index) {
-    const internal::TextRunHarfBuzz* run = run_list_.runs()[run_index];
-    base::char16 first_char = text_[run->range.start()];
-    if (multiline_ && first_char == '\n') {
-      AdvanceLine();
-    } else if (multiline_ && (line_x_ + SkFloatToScalar(run->width)) >
-               max_width_) {
-      BreakRun(run_index);
-    } else {
-      AddSegment(run_index, run->range, run->width);
-    }
-  }
-
-  // Finishes line breaking and outputs the results. Can be called at most once.
-  void Finalize(std::vector<internal::Line>* lines, SizeF* size) {
-    DCHECK(!lines_.empty());
-    // Add an empty line to finish the line size calculation and remove it.
-    AdvanceLine();
-    lines_.pop_back();
-    *size = total_size_;
-    lines->swap(lines_);
-  }
+  std::vector<internal::Line> GetLines() const { return lines_; }

[Jun Mukai, 2015/05/15 20:16:01]

Do not do this. This copies all of the line structure. The point of old
Finalize() is avoid copying but simply passing the line structures.

[xdai1, 2015/05/15 23:41:17]

Removed it and passed values through FinalizeLines().

+  SizeF GetTotalSize() const { return total_size_; }
 
  private:
   // A (line index, segment index) pair that specifies a segment in |lines_|.
   typedef std::pair<size_t, size_t> SegmentHandle;
 
   internal::LineSegment* SegmentFromHandle(const SegmentHandle& handle) {
     return &lines_[handle.first].segments[handle.second];
   }
 
-  // Breaks a run into segments that fit in the last line in |lines_| and adds
-  // them. Adds a new Line to the back of |lines_| whenever a new segment can't
-  // be added without the Line's width exceeding |max_width_|.
-  void BreakRun(int run_index) {
-    const internal::TextRunHarfBuzz& run = *(run_list_.runs()[run_index]);
-    SkScalar width = 0;
-    size_t next_char = run.range.start();
+  // Runs line breaking algorithm and break |text_| into lines if applicable.
+  void RunLineBreaking() {

[Jun Mukai, 2015/05/15 20:16:00]

I don't think this method is necessary.

- revert back to AdvanceLine() in the constructor
- modify the invocation of HarfBuzzLineBreaker as:
HarfBuzzLineBreaker line_breaker(...);
if (multiline())
  line_breaker.ConstructSingleLine();
else
  line_breaker.ConstructMultiLines();
line_breaker.FinalizeLines(&lines, &size);

- then remove 'multiline_' flag from HarfBuzzLineBreaker.

This way you can even remove multiline_ flag.

[xdai1, 2015/05/15 23:41:17]

Done.

+    AdvanceLine();
+    if (!multiline_)
+      ConstructSingleLine();
+    else
+      ConstructMultiLines();
+    // Finishes line breaking and calculates the line size.
+    FinalizeLines();
+  }
 
-    // Break the run until it fits the current line.
-    while (next_char < run.range.end()) {
-      const size_t current_char = next_char;
-      size_t end_char = next_char;
-      const bool skip_line =
-          BreakRunAtWidth(run, current_char, &width, &end_char, &next_char);
-      AddSegment(run_index, Range(current_char, end_char),
-                 SkScalarToFloat(width));
-      if (skip_line)
+  // Constructs a single line for |text_| using |run_list_|.
+  void ConstructSingleLine() {
+    for (auto iter = run_list_.runs().begin(); iter != run_list_.runs().end();

[Jun Mukai, 2015/05/15 20:16:00]

It's better to use 'for (size_t i = 0; i < run_list_.size(); ++i) { ... }'

[xdai1, 2015/05/15 23:41:17]

Done. but I don't know why...

+         iter++) {
+      internal::LineSegment segment;
+      segment.run = std::distance(run_list_.runs().begin(), iter);
+      segment.char_range = (*iter)->range;
+      segment.x_range = Range(SkScalarCeilToInt(text_x_),
+                              SkScalarCeilToInt(text_x_ + (*iter)->width));
+      segment.width = (*iter)->width;
+      AddLineSegment(segment);
+    }
+  }
+
+  // Constructs multiple lines for |text_| based on words iteration approach.
+  void ConstructMultiLines() {
+    for (auto iter = words_->breaks().begin(); iter != words_->breaks().end();
+         iter++) {

[Jun Mukai, 2015/05/15 20:16:00]

for (const auto& word : words_->breaks()) { ... }

[xdai1, 2015/05/15 23:41:18]

Done.

+      std::vector<internal::LineSegment> word_segments;
+      SkScalar word_width = GetWordWidth(iter, word_segments);
+
+      bool new_line = false;
+      if (!word_segments.empty()) {
+        // If the word is end with '\n', we should advance a new line after
+        // adding the word to current line.
+        internal::LineSegment last_segment = word_segments.back();

[Jun Mukai, 2015/05/15 20:15:59]

const internal::LineSegment&

[xdai1, 2015/05/15 23:41:17]

Done.

+        base::char16 last_char = text_[last_segment.char_range.start()];

[Jun Mukai, 2015/05/15 20:16:00]

const base::char16

[xdai1, 2015/05/15 23:41:18]

Done.

+        if (last_char == '\n') {
+          new_line = true;
+          word_width -= last_segment.width;
+          word_segments.pop_back();
+        }
+      }
+
+      // If the word is not the first word in the line and it can't fit into
+      // the current line, advance a new line.
+      if (word_width > available_width_ && available_width_ != max_width_)
+        AdvanceLine();

[Jun Mukai, 2015/05/15 20:16:00]

I think this is not necessary, and if behavior is WRAP_LONG_WORDS and input is
"aa bbbbbb cc" (with max_width_ = 4 chars), your result is:
aa
bbbb
bb
cc

But expected result is
aa b
bbbb
b cc


Just remove these two lines, AddWordToLine() can handle AdvanceLine().

[xdai1, 2015/05/15 23:41:18]

As we discussed offline, this logic is still needed.

+      AddWordToLine(word_segments);
+      if (new_line)
         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). It stores the end of the segment range to |end_char|, which can be
-  // smaller than |*next_char| for certain word wrapping behavior.
-  // Returns whether to skip the line before |*next_char|.
-  // 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* end_char,
-                       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;
-
-    Range char_range;
-    SkScalar truncated_width = 0;
-    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) {
-        if (*width > available_width) {
-          DCHECK_NE(WRAP_LONG_WORDS, word_wrap_behavior_);
-          *next_char = i;
-          if (word_wrap_behavior_ != TRUNCATE_LONG_WORDS)
-            *end_char = *next_char;
-          else
-            *width = truncated_width;
-          return true;
-        }
-        word = next_word++;
-        word_width = 0;
-      }
-
-      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;
-
-      // TODO(mukai): implement ELIDE_LONG_WORDS.
-      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);
-          *end_char = *next_char;
-          return true;
-        } else if (word_wrap_behavior_ == WRAP_LONG_WORDS) {
-          if (char_width < *width) {
-            // Roll back one character.
-            *width -= char_width;
-            *next_char = i;
-          } else {
-            // Continue from the next character.
-            *next_char = i + char_range.length();
-          }
-          *end_char = *next_char;
-          return true;
-        }
-      } else {
-        *end_char = char_range.end();
-        truncated_width = *width;
-      }
-    }
-
-    if (word_wrap_behavior_ == TRUNCATE_LONG_WORDS)
-      *width = truncated_width;
-    *end_char = *next_char = run.range.end();
-    return false;
-  }
-
-  // RTL runs are broken in logical order but displayed in visual order. To find
-  // the text-space coordinate (where it would fall in a single-line text)
-  // |x_range| of RTL segments, segment widths are applied in reverse order.
-  // e.g. {[5, 10], [10, 40]} will become {[35, 40], [5, 35]}.
-  void UpdateRTLSegmentRanges() {
-    if (rtl_segments_.empty())
-      return;
-    float x = SegmentFromHandle(rtl_segments_[0])->x_range.start();
-    for (size_t i = rtl_segments_.size(); i > 0; --i) {
-      internal::LineSegment* segment = SegmentFromHandle(rtl_segments_[i - 1]);
-      const float segment_width = segment->width;
-      segment->x_range = Range(x, x + segment_width);
-      x += segment_width;
-    }
-    rtl_segments_.clear();
-  }
-
   // Finishes the size calculations of the last Line in |lines_|. Adds a new
   // Line to the back of |lines_|.
   void AdvanceLine() {
     if (!lines_.empty()) {
       internal::Line* line = &lines_.back();
       std::sort(line->segments.begin(), line->segments.end(),
                 [this](const internal::LineSegment& s1,
                        const internal::LineSegment& s2) -> bool {
                   return run_list_.logical_to_visual(s1.run) <
                          run_list_.logical_to_visual(s2.run);
                 });
       line->size.set_height(std::max(min_height_, max_descent_ + max_ascent_));
-      line->baseline =
-          std::max(min_baseline_, SkScalarRoundToInt(max_ascent_));
+      line->baseline = std::max(min_baseline_, SkScalarRoundToInt(max_ascent_));
       line->preceding_heights = std::ceil(total_size_.height());
       total_size_.set_height(total_size_.height() + line->size.height());
       total_size_.set_width(std::max(total_size_.width(), line->size.width()));
     }
     max_descent_ = 0;
     max_ascent_ = 0;
-    line_x_ = 0;
+    available_width_ = max_width_;
     lines_.push_back(internal::Line());
   }
 
-  // Adds a new segment with the given properties to |lines_.back()|.
-  void AddSegment(int run_index, Range char_range, float width) {
-    if (char_range.is_empty()) {
-      DCHECK_EQ(0, width);
+  // Adds word to the current line. A word may contain multiple segments. If the
+  // word is the first word in line and its width exceeds |available_width_|,
+  // ignore/truncate/wrap it according to |word_wrap_behavior_|.
+  void AddWordToLine(std::vector<internal::LineSegment>& segments) {

[Jun Mukai, 2015/05/15 20:16:00]

const std::vector<internal::LineSegment>&

[xdai1, 2015/05/15 23:41:18]

This can't be const since the element inside of the vector might be modified.
See line 381-384 in this patch.

[Jun Mukai, 2015/05/16 00:21:56]

If you really need to modify this parameter, pass it as a pointer. Again, any
non-const reference parameters are disallowed explicitly.  No exceptions.


However, I think the point of modifying segment is char_range, x_range, and
width. You can declare the local variables right before while such like
Range char_range = segment.char_range;
Range x_range = segment.x_range;
SkScalar width = segment.width;
while (...) {
}

This way you don't have to modify segments, and word_segments can be const.

[xdai1, 2015/05/18 17:41:26]

Done.

+    if (segments.empty() || lines_.empty())

[Jun Mukai, 2015/05/15 20:16:00]

lines_ shouldn't be empty, because AdvanceLine() must be called, right?
DCHECK(!lines_.empty()); and remove lines_.empty() check in if.

[xdai1, 2015/05/15 23:41:17]

Done.

       return;
+
+    bool has_truncated = false;
+    for (auto iter = segments.begin(); iter != segments.end(); iter++) {

[Jun Mukai, 2015/05/15 20:16:00]

for (const internal::LineSegment& segment : segments) { ... }

[xdai1, 2015/05/15 23:41:17]

Same as previous one, segment can't be const since it might need to be modified
in line 381-384.

+      if (has_truncated)
+        break;
+      internal::LineSegment segment = *iter;
+      if (segment.width <= available_width_ ||
+          word_wrap_behavior_ == IGNORE_LONG_WORDS) {
+        AddLineSegment(segment);
+      } else {
+        DCHECK(word_wrap_behavior_ != IGNORE_LONG_WORDS);

[Jun Mukai, 2015/05/15 20:16:01]

DCHECK(word_wrap_behavior_ == TRUNCATE_LONG_WORDS || word_wrap_behavior_ ==
WRAP_LONG_WORDS);

IGNORE_LONG_WORDS is already tested at line 348, you don't have to check again.
I believe the point is, this section only supports TRUNCATE_LONG_WORDS and
WRAP_LONG_WORDS.

[xdai1, 2015/05/15 23:41:17]

Done.

+        has_truncated = (word_wrap_behavior_ == TRUNCATE_LONG_WORDS);
+
+        while (!segment.char_range.is_empty()) {
+          size_t cutoff_pos;

[Jun Mukai, 2015/05/15 20:16:00]

size_t cutoff_pos = 0;

[xdai1, 2015/05/15 23:41:17]

Done.

+          SkScalar width =
+              GetCutoffWidth(segment, segment.char_range.start(), cutoff_pos);
+          if (width == 0 && available_width_ == max_width_) {
+            // |max_width_| might be smaller than a single character. In this
+            // case we need to put at least one character in the line.
+            // See RenderTextTest.Multiline_MinWidth for example.
+            cutoff_pos = segment.char_range.start() + 1;
+            const internal::TextRunHarfBuzz& run =
+                *(run_list_.runs()[segment.run]);
+            Range char_range = Range(segment.char_range.start(), cutoff_pos);
+            Range glyph_range = run.CharRangeToGlyphRange(char_range);
+            width = ((glyph_range.end() >= run.glyph_count)
+                         ? SkFloatToScalar(run.width)
+                         : run.positions[glyph_range.end()].x()) -
+                    run.positions[glyph_range.start()].x();

[Jun Mukai, 2015/05/15 20:16:01]

Looks like it's better to add a new method to HarfBuzzTextRun for SkScalar
GetWidthForGlyphRange(const Range& range); to do this.

[xdai1, 2015/05/15 23:41:17]

Done. Also adjusted some functions' sequence to consist with the header file.

+          }
+          if (width > 0) {
+            internal::LineSegment cut_segment;
+            cut_segment.run = segment.run;
+            cut_segment.char_range =
+                Range(segment.char_range.start(), cutoff_pos);
+            cut_segment.width = width;
+            cut_segment.x_range = Range(segment.x_range.start(),
+                                        SkScalarCeilToInt(text_x_ + width));
+            AddLineSegment(cut_segment);
+            // Updates old segment.
+            segment.char_range.set_start(cutoff_pos);
+            segment.x_range.set_start(SkScalarCeilToInt(text_x_));
+            segment.width -= width;
+          }
+          if (has_truncated)
+            break;
+          if (!segment.char_range.is_empty())
+            AdvanceLine();
+        }
+      }
     }
-    const internal::TextRunHarfBuzz& run = *(run_list_.runs()[run_index]);
+  }
 
-    internal::LineSegment segment;
-    segment.run = run_index;
-    segment.char_range = char_range;
-    segment.x_range = Range(
-        SkScalarCeilToInt(text_x_),
-        SkScalarCeilToInt(text_x_ + SkFloatToScalar(width)));
-    segment.width = width;
-
+  // Add line segment to current line. Note in order to keep the visual order
+  // correct for ltr and rtl language, we need to merge segments that belong to
+  // a same run.
+  void AddLineSegment(internal::LineSegment& segment) {

[Jun Mukai, 2015/05/15 20:16:00]

const internal::LineSegment&

[xdai1, 2015/05/15 23:41:18]

It can't be const since it might be modified in line 405-409 in this patch.

[Jun Mukai, 2015/05/16 00:21:56]

In that case please pass as the pointer.  Our coding style explicitly disallows
non-const reference parameters.

+    DCHECK(!lines_.empty());
     internal::Line* line = &lines_.back();
+    const internal::TextRunHarfBuzz& run = *(run_list_.runs()[segment.run]);
+    if (!line->segments.empty()) {
+      internal::LineSegment last_segment = line->segments.back();

[Jun Mukai, 2015/05/15 20:16:01]

internal::LineSegment& last_segment = line_segments->back();  (or
internal::LineSegment* last_segment = &line_segments->back(); ), then modify it
directly, and return.

[xdai1, 2015/05/15 23:41:17]

Done. And also make last_segment const.

[Jun Mukai, 2015/05/16 00:21:56]

No.  My intention was, if the last_segment and segment shares the same run, just
modify the last_segment and abandon segment.

computation in line 420-440 is per-run, so you don't have to do it again.  What
I'm thinking is (I may miss some but):

if (last_segment.run == segment.run) {
  // Simply adding |segment| data into |last_segment|.
  last_segment->char_range.set_end(segment.run.char_range.end());
  last_segment->width += segment.width;
  last_segment->x_range.set_end(last_segment->x_range.start() +
SkScalarCeilToInt(last_segment->width));
  line->size.set_width(line->size.width() + segment.width());
  text_x_ += segment.width;
  available_width_ -= segment.width;
  return;
}

[xdai1, 2015/05/18 17:41:26]

You're right. We can modify last_segment and keep segment const. Done.

+      // Merge segments that belong to the same run.
+      if (last_segment.run == segment.run) {
+        segment.char_range.set_start(last_segment.char_range.start());
+        segment.width += last_segment.width;
+        segment.x_range.set_start(
+            SkScalarCeilToInt(text_x_ - last_segment.width));
+        line->segments.pop_back();
+        if (run.is_rtl)
+          rtl_segments_.pop_back();
+        line->size.set_width(line->size.width() - last_segment.width);
+        text_x_ -= last_segment.width;
+        available_width_ += last_segment.width;
+      }
+    }
     line->segments.push_back(segment);
 
     SkPaint paint;
     paint.setTypeface(run.skia_face.get());
     paint.setTextSize(SkIntToScalar(run.font_size));
     paint.setAntiAlias(run.render_params.antialiasing);
     SkPaint::FontMetrics metrics;
     paint.getFontMetrics(&metrics);
 
-    line->size.set_width(line->size.width() + width);
+    line->size.set_width(line->size.width() + segment.width);
     // TODO(dschuyler): Account for stylized baselines in string sizing.
     max_descent_ = std::max(max_descent_, metrics.fDescent);
     // fAscent is always negative.
     max_ascent_ = std::max(max_ascent_, -metrics.fAscent);
 
     if (run.is_rtl) {
       rtl_segments_.push_back(
           SegmentHandle(lines_.size() - 1, line->segments.size() - 1));
       // If this is the last segment of an RTL run, reprocess the text-space x
       // ranges of all segments from the run.
-      if (char_range.end() == run.range.end())
+      if (segment.char_range.end() == run.range.end())
         UpdateRTLSegmentRanges();
     }
-    text_x_ += SkFloatToScalar(width);
-    line_x_ += SkFloatToScalar(width);
+    text_x_ += segment.width;
+    available_width_ -= segment.width;
+  }
+
+  // Starts from |st_pos|, find the end position |en_pos| that the preceding
+  // width is no larger than |available_width_|, and return the preceding width.
+  SkScalar GetCutoffWidth(internal::LineSegment segment,

[Jun Mukai, 2015/05/15 20:16:00]

const internal::LineSegment&

[xdai1, 2015/05/15 23:41:18]

Done.

+                          size_t st_pos,

[Jun Mukai, 2015/05/15 20:16:00]

Remove st_pos. It always starts from segment.char_range.start() right?

[xdai1, 2015/05/15 23:41:18]

Done.

+                          size_t& en_pos) {

[Jun Mukai, 2015/05/15 20:16:00]

Return value is passed by a pointer, do not use nonconst reference as a
parameter.
See:
https://google-styleguide.googlecode.com/svn/trunk/cppguide.html#Reference_Ar...

Also I prefer naming 'end_pos'

Also make this method a const method -- GetCutoffWidth(...) const { ... }

[xdai1, 2015/05/15 23:41:17]

I see. Thanks! Done.

+    DCHECK(segment.char_range.Contains(Range(st_pos, st_pos + 1)));
+    const internal::TextRunHarfBuzz& run = *(run_list_.runs()[segment.run]);
+    en_pos = st_pos;
+    SkScalar width = 0;
+    while (en_pos < segment.char_range.end()) {
+      Range char_range;
+      Range glyph_range;
+      run.GetClusterAt(en_pos, &char_range, &glyph_range);
+      SkScalar char_width = ((glyph_range.end() >= run.glyph_count)

[Jun Mukai, 2015/05/15 20:16:00]

const SkScalar

[xdai1, 2015/05/15 23:41:17]

Done.

+                                 ? SkFloatToScalar(run.width)
+                                 : run.positions[glyph_range.end()].x()) -
+                            run.positions[glyph_range.start()].x();
+      if (width + char_width > available_width_)
+        break;
+      width += char_width;
+      en_pos++;
+    }
+    return width;
+  }
+
+  // Gets the glyph width for |word|, and splits the |word| into different
+  // segments based on its runs.
+  SkScalar GetWordWidth(BreakList<size_t>::const_iterator word,
+                        std::vector<internal::LineSegment>& segments) {

[Jun Mukai, 2015/05/15 20:16:00]

std::vector<internal::LineSegment>*
Also make this a const method.

[xdai1, 2015/05/15 23:41:17]

Done.

+    if (word == words_->breaks().end())
+      return 0;
+    int word_st = word->first;
+    int word_en = (word + 1 == words_->breaks().end()) ? text_.size() - 1
+                                                       : (word + 1)->first - 1;
+    if (word_en < 0 || word_en < word_st)
+      return 0;
+    size_t run_st_idx = run_list_.GetRunIndexAt(word_st);
+    size_t run_en_idx = run_list_.GetRunIndexAt(word_en);
+    SkScalar width = 0;
+    for (size_t idx = run_st_idx; idx <= run_en_idx; idx++) {
+      const internal::TextRunHarfBuzz& run = *(run_list_.runs()[idx]);
+      Range char_range = run.range.Intersect(Range(word_st, word_en + 1));
+      Range glyph_range = run.CharRangeToGlyphRange(char_range);
+      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;
+
+      internal::LineSegment segment;
+      segment.run = idx;
+      segment.char_range = char_range;
+      segment.width = char_width;
+      segment.x_range = Range(SkScalarCeilToInt(text_x_ + width - char_width),
+                              SkScalarCeilToInt(text_x_ + width));
+      segments.push_back(segment);
+    }
+    return width;
+  }
+
+  // Finishes line breaking algorithm.
+  void FinalizeLines() {
+    DCHECK(!lines_.empty());
+    // Add an empty line to finish the line size calculation and remove it.
+    AdvanceLine();
+    lines_.pop_back();
+  }
+
+  // RTL runs are broken in logical order but displayed in visual order. To find
+  // the text-space coordinate (where it would fall in a single-line text)
+  // |x_range| of RTL segments, segment widths are applied in reverse order.
+  // e.g. {[5, 10], [10, 40]} will become {[35, 40], [5, 35]}.
+  void UpdateRTLSegmentRanges() {
+    if (rtl_segments_.empty())
+      return;
+    float x = SegmentFromHandle(rtl_segments_[0])->x_range.start();
+    for (size_t i = rtl_segments_.size(); i > 0; --i) {
+      internal::LineSegment* segment = SegmentFromHandle(rtl_segments_[i - 1]);
+      const float segment_width = segment->width;
+      segment->x_range = Range(x, x + segment_width);
+      x += segment_width;
+    }
+    rtl_segments_.clear();
   }
 
   const SkScalar max_width_;
   const int min_baseline_;
   const float min_height_;
   const bool multiline_;
   const WordWrapBehavior word_wrap_behavior_;
   const base::string16& text_;
   const BreakList<size_t>* const words_;
   const internal::TextRunList& run_list_;
 
   // Stores the resulting lines.
   std::vector<internal::Line> lines_;
 
-  // Text space and line space x coordinates of the next segment to be added.
-  SkScalar text_x_;
-  SkScalar line_x_;
-
   float max_descent_;
   float max_ascent_;
 
+  // Text space x coordinates of the next segment to be added.
+  SkScalar text_x_;
+  // Stores available width in the current line.
+  SkScalar available_width_;
+
   // Size of the multiline text, not including the currently processed line.
   SizeF total_size_;
 
   // The current RTL run segments, to be applied by |UpdateRTLSegmentRanges()|.
   std::vector<SegmentHandle> rtl_segments_;
 
   DISALLOW_COPY_AND_ASSIGN(HarfBuzzLineBreaker);
 };
 
 // Function object for case insensitive string comparison.
@@ skipping 151 matching lines @@
 void TextRunList::ComputePrecedingRunWidths() {
   // Precalculate run width information.
   width_ = 0.0f;
   for (size_t i = 0; i < runs_.size(); ++i) {
     TextRunHarfBuzz* run = runs_[visual_to_logical_[i]];
     run->preceding_run_widths = width_;
     width_ += run->width;
   }
 }
 
+size_t TextRunList::GetRunIndexAt(size_t position) const {
+  for (size_t i = 0; i < runs_.size(); ++i) {
+    if (runs_[i]->range.start() <= position && runs_[i]->range.end() > position)
+      return i;
+  }
+  return runs_.size();
+}
+
 }  // namespace internal
 
 RenderTextHarfBuzz::RenderTextHarfBuzz()
     : RenderText(),
       update_layout_run_list_(false),
       update_display_run_list_(false),
       update_grapheme_iterator_(false),
       update_display_text_(false),
       glyph_width_for_test_(0u) {
   set_truncate_length(kMaxTextLength);
@@ skipping 334 matching lines @@
 
     internal::TextRunList* run_list = GetRunList();
     HarfBuzzLineBreaker line_breaker(
         display_rect().width(), font_list().GetBaseline(),
         std::max(font_list().GetHeight(), min_line_height()), multiline(),
         word_wrap_behavior(), GetDisplayText(),
         multiline() ? &GetLineBreaks() : nullptr, *run_list);
 
     tracking_profile.reset();
 
-    for (size_t i = 0; i < run_list->size(); ++i)
-      line_breaker.AddRun(i);
-    std::vector<internal::Line> lines;
-    line_breaker.Finalize(&lines, &total_size_);
+    std::vector<internal::Line> lines = line_breaker.GetLines();
     set_lines(&lines);
+    total_size_ = line_breaker.GetTotalSize();
   }
 }
 
 void RenderTextHarfBuzz::DrawVisualText(Canvas* canvas) {
   internal::SkiaTextRenderer renderer(canvas);
   DrawVisualTextInternal(&renderer);
 }
 
 void RenderTextHarfBuzz::DrawVisualTextInternal(
     internal::SkiaTextRenderer* renderer) {
@@ skipping 447 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