MacViews: Enable word lookup for selectable views::Labels and multi-line text.

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 1013 matching lines @@
     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())
+  if (obscured())
     return false;
 
-  // Note: FindCursorPosition will trigger a layout via EnsureLayout.
+  EnsureLayout();
   const SelectionModel model_at_point = FindCursorPosition(point);
   const size_t word_index =
       GetNearestWordStartBoundary(model_at_point.caret_pos());
   if (word_index >= text().length())
     return false;
 
   const Range word_range = ExpandRangeToWordBoundary(Range(word_index));
   DCHECK(!word_range.is_reversed());
   DCHECK(!word_range.is_empty());
 
   const std::vector<Rect> word_bounds = GetSubstringBounds(word_range);
   if (word_bounds.empty() ||
       !GetDecoratedTextForRange(word_range, decorated_word)) {
     return false;
   }
 
   // Retrieve the baseline origin of the left-most glyph.
   const auto left_rect = std::min_element(
       word_bounds.begin(), word_bounds.end(),
       [](const Rect& lhs, const Rect& rhs) { return lhs.x() < rhs.x(); });
-  *baseline_point = left_rect->origin() + Vector2d(0, GetDisplayTextBaseline());
+  const int line_index = GetLineContainingYCoord(left_rect->CenterPoint().y() -
+                                                 GetLineOffset(0).y());

[karandeepb, 2017/01/19 04:38:36]

The logic in the previous patchset was indeed incorrect. Existing tests did
catch this in Patchset 1, but didn't see it earlier.

+  if (line_index == -1 || line_index == static_cast<int>(lines().size()))
+    return false;
+  *baseline_point =
+      left_rect->origin() + Vector2d(0, lines()[line_index].baseline);
   return true;
 }
 
 base::string16 RenderText::GetTextFromRange(const Range& range) const {
   if (range.IsValid() && range.GetMin() < text().length())
     return text().substr(range.GetMin(), range.length());
   return base::string16();
 }
 
 RenderText::RenderText()
@@ skipping 309 matching lines @@
 
 void RenderText::UpdateStyleLengths() {
   const size_t text_length = text_.length();
   colors_.SetMax(text_length);
   baselines_.SetMax(text_length);
   weights_.SetMax(text_length);
   for (size_t style = 0; style < NUM_TEXT_STYLES; ++style)
     styles_[style].SetMax(text_length);
 }
 
+int RenderText::GetLineContainingYCoord(float text_y) {
+  if (text_y < 0)
+    return -1;
+
+  for (size_t i = 0; i < lines().size(); i++) {
+    const internal::Line& line = lines()[i];
+
+    if (text_y <= line.size.height())
+      return i;
+    text_y -= line.size.height();
+  }
+
+  return lines().size();
+}
+
+int RenderText::GetLineSegmentContainingXCoord(const internal::Line& line,
+                                               float line_x,
+                                               float* offset_relative_segment) {
+  DCHECK(offset_relative_segment);
+
+  *offset_relative_segment = 0;
+  if (line_x < 0)
+    return -1;
+  for (size_t i = 0; i < line.segments.size(); i++) {
+    const internal::LineSegment& segment = line.segments[i];
+
+    // segment.x_range is not used because it is in text space.
+    if (line_x < segment.width()) {
+      *offset_relative_segment = line_x;
+      return i;
+    }
+    line_x -= segment.width();
+  }
+  return line.segments.size();
+}
+
 // static
 bool RenderText::RangeContainsCaret(const Range& range,
                                     size_t caret_pos,
                                     LogicalCursorDirection caret_affinity) {
   // NB: exploits unsigned wraparound (WG14/N1124 section 6.2.5 paragraph 9).
   size_t adjacent = (caret_affinity == CURSOR_BACKWARD) ?
       caret_pos - 1 : caret_pos + 1;
   return range.Contains(Range(caret_pos, adjacent));
 }
 
@@ skipping 292 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