RenderTextHarfBuzz: Add support for multi line text selection.

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 496 matching lines @@
     GetRenderTextHarfBuzz()->set_glyph_width_for_test(test_width);
   }
 
   bool ShapeRunWithFont(const base::string16& text,
                         const Font& font,
                         const FontRenderParams& params,
                         internal::TextRunHarfBuzz* run) {
     return GetRenderTextHarfBuzz()->ShapeRunWithFont(text, font, params, run);
   }
 
+  int GetCursorYForTesting(int line_num = 0) {

[msw, 2016/12/07 20:20:35]

nit: use the line_num param in new tests, or remove it

[karandeepb, 2016/12/12 10:36:19]

Added tests using this.

+    test_api()->EnsureLayout();
+    const internal::Line& line = test_api()->lines()[line_num];
+    return GetRenderText()->GetLineOffset(line_num).y() +
+           line.size.height() / 2;

[msw, 2016/12/07 20:20:35]

optional nit: just add 1 instead of half the line height, like
textfield_unittest

[karandeepb, 2016/12/12 10:36:19]

Done.

+  }
+
  private:
   DISALLOW_COPY_AND_ASSIGN(RenderTextHarfBuzzTest);
 };
 
 #if defined(OS_MACOSX)
 // Test fixture class. Use for tests which are only to be run for RenderTextMac.
 class RenderTextMacTest : public RenderTextTest {
  public:
   RenderTextMacTest() {}
 
@@ skipping 254 matching lines @@
   EXPECT_EQ(1U, test_api()->TextIndexToDisplayIndex(1U));
   EXPECT_EQ(1U, test_api()->TextIndexToDisplayIndex(2U));
   EXPECT_EQ(0U, test_api()->DisplayIndexToTextIndex(0U));
   EXPECT_EQ(2U, test_api()->DisplayIndexToTextIndex(1U));
   EXPECT_TRUE(render_text->IsValidCursorIndex(0U));
   EXPECT_FALSE(render_text->IsValidCursorIndex(1U));
   EXPECT_TRUE(render_text->IsValidCursorIndex(2U));
 
   // FindCursorPosition() should not return positions between a surrogate pair.
   render_text->SetDisplayRect(Rect(0, 0, 20, 20));
-  EXPECT_EQ(render_text->FindCursorPosition(Point(0, 0)).caret_pos(), 0U);
-  EXPECT_EQ(render_text->FindCursorPosition(Point(20, 0)).caret_pos(), 2U);
+  const int cursor_y = GetCursorYForTesting();
+  EXPECT_EQ(render_text->FindCursorPosition(Point(0, cursor_y)).caret_pos(),
+            0U);
+  EXPECT_EQ(render_text->FindCursorPosition(Point(20, cursor_y)).caret_pos(),
+            2U);
   for (int x = -1; x <= 20; ++x) {
-    SelectionModel selection = render_text->FindCursorPosition(Point(x, 0));
+    SelectionModel selection =
+        render_text->FindCursorPosition(Point(x, cursor_y));
     EXPECT_TRUE(selection.caret_pos() == 0U || selection.caret_pos() == 2U);
   }
 
   // GetGlyphBounds() should yield the entire string bounds for text index 0.
   EXPECT_EQ(render_text->GetStringSize().width(),
             static_cast<int>(render_text->GetGlyphBounds(0U).length()));
 
   // Cursoring is independent of underlying characters when text is obscured.
   const wchar_t* const texts[] = {
     kWeak, kLtr, kLtrRtl, kLtrRtlLtr, kRtl, kRtlLtr, kRtlLtrRtl,
@@ skipping 971 matching lines @@
   const wchar_t* kTestStrings[] = { kLtrRtl, kLtrRtlLtr, kRtlLtr, kRtlLtrRtl };
   RenderText* render_text = GetRenderText();
   render_text->SetDisplayRect(Rect(0, 0, 100, 20));
   for (size_t i = 0; i < arraysize(kTestStrings); ++i) {
     SCOPED_TRACE(base::StringPrintf("Testing case[%" PRIuS "]", i));
     render_text->SetText(WideToUTF16(kTestStrings[i]));
     for (size_t j = 0; j < render_text->text().length(); ++j) {
       const Range range(render_text->GetGlyphBounds(j));
       // Test a point just inside the leading edge of the glyph bounds.
       int x = range.is_reversed() ? range.GetMax() - 1 : range.GetMin() + 1;
-      EXPECT_EQ(j, render_text->FindCursorPosition(Point(x, 0)).caret_pos());
+      EXPECT_EQ(
+          j, render_text->FindCursorPosition(Point(x, GetCursorYForTesting()))
+                 .caret_pos());
     }
   }
 }
 
 TEST_P(RenderTextTest, EdgeSelectionModels) {
   // Simple Latin text.
   const base::string16 kLatin = WideToUTF16(L"abc");
   // LTR 2-character grapheme.
   const base::string16 kLTRGrapheme = WideToUTF16(L"\x0915\x093f");
   // LTR 2-character grapheme, LTR a, LTR 2-character grapheme.
@@ skipping 1059 matching lines @@
   }
 }
 
 TEST_P(RenderTextHarfBuzzTest, Multiline_Newline) {
   const struct {
     const wchar_t* const text;
     const size_t lines_count;
     // Ranges of the characters on each line preceding the newline.
     const Range line_char_ranges[3];
   } kTestStrings[] = {
-    {L"abc\ndef", 2ul, { Range(0, 3), Range(4, 7), Range::InvalidRange() } },
-    {L"a \n b ", 2ul, { Range(0, 2), Range(3, 6), Range::InvalidRange() } },
-    {L"ab\n", 2ul, { Range(0, 2), Range(), Range::InvalidRange() } },
-    {L"a\n\nb", 3ul, { Range(0, 1), Range(), Range(3, 4) } },
-    {L"\nab", 2ul, { Range(), Range(1, 3), Range::InvalidRange() } },
-    {L"\n", 2ul, { Range(), Range(), Range::InvalidRange() } },
+      {L"abc\ndef", 2ul, {Range(0, 3), Range(4, 7), Range::InvalidRange()}},
+      {L"a \n b ", 2ul, {Range(0, 2), Range(3, 6), Range::InvalidRange()}},
+      {L"ab\n", 2ul, {Range(0, 2), Range(), Range::InvalidRange()}},
+      {L"a\n\nb", 3ul, {Range(0, 1), Range(2, 3), Range(3, 4)}},
+      {L"\nab", 2ul, {Range(0, 1), Range(1, 3), Range::InvalidRange()}},
+      {L"\n", 2ul, {Range(0, 1), Range(), Range::InvalidRange()}},
   };
 
   RenderText* render_text = GetRenderText();
   render_text->SetDisplayRect(Rect(200, 1000));
   render_text->SetMultiline(true);
 
   for (size_t i = 0; i < arraysize(kTestStrings); ++i) {
     SCOPED_TRACE(base::StringPrintf("kTestStrings[%" PRIuS "]", i));
     render_text->SetText(WideToUTF16(kTestStrings[i].text));
     render_text->Draw(canvas());
@@ skipping 1009 matching lines @@
   const int kWordTwoStartIndex = 6;
 
   RenderText* render_text = GetRenderText();
   render_text->SetDisplayRect(Rect(100, 30));
   render_text->SetText(ltr);
   render_text->ApplyWeight(Font::Weight::SEMIBOLD, Range(0, 3));
   render_text->ApplyStyle(UNDERLINE, true, Range(1, 5));
   render_text->ApplyStyle(ITALIC, true, Range(3, 8));
   render_text->ApplyStyle(DIAGONAL_STRIKE, true, Range(5, 7));
   render_text->ApplyStyle(STRIKE, true, Range(1, 7));
+  const int cursor_y = GetCursorYForTesting();
 
   const std::vector<RenderText::FontSpan> font_spans =
       render_text->GetFontSpansForTesting();
 
   // Create expected decorated text instances.
   DecoratedText expected_word_1;
   expected_word_1.text = ASCIIToUTF16("ab");
   // Attributes for the characters 'a' and 'b' at logical indices 2 and 3
   // respectively.
   expected_word_1.attributes.push_back(CreateRangedAttribute(
@@ skipping 13 matching lines @@
       ITALIC_MASK | DIAGONAL_STRIKE_MASK | STRIKE_MASK));
   const Rect left_glyph_word_2 = render_text->GetCursorBounds(
       SelectionModel(kWordTwoStartIndex, CURSOR_FORWARD), false);
 
   DecoratedText decorated_word;
   Point baseline_point;
 
   {
     SCOPED_TRACE(base::StringPrintf("Query to the left of text bounds"));
     EXPECT_TRUE(render_text->GetDecoratedWordAtPoint(
-        Point(-5, 5), &decorated_word, &baseline_point));
+        Point(-5, cursor_y), &decorated_word, &baseline_point));
     VerifyDecoratedWordsAreEqual(expected_word_1, decorated_word);
     EXPECT_TRUE(left_glyph_word_1.Contains(baseline_point));
   }
   {
     SCOPED_TRACE(base::StringPrintf("Query to the right of text bounds"));
     EXPECT_TRUE(render_text->GetDecoratedWordAtPoint(
-        Point(105, 5), &decorated_word, &baseline_point));
+        Point(105, cursor_y), &decorated_word, &baseline_point));
     VerifyDecoratedWordsAreEqual(expected_word_2, decorated_word);
     EXPECT_TRUE(left_glyph_word_2.Contains(baseline_point));
   }
 
   for (size_t i = 0; i < render_text->text().length(); i++) {
     SCOPED_TRACE(base::StringPrintf("Case[%" PRIuS "]", i));
     // Query the decorated word using the origin of the i'th glyph's bounds.
     const Point query =
         render_text->GetCursorBounds(SelectionModel(i, CURSOR_FORWARD), false)
             .origin();
@@ skipping 23 matching lines @@
   const int kWordTwoStartIndex = 5;
 
   RenderText* render_text = GetRenderText();
   render_text->SetDisplayRect(Rect(100, 30));
   render_text->SetText(rtl);
   render_text->ApplyWeight(Font::Weight::SEMIBOLD, Range(2, 3));
   render_text->ApplyStyle(UNDERLINE, true, Range(3, 6));
   render_text->ApplyStyle(ITALIC, true, Range(0, 3));
   render_text->ApplyStyle(DIAGONAL_STRIKE, true, Range(0, 2));
   render_text->ApplyStyle(STRIKE, true, Range(2, 5));
+  const int cursor_y = GetCursorYForTesting();
 
   const std::vector<RenderText::FontSpan> font_spans =
       render_text->GetFontSpansForTesting();
 
   // Create expected decorated text instance.
   DecoratedText expected_word_1;
   expected_word_1.text = WideToUTF16(L"\x0634\x0632");
   // Attributes for characters at logical indices 1 and 2.
   expected_word_1.attributes.push_back(CreateRangedAttribute(
       font_spans, 0, kWordOneStartIndex, Font::Weight::NORMAL,
@@ skipping 12 matching lines @@
       font_spans, 0, kWordTwoStartIndex, Font::Weight::NORMAL, UNDERLINE_MASK));
   const Rect left_glyph_word_2 = render_text->GetCursorBounds(
       SelectionModel(kWordTwoStartIndex, CURSOR_FORWARD), false);
 
   DecoratedText decorated_word;
   Point baseline_point;
 
   {
     SCOPED_TRACE(base::StringPrintf("Query to the left of text bounds"));
     EXPECT_TRUE(render_text->GetDecoratedWordAtPoint(
-        Point(-5, 5), &decorated_word, &baseline_point));
+        Point(-5, cursor_y), &decorated_word, &baseline_point));
     VerifyDecoratedWordsAreEqual(expected_word_2, decorated_word);
     EXPECT_TRUE(left_glyph_word_2.Contains(baseline_point));
   }
   {
     SCOPED_TRACE(base::StringPrintf("Query to the right of text bounds"));
     EXPECT_TRUE(render_text->GetDecoratedWordAtPoint(
-        Point(105, 5), &decorated_word, &baseline_point));
+        Point(105, cursor_y), &decorated_word, &baseline_point));
     VerifyDecoratedWordsAreEqual(expected_word_1, decorated_word);
     EXPECT_TRUE(left_glyph_word_1.Contains(baseline_point));
   }
 
   for (size_t i = 0; i < render_text->text().length(); i++) {
     SCOPED_TRACE(base::StringPrintf("Case[%" PRIuS "]", i));
 
     // Query the decorated word using the top right point of the i'th glyph's
     // bounds.
     const Point query =
@@ skipping 59 matching lines @@
                         ::testing::Values(RENDER_TEXT_HARFBUZZ),
                         PrintRenderTextBackend());
 #endif
 
 INSTANTIATE_TEST_CASE_P(,
                         RenderTextHarfBuzzTest,
                         ::testing::Values(RENDER_TEXT_HARFBUZZ),
                         PrintRenderTextBackend());
 
 }  // namespace gfx