Fix multiline behaviors for RTL text.

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 205 matching lines @@
 // TODO(ckocagil): Expose the interface of this class in the header and test
 //                 this class directly.
 class HarfBuzzLineBreaker {
  public:
   HarfBuzzLineBreaker(size_t max_width,
                       int min_baseline,
                       float min_height,
                       bool multiline,
                       const base::string16& text,
                       const BreakList<size_t>* words,
-                      const ScopedVector<internal::TextRunHarfBuzz>& runs)
+                      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),
         text_(text),
         words_(words),
-        runs_(runs),
+        run_list_(run_list),
         text_x_(0),
         line_x_(0),
         max_descent_(0),
         max_ascent_(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 = runs_[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);
     }
   }
@@ skipping 13 matching 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 = *runs_[run_index];
+    const internal::TextRunHarfBuzz& run = *(run_list_.runs()[run_index]);
     SkScalar width = 0;
     size_t next_char = run.range.start();
 
     // Break the run until it fits the current line.
     while (next_char < run.range.end()) {
       const size_t current_char = next_char;
       const bool skip_line =
           BreakRunAtWidth(run, current_char, &width, &next_char);
       AddSegment(run_index, Range(current_char, next_char),
                  SkScalarToFloat(width));
@@ skipping 79 matching lines @@
       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->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;
     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);
       return;
     }
-    const internal::TextRunHarfBuzz& run = *runs_[run_index];
+    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;
 
     internal::Line* line = &lines_.back();
@@ skipping 22 matching lines @@
     text_x_ += SkFloatToScalar(width);
     line_x_ += SkFloatToScalar(width);
   }
 
   const SkScalar max_width_;
   const int min_baseline_;
   const float min_height_;
   const bool multiline_;
   const base::string16& text_;
   const BreakList<size_t>* const words_;
-  const ScopedVector<internal::TextRunHarfBuzz>& runs_;
+  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_;
@@ skipping 512 matching lines @@
   if (lines().empty()) {
     // TODO(vadimt): Remove ScopedTracker below once crbug.com/431326 is fixed.
     tracked_objects::ScopedTracker tracking_profile2(
         FROM_HERE_WITH_EXPLICIT_FUNCTION(
             "431326 RenderTextHarfBuzz::EnsureLayout2"));
 
     internal::TextRunList* run_list = GetRunList();
     HarfBuzzLineBreaker line_breaker(
         display_rect().width(), font_list().GetBaseline(),
         std::max(font_list().GetHeight(), min_line_height()), multiline(),
-        GetDisplayText(), multiline() ? &GetLineBreaks() : nullptr,
-        run_list->runs());
+        GetDisplayText(), multiline() ? &GetLineBreaks() : nullptr, *run_list);
 
     // TODO(vadimt): Remove ScopedTracker below once crbug.com/431326 is fixed.
     tracked_objects::ScopedTracker tracking_profile3(
         FROM_HERE_WITH_EXPLICIT_FUNCTION(
             "431326 RenderTextHarfBuzz::EnsureLayout3"));
 
     for (size_t i = 0; i < run_list->size(); ++i)
