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>
 
 #include <algorithm>
 #include <memory>
+#include <numeric>
 
 #include "base/format_macros.h"
 #include "base/i18n/break_iterator.h"
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
 #include "base/run_loop.h"
 #include "base/strings/string_split.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/strings/utf_string_conversions.h"
@@ skipping 84 matching lines @@
   size_t DisplayIndexToTextIndex(size_t index) {
     return render_text_->DisplayIndexToTextIndex(index);
   }
 
   void EnsureLayout() { render_text_->EnsureLayout(); }
 
   Vector2d GetAlignmentOffset(size_t line_number) {
     return render_text_->GetAlignmentOffset(line_number);
   }
 
+  std::vector<Rect> GetSubstringBounds(const Range& range) {
+    return render_text_->GetSubstringBounds(range);
+  }
+
  private:
   RenderText* render_text_;
 
   DISALLOW_COPY_AND_ASSIGN(RenderTextTestApi);
 };
 
 }  // namespace test
 
 namespace {
 
@@ skipping 338 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() {
+    const std::vector<Rect> bounds =
+        test_api_->GetSubstringBounds(render_text_->selection());
+    return std::accumulate(bounds.begin(), bounds.end(), Rect(), UnionRects);
+  }
+
   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 22 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) {
+    return GetRenderText()->GetLineOffset(line_num).y() + 1;
+  }
+
  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());
     }
   }
 }
+
+// Tests that FindCursorPosition behaves correctly for multi-line text.
+TEST_P(RenderTextHarfBuzzTest, FindCursorPositionMultiline) {

[msw, 2016/12/13 03:04:56]

q: should we have any multi-char grapheme test cases for FindCursorPosition?

[karandeepb, 2016/12/16 02:58:38]

Thanks for pointing this out. The existing implementation does not always return
valid grapheme boundaries. As a result, bugs like http://crbug.com/673986 occur.
I have modified the code so that a valid grapheme boundary is returned. Also,
added a test.

+  struct {
+    const wchar_t* const text;
+    bool is_ltr;

[msw, 2016/12/13 03:04:56]

optional nit: check RenderText::GetDisplayTextDirection() below instead?

[karandeepb, 2016/12/16 02:58:38]

Done.

+  } cases[] = {{L"abc def", true}, {L"\x5d0\x5d1\x5d2 \x5d3\x5d4\x5d5", false}};
+
+  SetGlyphWidth(5);
+  RenderText* render_text = GetRenderText();
+  render_text->SetDisplayRect(Rect(25, 1000));
+  render_text->SetMultiline(true);
+
+  for (size_t i = 0; i < arraysize(cases); i++) {
+    render_text->SetText(WideToUTF16(cases[i].text));
+    test_api()->EnsureLayout();
+    EXPECT_EQ(2u, test_api()->lines().size());
+
+    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 Point query(cases[i].is_ltr ? bounds.x() + 1 : bounds.right() - 1,

[msw, 2016/12/13 03:04:56]

nit: name this cursor_position?

[karandeepb, 2016/12/16 02:58:38]

Done.

+                        bounds.y() + 1);
+
+      const SelectionModel model_for_query =

[msw, 2016/12/13 03:04:56]

nit: name this model?

[karandeepb, 2016/12/16 02:58:38]

Done.

+          render_text->FindCursorPosition(query);
+      EXPECT_EQ(j, model_for_query.caret_pos());
+      EXPECT_EQ(CURSOR_FORWARD, model_for_query.caret_affinity());
+    }
+  }
+}
 
 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.
   const base::string16 kHindiLatin =
       WideToUTF16(L"\x0915\x093f" L"a" L"\x0915\x093f");
   // RTL 2-character grapheme.
@@ skipping 1056 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 34 matching lines @@
                                                    &baseline_point));
 
   // False should be returned for obscured text.
   render_text->SetObscured(true);
   query = render_text->GetCursorBounds(SelectionModel(0, CURSOR_FORWARD), false)
               .origin();
   EXPECT_FALSE(render_text->GetDecoratedWordAtPoint(query, &decorated_word,
                                                     &baseline_point));
 }
 
+// Tests text selection made at end points of individual lines of multiline
+// text.
+TEST_P(RenderTextHarfBuzzTest, LineEndSelections) {
+  const wchar_t* const ltr = L"abc\n\ndef";
+  const wchar_t* const rtl = L"\x5d0\x5d1\x5d2\n\n\x5d3\x5d4\x5d5";
+  const int left_x = -100;
+  const int right_x = 100;
+  struct {
+    const wchar_t* const text;
+    const int line_num;
+    const int x;
+    const wchar_t* const selected_text;
+  } cases[] = {
+      {ltr, 1, left_x, L"abc\n"},
+      {ltr, 1, right_x, L"abc\n\n"},
+      {ltr, 2, left_x, L"abc\n\n"},
+      {ltr, 2, right_x, ltr},
+
+      {rtl, 1, left_x, L"\x5d0\x5d1\x5d2\n\n"},
+      {rtl, 1, right_x, L"\x5d0\x5d1\x5d2\n"},
+      {rtl, 2, left_x, rtl},
+      {rtl, 2, right_x, L"\x5d0\x5d1\x5d2\n\n"},
+  };
+
+  RenderText* render_text = GetRenderText();
+  render_text->SetMultiline(true);
+  render_text->SetDisplayRect(Rect(200, 1000));
+
+  for (size_t i = 0; i < arraysize(cases); i++) {
+    SCOPED_TRACE(base::StringPrintf("Testing case %" PRIuS "", i));
+    render_text->SetText(WideToUTF16(cases[i].text));
+    test_api()->EnsureLayout();
+
+    EXPECT_EQ(3u, test_api()->lines().size());
+    // Position the cursor at the logical beginning of text.
+    render_text->SelectRange(Range(0));
+
+    render_text->MoveCursorTo(
+        Point(cases[i].x, GetCursorYForTesting(cases[i].line_num)), true);
+    EXPECT_EQ(WideToUTF16(cases[i].selected_text),
+              GetSelectedText(render_text));
+  }
+}
+
+// Tests that GetSubstringBounds returns the correct bounds for multiline text.
+TEST_P(RenderTextHarfBuzzTest, GetSubstringBoundsMultiline) {
+  RenderText* render_text = GetRenderText();
+  render_text->SetMultiline(true);
+  render_text->SetDisplayRect(Rect(200, 1000));
+  render_text->SetText(WideToUTF16(L"abc\n\ndef"));
+  test_api()->EnsureLayout();
+
+  const std::vector<Range> line_char_range = {Range(0, 3), Range(4, 5),
+                                              Range(5, 8)};
+
+  // Test bounds for individual lines.
+  EXPECT_EQ(3u, test_api()->lines().size());
+  Rect expected_total_bounds;
+  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());
+  }
+
+  // Test complete bounds.
+  render_text->SelectAll(false);
+  EXPECT_EQ(expected_total_bounds, GetSelectionBoundsUnion());
+}
+
 // 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