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 442 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 =
+        render_text_->GetSubstringBoundsForTesting(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 841 matching lines @@
 
 // TODO(asvitkine): RenderTextMac cursor movements. http://crbug.com/131618
 // Crashes on Mac with RenderTextHarfBuzz. See http://crbug.com/640068.
 #if !defined(OS_MACOSX)
 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();
   for (size_t i = 0; i < render_text->text().length(); ++i) {
-    render_text->MoveCursor(CHARACTER_BREAK, CURSOR_RIGHT, SELECTION_NONE);
+    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();
+    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) {
   // LTR 2-character grapheme, LTR abc, LTR 2-character grapheme.
   const base::string16 kText1 =
       WideToUTF16(L"\x0915\x093f" L"abc" L"\x0915\x093f");
@@ skipping 77 matching lines @@
   if (base::win::GetVersion() < base::win::VERSION_VISTA)
     return;
 #endif
 
   // Test that selection bounds may be set amid multi-character graphemes.
   const base::string16 kHindi = WideToUTF16(L"\x0915\x093f");
   const base::string16 kThai = WideToUTF16(L"\x0e08\x0e33");
   const base::string16 cases[] = { kHindi, kThai };
 
   RenderText* render_text = GetRenderText();
+  render_text->SetDisplayRect(Rect(100, 1000));
   for (size_t i = 0; i < arraysize(cases); i++) {
     SCOPED_TRACE(base::StringPrintf("Testing cases[%" PRIuS "]", i));
     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 whole grapheme is selected even if the selection is set

[msw, 2016/12/19 22:27:43]

Hmm, maybe clarify this comment "Verify that the selection bounds extend over
the entire grapheme, even if the selection is set amid the grapheme."

If we actually want different behavior (ie. selecting an accent character should
actually just draw a selection rectangle around the accent glyph's bounds, not
the whole grapheme), then file/cite a bug?

[karandeepb, 2016/12/21 14:23:44]

Done. Think selecting the whole grapheme is the correct behavior.

+    // amid the grapheme.
+    test_api()->EnsureLayout();
+    const gfx::Rect mid_grapheme_bounds = GetSelectionBoundsUnion();
+    render_text->SelectAll(false);
+    EXPECT_EQ(GetSelectionBoundsUnion(), 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());
   }
 }
 
 // TODO(asvitkine): RenderTextMac cursor movements. http://crbug.com/131618
 TEST_P(RenderTextHarfBuzzTest, FindCursorPosition) {
   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) {
+  const wchar_t* kTestStrings[] = {L"abc def",
+                                   L"\x5d0\x5d1\x5d2 \x5d3\x5d4\x5d5" /*rtl*/};
+
+  SetGlyphWidth(5);
+  RenderText* render_text = GetRenderText();
+  render_text->SetDisplayRect(Rect(25, 1000));
+  render_text->SetMultiline(true);
+
+  for (size_t i = 0; i < arraysize(kTestStrings); i++) {
+    render_text->SetText(WideToUTF16(kTestStrings[i]));
+    test_api()->EnsureLayout();
+    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 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());
+    }
+  }
+}
+
+// Ensure FindCursorPosition returns positions only at valid grapheme
+// boundaries.
+TEST_P(RenderTextHarfBuzzTest, FindCursorPosition_GraphemeBoundaries) {
+  struct {
+    base::string16 text;
+    std::set<size_t> expected_cursor_positions;
+  } cases[] = {
+      // LTR 2-character grapheme, LTR abc, LTR 2-character grapheme.
+      {WideToUTF16(L"\x0915\x093f"
+                   L"abc"
+                   L"\x0915\x093f"),
+       {0, 2, 3, 4, 5, 7}},
+      // LTR ab, LTR 2-character grapheme, LTR cd.
+      {WideToUTF16(L"ab"
+                   L"\x0915\x093f"
+                   L"cd"),
+       {0, 1, 2, 4, 5, 6}},
+      // LTR ab, surrogate pair composed of two 16 bit characters, LTR cd.
+      {UTF8ToUTF16("ab"
+                   "\xF0\x9D\x84\x9E"
+                   "cd"),
+       {0, 1, 2, 4, 5, 6}}};
+
+  RenderText* render_text = GetRenderText();
+  render_text->SetDisplayRect(gfx::Rect(100, 30));
+  for (size_t i = 0; i < arraysize(cases); i++) {
+    SCOPED_TRACE(base::StringPrintf("Testing case %" PRIuS "", i));
+    render_text->SetText(cases[i].text);
+    test_api()->EnsureLayout();
+    std::set<size_t> obtained_cursor_positions;
+    size_t cursor_y = GetCursorYForTesting();
+    for (int x = -5; x < 105; x++)
+      obtained_cursor_positions.insert(
+          render_text->FindCursorPosition(gfx::Point(x, cursor_y)).caret_pos());
+    EXPECT_EQ(cases[i].expected_cursor_positions, obtained_cursor_positions);
+  }
+}
+
 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.
   const base::string16 kRTLGrapheme = WideToUTF16(L"\x05e0\x05b8");
@@ skipping 1055 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 = 200;
+  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