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

ui/gfx/render_text_unittest.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 <stddef.h>
 #include <stdint.h>
 
@@ skipping 455 matching lines @@
     return static_cast<RenderTextHarfBuzz*>(GetRenderText());
   }
 
 #if defined(OS_MACOSX)
   RenderTextMac* GetRenderTextMac() {
     DCHECK_EQ(RENDER_TEXT_MAC, GetParam());
     return static_cast<RenderTextMac*>(GetRenderText());
   }
 #endif
 
-  Rect GetSelectionBoundsUnion() {
+  Rect GetSubstringBoundsUnionForRange(const Range& range) {
     const std::vector<Rect> bounds =
-        render_text_->GetSubstringBoundsForTesting(render_text_->selection());
+        render_text_->GetSubstringBoundsForTesting(range);
     return std::accumulate(bounds.begin(), bounds.end(), Rect(), UnionRects);
   }

[tapted, 2017/01/20 06:24:50]

Can we keep an overload?
i.e.

Rect GetSelectionBoundsUnion() {
  return GetSubstringBoundsUnionForRange(render_text_->selection());
}

[karandeepb, 2017/01/20 07:29:10]

Done.

 
   Canvas* canvas() { return &canvas_; }
   TestSkiaTextRenderer* renderer() { return &renderer_; }
   test::RenderTextTestApi* test_api() { return test_api_.get(); };
 
  private:
   std::unique_ptr<RenderText> render_text_;
   std::unique_ptr<test::RenderTextTestApi> test_api_;
   Canvas canvas_;
   TestSkiaTextRenderer renderer_;
@@ skipping 1174 matching lines @@
 TEST_P(RenderTextHarfBuzzTest, MoveCursorLeftRight_MeiryoUILigatures) {
   RenderText* render_text = GetRenderText();
   // Meiryo UI uses single-glyph ligatures for 'ff' and 'ffi', but each letter
   // (code point) has unique bounds, so mid-glyph cursoring should be possible.
   render_text->SetFontList(FontList("Meiryo UI, 12px"));
   render_text->SetText(WideToUTF16(L"ff ffi"));
   render_text->SetDisplayRect(gfx::Rect(100, 100));
   test_api()->EnsureLayout();
   EXPECT_EQ(0U, render_text->cursor_position());
 
-  gfx::Rect last_selection_bounds = GetSelectionBoundsUnion();
+  gfx::Rect last_selection_bounds =
+      GetSubstringBoundsUnionForRange(render_text->selection());
   for (size_t i = 0; i < render_text->text().length(); ++i) {
     render_text->MoveCursor(CHARACTER_BREAK, CURSOR_RIGHT, SELECTION_RETAIN);
     EXPECT_EQ(i + 1, render_text->cursor_position());
 
     // Verify the selection bounds also increase and that the correct bounds are
     // returned even when the grapheme boundary lies within a glyph.
-    const gfx::Rect selection_bounds = GetSelectionBoundsUnion();
+    const gfx::Rect selection_bounds =
+        GetSubstringBoundsUnionForRange(render_text->selection());
     EXPECT_GT(selection_bounds.right(), last_selection_bounds.right());
     EXPECT_EQ(selection_bounds.x(), last_selection_bounds.x());
     last_selection_bounds = selection_bounds;
   }
   EXPECT_EQ(6U, render_text->cursor_position());
 }
 #endif  // !defined(OS_MACOSX)
 
 // TODO(asvitkine): RenderTextMac cursor movements. http://crbug.com/131618
 TEST_P(RenderTextHarfBuzzTest, GraphemePositions) {
@@ skipping 93 matching lines @@
     render_text->SetText(cases[i]);
     EXPECT_TRUE(render_text->IsValidLogicalIndex(1));
     EXPECT_FALSE(render_text->IsValidCursorIndex(1));
     EXPECT_TRUE(render_text->SelectRange(Range(2, 1)));
     EXPECT_EQ(Range(2, 1), render_text->selection());
     EXPECT_EQ(1U, render_text->cursor_position());
 
     // Verify that the selection bounds extend over the entire grapheme, even if
     // the selection is set amid the grapheme.
     test_api()->EnsureLayout();
-    const gfx::Rect mid_grapheme_bounds = GetSelectionBoundsUnion();
+    const gfx::Rect mid_grapheme_bounds =
+        GetSubstringBoundsUnionForRange(render_text->selection());
     render_text->SelectAll(false);
-    EXPECT_EQ(GetSelectionBoundsUnion(), mid_grapheme_bounds);
+    EXPECT_EQ(GetSubstringBoundsUnionForRange(render_text->selection()),
+              mid_grapheme_bounds);
 
     // Although selection bounds may be set within a multi-character grapheme,
     // cursor movement (e.g. via arrow key) should avoid those indices.
     EXPECT_TRUE(render_text->SelectRange(Range(2, 1)));
     render_text->MoveCursor(CHARACTER_BREAK, CURSOR_LEFT, SELECTION_NONE);
     EXPECT_EQ(0U, render_text->cursor_position());
     render_text->MoveCursor(CHARACTER_BREAK, CURSOR_RIGHT, SELECTION_NONE);
     EXPECT_EQ(2U, render_text->cursor_position());
   }
 }