-      line_breaker.AddRun(run_list->visual_to_logical(i));
-
+      line_breaker.AddRun(i);
     std::vector<internal::Line> lines;
     line_breaker.Finalize(&lines, &total_size_);
     set_lines(&lines);
   }
 }
 
 void RenderTextHarfBuzz::DrawVisualText(Canvas* canvas) {
+  internal::SkiaTextRenderer renderer(canvas);
+  DrawVisualTextInternal(&renderer);
+}
+
+void RenderTextHarfBuzz::DrawVisualTextInternal(
+    internal::SkiaTextRenderer* renderer) {
   DCHECK(!update_layout_run_list_);
   DCHECK(!update_display_run_list_);
   DCHECK(!update_display_text_);
   if (lines().empty())
     return;
 
-  internal::SkiaTextRenderer renderer(canvas);
-  ApplyFadeEffects(&renderer);
-  ApplyTextShadows(&renderer);
+  ApplyFadeEffects(renderer);
+  ApplyTextShadows(renderer);
   ApplyCompositionAndSelectionStyles();
 
   internal::TextRunList* run_list = GetRunList();
   for (size_t i = 0; i < lines().size(); ++i) {
     const internal::Line& line = lines()[i];
     const Vector2d origin = GetLineOffset(i) + Vector2d(0, line.baseline);
     SkScalar preceding_segment_widths = 0;
     for (const internal::LineSegment& segment : line.segments) {
       const internal::TextRunHarfBuzz& run = *run_list->runs()[segment.run];
-      renderer.SetTypeface(run.skia_face.get());
-      renderer.SetTextSize(SkIntToScalar(run.font_size));
-      renderer.SetFontRenderParams(run.render_params,
-                                   background_is_transparent());
+      renderer->SetTypeface(run.skia_face.get());
+      renderer->SetTextSize(SkIntToScalar(run.font_size));
+      renderer->SetFontRenderParams(run.render_params,
+                                    background_is_transparent());
       Range glyphs_range = run.CharRangeToGlyphRange(segment.char_range);
       scoped_ptr<SkPoint[]> positions(new SkPoint[glyphs_range.length()]);
       SkScalar offset_x =
           preceding_segment_widths - run.positions[glyphs_range.start()].x();
       for (size_t j = 0; j < glyphs_range.length(); ++j) {
         positions[j] = run.positions[(glyphs_range.is_reversed()) ?
                                      (glyphs_range.start() - j) :
                                      (glyphs_range.start() + j)];
         positions[j].offset(SkIntToScalar(origin.x()) + offset_x,
                             SkIntToScalar(origin.y()));
       }
       for (BreakList<SkColor>::const_iterator it =
                colors().GetBreak(segment.char_range.start());
            it != colors().breaks().end() &&
                it->first < segment.char_range.end();
            ++it) {
         const Range intersection =
             colors().GetRange(it).Intersect(segment.char_range);
         const Range colored_glyphs = run.CharRangeToGlyphRange(intersection);
         // The range may be empty if a portion of a multi-character grapheme is
         // selected, yielding two colors for a single glyph. For now, this just
         // paints the glyph with a single style, but it should paint it twice,
         // clipped according to selection bounds. See http://crbug.com/366786
         if (colored_glyphs.is_empty())
           continue;
 
-        renderer.SetForegroundColor(it->second);
-        renderer.DrawPosText(
+        renderer->SetForegroundColor(it->second);
+        renderer->DrawPosText(
             &positions[colored_glyphs.start() - glyphs_range.start()],
             &run.glyphs[colored_glyphs.start()], colored_glyphs.length());
         int start_x = SkScalarRoundToInt(
             positions[colored_glyphs.start() - glyphs_range.start()].x());
         int end_x = SkScalarRoundToInt(
             (colored_glyphs.end() == glyphs_range.end())
                 ? (SkFloatToScalar(segment.width) + preceding_segment_widths +
                    SkIntToScalar(origin.x()))
                 : positions[colored_glyphs.end() - glyphs_range.start()].x());
-        renderer.DrawDecorations(start_x, origin.y(), end_x - start_x,
-                                 run.underline, run.strike,
-                                 run.diagonal_strike);
+        renderer->DrawDecorations(start_x, origin.y(), end_x - start_x,
+                                  run.underline, run.strike,
+                                  run.diagonal_strike);
       }
       preceding_segment_widths += SkFloatToScalar(segment.width);
     }
   }
 
-  renderer.EndDiagonalStrike();
+  renderer->EndDiagonalStrike();
 
   UndoCompositionAndSelectionStyles();
 }
 
 size_t RenderTextHarfBuzz::GetRunContainingCaret(
     const SelectionModel& caret) {
   DCHECK(!update_display_run_list_);
   size_t layout_position = TextIndexToDisplayIndex(caret.caret_pos());
   LogicalCursorDirection affinity = caret.caret_affinity();
   internal::TextRunList* run_list = GetRunList();
@@ skipping 301 matching lines @@
           "431326 RenderTextHarfBuzz::ShapeRunWithFont3"));
 
   for (size_t i = 0; i < run->glyph_count; ++i) {
     DCHECK_LE(infos[i].codepoint, std::numeric_limits<uint16>::max());
     run->glyphs[i] = static_cast<uint16>(infos[i].codepoint);
     run->glyph_to_char[i] = infos[i].cluster;
     const SkScalar x_offset = SkFixedToScalar(hb_positions[i].x_offset);
     const SkScalar y_offset = SkFixedToScalar(hb_positions[i].y_offset);
     run->positions[i].set(run->width + x_offset, -y_offset);
     run->width += (glyph_width_for_test_ > 0)
-                      ? SkIntToScalar(glyph_width_for_test_)
-                      : SkFixedToScalar(hb_positions[i].x_advance);
+                      ? glyph_width_for_test_
+                      : SkFixedToFloat(hb_positions[i].x_advance);
     // Round run widths if subpixel positioning is off to match native behavior.
     if (!run->render_params.subpixel_positioning)
       run->width = std::floor(run->width + 0.5f);
   }
 
   hb_buffer_destroy(buffer);
   hb_font_destroy(harfbuzz_font);
   return true;
 }
 
@@ skipping 65 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