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 33 matching lines @@
 // 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;

[Jun Mukai, 2015/05/11 05:14:38]

Remove these special cases of DINGBATS and EMOTICIONS, which was added by me for
a workaround of weird emoji characters. They are 'COMMON' scripts, therefore
these special cases are not necessary after your patch.

[xdai1, 2015/05/11 21:55:22]

Done.

 }
 
 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
-// USCRIPT_INVALID_CODE.
+// 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 53 matching lines @@
         min_baseline_(min_baseline),
         min_height_(min_height),
         multiline_(multiline),
         word_wrap_behavior_(word_wrap_behavior),
         text_(text),
         words_(words),
         run_list_(run_list),
         text_x_(0),
         line_x_(0),
         max_descent_(0),
-        max_ascent_(0) {
+        max_ascent_(0),
+        next_char_pos_(0),
+        word_width_(0) {
     DCHECK_EQ(multiline_, (words_ != nullptr));
     AdvanceLine();
   }
 
   // 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);
+      return;
+    }
+
+    int ignored_char_offset = 0;
+    SkScalar ignored_width = 0;
+    if (multiline_ && word_wrap_behavior_ == TRUNCATE_LONG_WORDS ) {

[Jun Mukai, 2015/05/11 05:14:38]

This logic looks fairly complicated.  I don't get why.  Why don't you integrate
this into BreakRunAtWidth?

I think your logic here is to skip runs when its width is totally hidden by
available_width. You can do that with modifying BreakRunAtWidth().  This way,
you'll have to have a minor fix on BreakRun() to avoid adding segments if
BreakRunAtWidth()'s result is an empty segment.

[xdai1, 2015/05/11 21:55:22]

Done.

+      // Check if the run needs to be fully or partially ignored.
+      if (run->range.start() < next_char_pos_) {
+        BreakList<size_t>::const_iterator first_word_in_run =
+            words_->GetBreak(run->range.start());
+        BreakList<size_t>::const_iterator last_word_in_run =
+            words_->GetBreak(run->range.end() - 1);
+        if (first_word_in_run == last_word_in_run) {
+          // The run's range is fully covered by the current word.
+          return;
+        } else {
+          // The run contains multiple words, calculate |ignored_char_offset|
+          // and |ignored_width|.
+          BreakList<size_t>::const_iterator next_word = first_word_in_run + 1;
+          ignored_char_offset = next_word->first - run->range.start();
+          Range ignored_char_range(run->range.start(), next_word->first);
+          Range ignored_glyph_range =
+              run->CharRangeToGlyphRange(ignored_char_range);
+          ignored_width =
+              ((ignored_glyph_range.end() >= run->glyph_count)
+                  ? SkFloatToScalar(run->width)
+                  : run->positions[ignored_glyph_range.end()].x()) -
+              run->positions[ignored_glyph_range.start()].x();
+        }
+      }
+    }
+
+    if (multiline_ && line_x_ != 0) {
+      // If the following word is not the first word in the current line and
+      //  can't be fit into the current line, advance a new line.
+      BreakList<size_t>::const_iterator word =
+          words_->GetBreak(run->range.start());
+      if (run->range.start() == word->first &&
+          line_x_ + GetWordWidth(word) - ignored_width > max_width_) {
+        AdvanceLine();
+      }
+    }
+
+    if (multiline_ &&
+        (line_x_ + SkFloatToScalar(run->width) - ignored_width) > max_width_) {
+      BreakRun(run_index, ignored_char_offset);
     } else {
-      AddSegment(run_index, run->range, run->width);
+      Range char_range(run->range.start() + ignored_char_offset,
+                       run->range.end());
+      AddSegment(run_index, char_range, run->width - ignored_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_);
   }
 
  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];
   }
 
+  SkScalar GetWordWidth(BreakList<size_t>::const_iterator word) {
+    if (word == words_->breaks().end())
+      return 0;
+    size_t word_st = word->first;
+    size_t word_en = (word + 1 == words_->breaks().end())
+                         ? text_.size()
+                         : (word + 1)->first;
+    internal::TextRunList::TextRunHarfBuzzIter run_st =
+        run_list_.GetRunAt(word_st);
+    internal::TextRunList::TextRunHarfBuzzIter run_en =
+        run_list_.GetRunAt(word_en);
+    SkScalar width = 0;
+    for (auto iter = run_st; iter != run_en; iter++) {
+      Range char_range = (*iter)->range.Intersect(Range(word_st, word_en));
+      Range glyph_range = (*iter)->CharRangeToGlyphRange(char_range);
+      SkScalar char_width = ((glyph_range.end() >= (*iter)->glyph_count)
+                                 ? SkFloatToScalar((*iter)->width)
+                                 : (*iter)->positions[glyph_range.end()].x()) -
+                            (*iter)->positions[glyph_range.start()].x();
+      width += char_width;
+    }
+    return width;
+  }
+
   // 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) {