@@ skipping 33 matching lines @@
     EXPECT_EQ(2u, test_api()->lines().size());
 
     const bool is_ltr =
         render_text->GetDisplayTextDirection() == base::i18n::LEFT_TO_RIGHT;
     for (size_t j = 0; j < render_text->text().length(); ++j) {
       SCOPED_TRACE(base::StringPrintf(
           "Testing index %" PRIuS " for case %" PRIuS "", j, i));
       render_text->SelectRange(Range(j, j + 1));
 
       // Test a point inside the leading edge of the glyph bounds.
-      const Rect bounds = GetSelectionBoundsUnion();
+      const Rect bounds =
+          GetSubstringBoundsUnionForRange(render_text->selection());
       const Point cursor_position(is_ltr ? bounds.x() + 1 : bounds.right() - 1,
                                   bounds.y() + 1);
 
       const SelectionModel model =
           render_text->FindCursorPosition(cursor_position);
       EXPECT_EQ(j, model.caret_pos());
       EXPECT_EQ(CURSOR_FORWARD, model.caret_affinity());
     }
   }
 }
@@ skipping 2290 matching lines @@
     if (i < kWordTwoStartIndex) {
       VerifyDecoratedWordsAreEqual(expected_word_1, decorated_word);
       EXPECT_TRUE(left_glyph_word_1.Contains(baseline_point));
     } else {
       VerifyDecoratedWordsAreEqual(expected_word_2, decorated_word);
       EXPECT_TRUE(left_glyph_word_2.Contains(baseline_point));
     }
   }
 }
 
