RenderTextHarfBuzz: Add support for multi line text selection.

ui/gfx/render_text.cc

 // Copyright (c) 2012 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.h"
 
 #include <limits.h>
 
 #include <algorithm>
 #include <climits>
@@ skipping 405 matching lines @@
       params.subpixel_rendering != FontRenderParams::SUBPIXEL_RENDERING_NONE);
   paint->setSubpixelText(params.subpixel_positioning);
   paint->setAutohinted(params.autohinter);
   paint->setHinting(FontRenderParamsHintingToSkPaintHinting(params.hinting));
 }
 
 }  // namespace internal
 
 // static
 constexpr base::char16 RenderText::kPasswordReplacementChar;
+constexpr bool RenderText::kDragToEndIfOutsideVerticalBounds;
 
 RenderText::~RenderText() {
 }
 
 // static
 RenderText* RenderText::CreateInstance() {
 #if defined(OS_MACOSX)
   const bool use_native = !base::CommandLine::ForCurrentProcess()->HasSwitch(
       switches::kEnableHarfBuzzRenderText);
   if (use_native)
@@ skipping 372 matching lines @@
   text_direction_ = base::i18n::UNKNOWN_DIRECTION;
   cached_bounds_and_offset_valid_ = false;
   OnLayoutTextAttributeChanged(false);
 }
 
 base::i18n::TextDirection RenderText::GetDisplayTextDirection() {
   return GetTextDirection(GetDisplayText());
 }
 
 VisualCursorDirection RenderText::GetVisualDirectionOfLogicalEnd() {
-  return GetDisplayTextDirection() == base::i18n::LEFT_TO_RIGHT ?
-      CURSOR_RIGHT : CURSOR_LEFT;
+  return GetDisplayTextDirection() == base::i18n::LEFT_TO_RIGHT ? CURSOR_RIGHT
+                                                                : CURSOR_LEFT;
+}
+
+VisualCursorDirection RenderText::GetVisualDirectionOfLogicalBeginning() {
+  return GetDisplayTextDirection() == base::i18n::RIGHT_TO_LEFT ? CURSOR_RIGHT
+                                                                : CURSOR_LEFT;
 }
 
 SizeF RenderText::GetStringSizeF() {
   return SizeF(GetStringSize());
 }
 
 float RenderText::GetContentWidthF() {
   const float string_size = GetStringSizeF().width();
   // The cursor is drawn one pixel beyond the int-enclosed text bounds.
   return cursor_enabled_ ? std::ceil(string_size) + 1 : string_size;
@@ skipping 57 matching lines @@
       (index < text().length() &&
        (truncate_length_ == 0 || index < truncate_length_) &&
        IsValidCodePointIndex(text(), index));
 }
 
 Rect RenderText::GetCursorBounds(const SelectionModel& caret,
                                  bool insert_mode) {
   // TODO(ckocagil): Support multiline. This function should return the height
   //                 of the line the cursor is on. |GetStringSize()| now returns
   //                 the multiline size, eliminate its use here.
-
+  DCHECK(!multiline_);
   EnsureLayout();
   size_t caret_pos = caret.caret_pos();
   DCHECK(IsValidLogicalIndex(caret_pos));
   // In overtype mode, ignore the affinity and always indicate that we will
   // overtype the next character.
   LogicalCursorDirection caret_affinity =
       insert_mode ? caret.caret_affinity() : CURSOR_FORWARD;
   int x = 0, width = 1;
   Size size = GetStringSize();
   if (caret_pos == (caret_affinity == CURSOR_BACKWARD ? 0 : text().length())) {
@@ skipping 47 matching lines @@
 }
 
 SelectionModel RenderText::GetSelectionModelForSelectionStart() const {
   const Range& sel = selection();
   if (sel.is_empty())
     return selection_model_;
   return SelectionModel(sel.start(),
                         sel.is_reversed() ? CURSOR_BACKWARD : CURSOR_FORWARD);
 }
 
+std::vector<Rect> RenderText::GetSubstringBoundsForTesting(
+    const gfx::Range& range) {
+  return GetSubstringBounds(range);
+}
+
 const Vector2d& RenderText::GetUpdatedDisplayOffset() {
   UpdateCachedBoundsAndOffset();
   return display_offset_;
 }
 
 void RenderText::SetDisplayOffset(int horizontal_offset) {
   const int extra_content = GetContentWidth() - display_rect_.width();
   const int cursor_width = cursor_enabled_ ? 1 : 0;
 
   int min_offset = 0;
@@ skipping 22 matching lines @@
     horizontal_offset = min_offset;
   else if (horizontal_offset > max_offset)
     horizontal_offset = max_offset;
 
   cached_bounds_and_offset_valid_ = true;
   display_offset_.set_x(horizontal_offset);
   cursor_bounds_ = GetCursorBounds(selection_model_, true);
 }
 
 Vector2d RenderText::GetLineOffset(size_t line_number) {
+  EnsureLayout();
   Vector2d offset = display_rect().OffsetFromOrigin();
   // TODO(ckocagil): Apply the display offset for multiline scrolling.
-  if (!multiline())
+  if (!multiline()) {
     offset.Add(GetUpdatedDisplayOffset());
-  else
+  } else {
+    DCHECK_LT(line_number, lines().size());
     offset.Add(Vector2d(0, lines_[line_number].preceding_heights));
+  }
   offset.Add(GetAlignmentOffset(line_number));
   return offset;
 }
 
 bool RenderText::GetDecoratedWordAtPoint(const Point& point,
                                          DecoratedText* decorated_word,
                                          Point* baseline_point) {
   // FindCursorPosition doesn't currently support multiline. See
   // http://crbug.com/650120.
   if (multiline() || obscured())
@@ skipping 75 matching lines @@
   return AdjacentWordSelectionModel(current, direction);
 }
 
 SelectionModel RenderText::EdgeSelectionModel(
     VisualCursorDirection direction) {
   if (direction == GetVisualDirectionOfLogicalEnd())
     return SelectionModel(text().length(), CURSOR_FORWARD);
   return SelectionModel(0, CURSOR_BACKWARD);
 }
 
+SelectionModel RenderText::LineSelectionModel(size_t line_index,
+                                              VisualCursorDirection direction) {
+  const internal::Line& line = lines()[line_index];
+  if (line.segments.empty()) {
+    // Only the last line can be empty.
+    DCHECK_EQ(lines().size() - 1, line_index);
+    return EdgeSelectionModel(GetVisualDirectionOfLogicalEnd());
+  }
+
+  size_t max_index = 0;
+  size_t min_index = text().length();
+  for (const auto& segment : line.segments) {
+    min_index = std::min<size_t>(min_index, segment.char_range.GetMin());
+    max_index = std::max<size_t>(max_index, segment.char_range.GetMax());
+  }
+
+  return direction == GetVisualDirectionOfLogicalEnd()
+             ? SelectionModel(DisplayIndexToTextIndex(max_index),
+                              CURSOR_FORWARD)
+             : SelectionModel(DisplayIndexToTextIndex(min_index),
+                              CURSOR_BACKWARD);
+}
+
 void RenderText::SetSelectionModel(const SelectionModel& model) {
   DCHECK_LE(model.selection().GetMax(), text().length());
   selection_model_ = model;
   cached_bounds_and_offset_valid_ = false;
 }
 
 void RenderText::OnTextColorChanged() {
 }
 
 void RenderText::UpdateDisplayText(float text_width) {
@@ skipping 88 matching lines @@
 }
 
 void RenderText::UndoCompositionAndSelectionStyles() {
   // Restore the underline and color breaks to undo the temporary styles.
   DCHECK(composition_and_selection_styles_applied_);
   colors_ = saved_colors_;
   styles_[UNDERLINE] = saved_underlines_;
   composition_and_selection_styles_applied_ = false;
 }
 
-Point RenderText::ToTextPoint(const Point& point) {
-  return point - GetLineOffset(0);
-  // TODO(ckocagil): Convert multiline view space points to text space.
-}
-
 Point RenderText::ToViewPoint(const Point& point) {
   if (!multiline())
     return point + GetLineOffset(0);
 
   // TODO(ckocagil): Traverse individual line segments for RTL support.
   DCHECK(!lines_.empty());
   int x = point.x();
   size_t line = 0;
   for (; line < lines_.size() && x > lines_[line].size.width(); ++line)
     x -= lines_[line].size.width();
+
+  // If |point| is outside the text space, clip it to the end of the last line.
+  if (line == lines_.size())
+    x = lines_[--line].size.width();
   return Point(x, point.y()) + GetLineOffset(line);
 }
 
-std::vector<Rect> RenderText::TextBoundsToViewBounds(const Range& x) {
-  std::vector<Rect> rects;
-
-  if (!multiline()) {
-    rects.push_back(Rect(ToViewPoint(Point(x.GetMin(), 0)),
-                         Size(x.length(), GetStringSize().height())));
-    return rects;
-  }
-
-  EnsureLayout();
-
-  // Each line segment keeps its position in text coordinates. Traverse all line
-  // segments and if the segment intersects with the given range, add the view
-  // rect corresponding to the intersection to |rects|.
-  for (size_t line = 0; line < lines_.size(); ++line) {
-    int line_x = 0;
-    const Vector2d offset = GetLineOffset(line);
-    for (size_t i = 0; i < lines_[line].segments.size(); ++i) {
-      const internal::LineSegment* segment = &lines_[line].segments[i];
-      const Range intersection = segment->x_range.Intersect(x).Ceil();
-      if (!intersection.is_empty()) {
-        Rect rect(line_x + intersection.start() - segment->x_range.start(),
-                  0, intersection.length(), lines_[line].size.height());
-        rects.push_back(rect + offset);
-      }
-      line_x += segment->x_range.length();
-    }
-  }
-
-  return rects;
-}
-
 HorizontalAlignment RenderText::GetCurrentHorizontalAlignment() {
   if (horizontal_alignment_ != ALIGN_TO_HEAD)
     return horizontal_alignment_;
   return GetDisplayTextDirection() == base::i18n::RIGHT_TO_LEFT ?
       ALIGN_RIGHT : ALIGN_LEFT;
 }
 
 Vector2d RenderText::GetAlignmentOffset(size_t line_number) {
   // TODO(ckocagil): Enable |lines_| usage on RenderTextMac.
   if (MultilineSupported() && multiline_)
@@ skipping 412 matching lines @@
 
   for (; range_max < length; ++range_max)
     if (iter.IsEndOfWord(range_max) || iter.IsStartOfWord(range_max))
       break;
 
   return range.is_reversed() ? Range(range_max, range_min)
                              : Range(range_min, range_max);
 }
 
 }  // namespace gfx