+  void BreakRun(int run_index, int ignored_offset) {
     const internal::TextRunHarfBuzz& run = *(run_list_.runs()[run_index]);
     SkScalar width = 0;
-    size_t next_char = run.range.start();
+    next_char_pos_ = run.range.start() + ignored_offset;
 
     // 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;
+    while (next_char_pos_ < run.range.end()) {
+      const size_t current_char = next_char_pos_;
+      size_t end_char = next_char_pos_;
       const bool skip_line =
-          BreakRunAtWidth(run, current_char, &width, &end_char, &next_char);
+          BreakRunAtWidth(run, current_char, &width, &end_char);
       AddSegment(run_index, Range(current_char, end_char),
                  SkScalarToFloat(width));
       if (skip_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) {
+                       size_t* end_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;
+    size_t word_end_pos =
+        (next_word == words_->breaks().end()) ? text_.size() : next_word->first;
+    word_width_ = (start_char == word->first) ? 0 : word_width_;
     *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) {

[Jun Mukai, 2015/05/11 05:14:38]

And then, you will have to keep this logic right?
What will happen on the example of "aaaaa'bb ccc" I previously commented?

[xdai1, 2015/05/11 21:55:22]

As we discussed offline, "aaaaa'bb ccc" has two words: "aaaaa'bb " and "ccc",
three runs: "aaaaa", "'", and "bb ccc", the first two runs are fine, when it
comes to the third run, because of "bb " still belongs to the first word, "bb "
will expand to the first line (because of logic line 423 in Patch 10) but "ccc"
will be put into the second line (also because of logic 423 in Patch 10).

-          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;
+        word_end_pos = (next_word == words_->breaks().end())
+                            ? text_.size()
+                            : next_word->first;
+        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;
+      word_width_ += char_width;
 
       // TODO(mukai): implement ELIDE_LONG_WORDS.
       if (*width > available_width) {
-        if (line_x_ != 0 || word_width < *width) {
+        if ((line_x_ != 0 && word_width_ <= *width) ||
+            (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;
+          *width -= word_width_;
+          next_char_pos_ = std::max(word->first, start_char);;
+          *end_char = next_char_pos_;
+          word_width_ = 0;
           return true;
         } else if (word_wrap_behavior_ == WRAP_LONG_WORDS) {
-          if (char_width < *width) {
+          if (char_width < *width ||
+              (word_width_ > *width && char_width <= *width)) {
             // Roll back one character.
             *width -= char_width;
-            *next_char = i;
+            next_char_pos_ = i;
           } else {
             // Continue from the next character.
-            *next_char = i + char_range.length();
+            next_char_pos_ = i + char_range.length();
           }
-          *end_char = *next_char;
+          *end_char = next_char_pos_;
+          word_width_ = 0;
+          return true;
+        } else if (word_wrap_behavior_ == TRUNCATE_LONG_WORDS) {
+          *width = truncated_width;
+          next_char_pos_ = word_end_pos;
+          word_width_ = 0;
           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();
+    *end_char = next_char_pos_ = 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;
@@ skipping 21 matching lines @@
       line->size.set_height(std::max(min_height_, max_descent_ + 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;
+    word_width_ = 0;
     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) {

[Jun Mukai, 2015/05/11 05:14:38]

I think all of your problem is that treating the 'added' segments are final. If
you can make it rollback and moving the added segments into the next line, I
believe the result code would get much simpler.

     if (char_range.is_empty()) {
       DCHECK_EQ(0, width);
       return;
     }
     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(
@@ skipping 20 matching lines @@
     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())
         UpdateRTLSegmentRanges();
     }
     text_x_ += SkFloatToScalar(width);
     line_x_ += SkFloatToScalar(width);
+
+    // Calculate |word_width_|.
+    if (words_) {
+      BreakList<size_t>::const_iterator word_for_range_start =
+          words_->GetBreak(char_range.start());
+      BreakList<size_t>::const_iterator word_for_range_end =
+          (char_range.end() == 0)
+              ? words_->breaks().begin()
+              : words_->GetBreak(char_range.end() - 1);
+
+      if (word_for_range_start == word_for_range_end) {
+        // Current word covers the entire char_range.
+        if (word_width_ == 0) {
+          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();
+          word_width_ += char_width;
+        }
+      } else {
+        // Current char_range intersects with more than one word.
+        word_width_ = char_range.end() - word_for_range_end->first;
+      }
+    }
   }
 
   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_;
 
+  // Stores the position of the character that need to be processed when
+  // breaking runs into multiple lines.
+  size_t next_char_pos_;
+  // Stores the glyph width between the current position and the start position
+  // of the current word. If the current position is pointing to the first
+  // character of the current word, |word_width_| is set to 0.
+  SkScalar word_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;
   }
 }
 
+TextRunList::TextRunHarfBuzzIter TextRunList::GetRunAt(size_t position) const {
+  for (TextRunList::TextRunHarfBuzzIter iter = runs_.begin();
+      iter != runs_.end(); iter++) {
+    if ((*iter)->range.start() <= position && (*iter)->range.end() > position)
+      return iter;
+  }
+  return runs_.end();
+}
+
 }  // 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 806 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