+// Test that GetDecoratedWordAtPoint behaves correctly for multiline text.
+TEST_P(RenderTextHarfBuzzTest, GetDecoratedWordAtPoint_Multiline) {
+  const base::string16 text = ASCIIToUTF16("a b\n..\nc.");
+  const size_t kWordOneIndex = 0;    // Index of character 'a'.
+  const size_t kWordTwoIndex = 2;    // Index of character 'b'.
+  const size_t kWordThreeIndex = 7;  // Index of character 'c'.
+
+  // Set up render text.
+  RenderText* render_text = GetRenderText();
+  render_text->SetMultiline(true);
+  render_text->SetDisplayRect(Rect(500, 500));
+  render_text->SetText(text);
+  render_text->ApplyWeight(Font::Weight::SEMIBOLD, Range(0, 3));
+  render_text->ApplyStyle(UNDERLINE, true, Range(1, 7));
+  render_text->ApplyStyle(STRIKE, true, Range(1, 8));
+  render_text->ApplyStyle(ITALIC, true, Range(5, 8));
+
+  // Set up test expectations.
+  const std::vector<RenderText::FontSpan> font_spans =
+      render_text->GetFontSpansForTesting();
+
+  DecoratedText expected_word_1;
+  expected_word_1.text = ASCIIToUTF16("a");
+  expected_word_1.attributes.push_back(CreateRangedAttribute(
+      font_spans, 0, kWordOneIndex, Font::Weight::SEMIBOLD, 0));
+  const Rect left_glyph_word_1 =
+      GetSubstringBoundsUnionForRange(Range(kWordOneIndex, kWordOneIndex + 1));
+
+  DecoratedText expected_word_2;
+  expected_word_2.text = ASCIIToUTF16("b");
+  expected_word_2.attributes.push_back(CreateRangedAttribute(
+      font_spans, 0, kWordTwoIndex, Font::Weight::SEMIBOLD,
+      UNDERLINE_MASK | STRIKE_MASK));
+  const Rect left_glyph_word_2 =
+      GetSubstringBoundsUnionForRange(Range(kWordTwoIndex, kWordTwoIndex + 1));
+
+  DecoratedText expected_word_3;
+  expected_word_3.text = ASCIIToUTF16("c");
+  expected_word_3.attributes.push_back(
+      CreateRangedAttribute(font_spans, 0, kWordThreeIndex,
+                            Font::Weight::NORMAL, STRIKE_MASK | ITALIC_MASK));
+  const Rect left_glyph_word_3 = GetSubstringBoundsUnionForRange(
+      Range(kWordThreeIndex, kWordThreeIndex + 1));
+
+  DecoratedText decorated_word;
+  Point baseline_point;
+  {
+    SCOPED_TRACE(base::StringPrintf("Query to the left of first line."));

[tapted, 2017/01/20 06:24:50]

This can just be a comment I think -- SCOPED_TRACE is useful if there is a loop
of function call, since then you can't tell just from the line number which test
case is failing.

[karandeepb, 2017/01/20 07:29:10]

Done.

+    EXPECT_TRUE(render_text->GetDecoratedWordAtPoint(
+        Point(-5, GetCursorYForTesting(0)), &decorated_word, &baseline_point));
+    VerifyDecoratedWordsAreEqual(expected_word_1, decorated_word);
+    EXPECT_TRUE(left_glyph_word_1.Contains(baseline_point));
+  }
+  {
+    SCOPED_TRACE(base::StringPrintf("Query on the second line"));
+    EXPECT_TRUE(render_text->GetDecoratedWordAtPoint(
+        Point(5, GetCursorYForTesting(1)), &decorated_word, &baseline_point));
+    VerifyDecoratedWordsAreEqual(expected_word_2, decorated_word);
+    EXPECT_TRUE(left_glyph_word_2.Contains(baseline_point));
+  }
+  {
+    SCOPED_TRACE(base::StringPrintf("Query on the third line"));
+
+    // Query at the center point of the character 'c'.
+    EXPECT_TRUE(render_text->GetDecoratedWordAtPoint(
+        left_glyph_word_3.CenterPoint(), &decorated_word, &baseline_point));
+    VerifyDecoratedWordsAreEqual(expected_word_3, decorated_word);
+    EXPECT_TRUE(left_glyph_word_3.Contains(baseline_point));
+  }
+  {
+    SCOPED_TRACE(base::StringPrintf("Query to the right of the third line"));
+    EXPECT_TRUE(render_text->GetDecoratedWordAtPoint(
+        Point(505, GetCursorYForTesting(2)), &decorated_word, &baseline_point));
+    VerifyDecoratedWordsAreEqual(expected_word_3, decorated_word);
+    EXPECT_TRUE(left_glyph_word_3.Contains(baseline_point));
+  }
+}
+
 // Verify the boolean return value of GetDecoratedWordAtPoint.
 TEST_P(RenderTextHarfBuzzTest, GetDecoratedWordAtPoint_Return) {
   RenderText* render_text = GetRenderText();
   render_text->SetText(ASCIIToUTF16("..."));
 
   DecoratedText decorated_word;
   Point baseline_point;
 
   // False should be returned, when the text does not contain any word.
   Point query =
@@ skipping 77 matching lines @@
   for (size_t i = 0; i < test_api()->lines().size(); i++) {
     SCOPED_TRACE(base::StringPrintf("Testing bounds for line %" PRIuS "", i));
     const internal::Line& line = test_api()->lines()[i];
     const Size line_size(std::ceil(line.size.width()),
                          std::ceil(line.size.height()));
     const Rect expected_line_bounds =
         render_text->GetLineOffset(i) + Rect(line_size);
     expected_total_bounds.Union(expected_line_bounds);
 
     render_text->SelectRange(line_char_range[i]);
-    EXPECT_EQ(expected_line_bounds, GetSelectionBoundsUnion());
+    EXPECT_EQ(expected_line_bounds,
+              GetSubstringBoundsUnionForRange(render_text->selection()));
   }
 
   // Test complete bounds.
   render_text->SelectAll(false);
-  EXPECT_EQ(expected_total_bounds, GetSelectionBoundsUnion());
+  EXPECT_EQ(expected_total_bounds,
+            GetSubstringBoundsUnionForRange(render_text->selection()));
 }
 
 // Prefix for test instantiations intentionally left blank since each test
 // fixture class has a single parameterization.
 #if defined(OS_MACOSX)
 INSTANTIATE_TEST_CASE_P(,
                         RenderTextTest,
                         ::testing::Values(RENDER_TEXT_HARFBUZZ,
                                           RENDER_TEXT_MAC),
                         PrintRenderTextBackend());
 INSTANTIATE_TEST_CASE_P(,
                         RenderTextMacTest,
                         ::testing::Values(RENDER_TEXT_MAC),
                         PrintRenderTextBackend());
 #else
 INSTANTIATE_TEST_CASE_P(,
                         RenderTextTest,
                         ::testing::Values(RENDER_TEXT_HARFBUZZ),
                         PrintRenderTextBackend());
 #endif
 
 INSTANTIATE_TEST_CASE_P(,
                         RenderTextHarfBuzzTest,
                         ::testing::Values(RENDER_TEXT_HARFBUZZ),
                         PrintRenderTextBackend());
 
 }  // namespace gfx