Reduce the number of text reshaping in RenderText

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 <algorithm>
 
 #include "base/format_macros.h"
 #include "base/i18n/break_iterator.h"
@@ skipping 232 matching lines @@
 
 TEST_F(RenderTextTest, ObscuredText) {
   const base::string16 seuss = ASCIIToUTF16("hop on pop");
   const base::string16 no_seuss = ASCIIToUTF16("**********");
   scoped_ptr<RenderText> render_text(RenderText::CreateInstance());
 
   // GetLayoutText() returns asterisks when the obscured bit is set.
   render_text->SetText(seuss);
   render_text->SetObscured(true);
   EXPECT_EQ(seuss, render_text->text());
-  EXPECT_EQ(no_seuss, render_text->GetLayoutText());
+  EXPECT_EQ(no_seuss, render_text->GetDisplayText());
   render_text->SetObscured(false);
   EXPECT_EQ(seuss, render_text->text());
-  EXPECT_EQ(seuss, render_text->GetLayoutText());
+  EXPECT_EQ(seuss, render_text->GetDisplayText());
 
   render_text->SetObscured(true);
 
   // Surrogate pairs are counted as one code point.
   const base::char16 invalid_surrogates[] = {0xDC00, 0xD800, 0};
   render_text->SetText(invalid_surrogates);
-  EXPECT_EQ(ASCIIToUTF16("**"), render_text->GetLayoutText());
+  EXPECT_EQ(ASCIIToUTF16("**"), render_text->GetDisplayText());
   const base::char16 valid_surrogates[] = {0xD800, 0xDC00, 0};
   render_text->SetText(valid_surrogates);
-  EXPECT_EQ(ASCIIToUTF16("*"), render_text->GetLayoutText());
+  EXPECT_EQ(ASCIIToUTF16("*"), render_text->GetDisplayText());
   EXPECT_EQ(0U, render_text->cursor_position());
   render_text->MoveCursor(CHARACTER_BREAK, CURSOR_RIGHT, false);
   EXPECT_EQ(2U, render_text->cursor_position());
 
   // Test index conversion and cursor validity with a valid surrogate pair.
-  EXPECT_EQ(0U, render_text->TextIndexToLayoutIndex(0U));
-  EXPECT_EQ(1U, render_text->TextIndexToLayoutIndex(1U));
-  EXPECT_EQ(1U, render_text->TextIndexToLayoutIndex(2U));
-  EXPECT_EQ(0U, render_text->LayoutIndexToTextIndex(0U));
-  EXPECT_EQ(2U, render_text->LayoutIndexToTextIndex(1U));
+  EXPECT_EQ(0U, render_text->TextIndexToDisplayIndex(0U));
+  EXPECT_EQ(1U, render_text->TextIndexToDisplayIndex(1U));
+  EXPECT_EQ(1U, render_text->TextIndexToDisplayIndex(2U));
+  EXPECT_EQ(0U, render_text->DisplayIndexToTextIndex(0U));
+  EXPECT_EQ(2U, render_text->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);
   for (int x = -1; x <= 20; ++x) {
     SelectionModel selection = render_text->FindCursorPosition(Point(x, 0));
@@ skipping 18 matching lines @@
 }
 
 TEST_F(RenderTextTest, RevealObscuredText) {
   const base::string16 seuss = ASCIIToUTF16("hop on pop");
   const base::string16 no_seuss = ASCIIToUTF16("**********");
   scoped_ptr<RenderText> render_text(RenderText::CreateInstance());
 
   render_text->SetText(seuss);
   render_text->SetObscured(true);
   EXPECT_EQ(seuss, render_text->text());
-  EXPECT_EQ(no_seuss, render_text->GetLayoutText());
+  EXPECT_EQ(no_seuss, render_text->GetDisplayText());
 
   // Valid reveal index and new revealed index clears previous one.
   render_text->RenderText::SetObscuredRevealIndex(0);
-  EXPECT_EQ(ASCIIToUTF16("h*********"), render_text->GetLayoutText());
+  EXPECT_EQ(ASCIIToUTF16("h*********"), render_text->GetDisplayText());
   render_text->RenderText::SetObscuredRevealIndex(1);
-  EXPECT_EQ(ASCIIToUTF16("*o********"), render_text->GetLayoutText());
+  EXPECT_EQ(ASCIIToUTF16("*o********"), render_text->GetDisplayText());
   render_text->RenderText::SetObscuredRevealIndex(2);
-  EXPECT_EQ(ASCIIToUTF16("**p*******"), render_text->GetLayoutText());
+  EXPECT_EQ(ASCIIToUTF16("**p*******"), render_text->GetDisplayText());
 
   // Invalid reveal index.
   render_text->RenderText::SetObscuredRevealIndex(-1);
-  EXPECT_EQ(no_seuss, render_text->GetLayoutText());
+  EXPECT_EQ(no_seuss, render_text->GetDisplayText());
   render_text->RenderText::SetObscuredRevealIndex(seuss.length() + 1);
-  EXPECT_EQ(no_seuss, render_text->GetLayoutText());
+  EXPECT_EQ(no_seuss, render_text->GetDisplayText());
 
   // SetObscured clears the revealed index.
   render_text->RenderText::SetObscuredRevealIndex(0);
-  EXPECT_EQ(ASCIIToUTF16("h*********"), render_text->GetLayoutText());
+  EXPECT_EQ(ASCIIToUTF16("h*********"), render_text->GetDisplayText());
   render_text->SetObscured(false);
-  EXPECT_EQ(seuss, render_text->GetLayoutText());
+  EXPECT_EQ(seuss, render_text->GetDisplayText());
   render_text->SetObscured(true);
-  EXPECT_EQ(no_seuss, render_text->GetLayoutText());
+  EXPECT_EQ(no_seuss, render_text->GetDisplayText());
 
   // SetText clears the revealed index.
   render_text->SetText(ASCIIToUTF16("new"));
-  EXPECT_EQ(ASCIIToUTF16("***"), render_text->GetLayoutText());
+  EXPECT_EQ(ASCIIToUTF16("***"), render_text->GetDisplayText());
   render_text->RenderText::SetObscuredRevealIndex(2);
-  EXPECT_EQ(ASCIIToUTF16("**w"), render_text->GetLayoutText());
+  EXPECT_EQ(ASCIIToUTF16("**w"), render_text->GetDisplayText());
   render_text->SetText(ASCIIToUTF16("new longer"));
-  EXPECT_EQ(ASCIIToUTF16("**********"), render_text->GetLayoutText());
+  EXPECT_EQ(ASCIIToUTF16("**********"), render_text->GetDisplayText());
 
   // Text with invalid surrogates.
   const base::char16 invalid_surrogates[] = {0xDC00, 0xD800, 'h', 'o', 'p', 0};
   render_text->SetText(invalid_surrogates);
-  EXPECT_EQ(ASCIIToUTF16("*****"), render_text->GetLayoutText());
+  EXPECT_EQ(ASCIIToUTF16("*****"), render_text->GetDisplayText());
   render_text->RenderText::SetObscuredRevealIndex(0);
   const base::char16 invalid_expect_0[] = {0xDC00, '*', '*', '*', '*', 0};
-  EXPECT_EQ(invalid_expect_0, render_text->GetLayoutText());
+  EXPECT_EQ(invalid_expect_0, render_text->GetDisplayText());
   render_text->RenderText::SetObscuredRevealIndex(1);
   const base::char16 invalid_expect_1[] = {'*', 0xD800, '*', '*', '*', 0};
-  EXPECT_EQ(invalid_expect_1, render_text->GetLayoutText());
+  EXPECT_EQ(invalid_expect_1, render_text->GetDisplayText());
   render_text->RenderText::SetObscuredRevealIndex(2);
-  EXPECT_EQ(ASCIIToUTF16("**h**"), render_text->GetLayoutText());
+  EXPECT_EQ(ASCIIToUTF16("**h**"), render_text->GetDisplayText());
 
   // Text with valid surrogates before and after the reveal index.
   const base::char16 valid_surrogates[] =
       {0xD800, 0xDC00, 'h', 'o', 'p', 0xD800, 0xDC00, 0};
   render_text->SetText(valid_surrogates);
-  EXPECT_EQ(ASCIIToUTF16("*****"), render_text->GetLayoutText());
+  EXPECT_EQ(ASCIIToUTF16("*****"), render_text->GetDisplayText());
   render_text->RenderText::SetObscuredRevealIndex(0);
   const base::char16 valid_expect_0_and_1[] =
       {0xD800, 0xDC00, '*', '*', '*', '*', 0};
-  EXPECT_EQ(valid_expect_0_and_1, render_text->GetLayoutText());
+  EXPECT_EQ(valid_expect_0_and_1, render_text->GetDisplayText());
   render_text->RenderText::SetObscuredRevealIndex(1);
-  EXPECT_EQ(valid_expect_0_and_1, render_text->GetLayoutText());
+  EXPECT_EQ(valid_expect_0_and_1, render_text->GetDisplayText());
   render_text->RenderText::SetObscuredRevealIndex(2);
-  EXPECT_EQ(ASCIIToUTF16("*h***"), render_text->GetLayoutText());
+  EXPECT_EQ(ASCIIToUTF16("*h***"), render_text->GetDisplayText());
   render_text->RenderText::SetObscuredRevealIndex(5);
   const base::char16 valid_expect_5_and_6[] =
       {'*', '*', '*', '*', 0xD800, 0xDC00, 0};
-  EXPECT_EQ(valid_expect_5_and_6, render_text->GetLayoutText());
+  EXPECT_EQ(valid_expect_5_and_6, render_text->GetDisplayText());
   render_text->RenderText::SetObscuredRevealIndex(6);
-  EXPECT_EQ(valid_expect_5_and_6, render_text->GetLayoutText());
+  EXPECT_EQ(valid_expect_5_and_6, render_text->GetDisplayText());
 }
 
 TEST_F(RenderTextTest, ElidedText) {
   // TODO(skanuj) : Add more test cases for following
   // - RenderText styles.
   // - Cross interaction of truncate, elide and obscure.
   // - ElideText tests from text_elider.cc.
   struct {
     const wchar_t* text;
     const wchar_t* layout_text;

[msw, 2015/02/13 22:19:05]

ping nit: rename this |display_text|

[oshima, 2015/02/13 23:24:11]

Done.

     const bool elision_expected;
   } cases[] = {
     // Strings shorter than the elision width should be laid out in full.
     { L"",        L""       , false },
     { L"M",       L""       , false },
     { L" . ",     L" . "    , false },
     { kWeak,      kWeak     , false },
     { kLtr,       kLtr      , false },
     { kLtrRtl,    kLtrRtl   , false },
     { kLtrRtlLtr, kLtrRtlLtr, false },
@@ skipping 23 matching lines @@
 
   scoped_ptr<RenderText> expected_render_text(RenderText::CreateInstance());
   expected_render_text->SetFontList(FontList("serif, Sans serif, 12px"));
   expected_render_text->SetDisplayRect(Rect(0, 0, 9999, 100));
 
   scoped_ptr<RenderText> render_text(RenderText::CreateInstance());
   render_text->SetFontList(FontList("serif, Sans serif, 12px"));
   render_text->SetElideBehavior(ELIDE_TAIL);
 
   for (size_t i = 0; i < arraysize(cases); i++) {
+    SCOPED_TRACE(base::StringPrintf("Testing cases[%" PRIuS "] '%ls'", i,
+                                    cases[i].text));
+
     // Compute expected width
     expected_render_text->SetText(WideToUTF16(cases[i].layout_text));
     int expected_width = expected_render_text->GetContentWidth();
 
     base::string16 input = WideToUTF16(cases[i].text);
     // Extend the input text to ensure that it is wider than the layout_text,
     // and so it will get elided.
     if (cases[i].elision_expected)
       input.append(WideToUTF16(L" MMMMMMMMMMM"));
-
     render_text->SetText(input);
     render_text->SetDisplayRect(Rect(0, 0, expected_width, 100));
-    EXPECT_EQ(input, render_text->text())
-        << "->For case " << i << ": " << cases[i].text << "\n";
-    EXPECT_EQ(WideToUTF16(cases[i].layout_text), render_text->GetLayoutText())
-        << "->For case " << i << ": " << cases[i].text << "\n";
+    EXPECT_EQ(input, render_text->text());
+    EXPECT_EQ(WideToUTF16(cases[i].layout_text), render_text->GetDisplayText());
     expected_render_text->SetText(base::string16());
   }
 }
 
 TEST_F(RenderTextTest, ElidedObscuredText) {
   scoped_ptr<RenderText> expected_render_text(RenderText::CreateInstance());
   expected_render_text->SetFontList(FontList("serif, Sans serif, 12px"));
   expected_render_text->SetDisplayRect(Rect(0, 0, 9999, 100));
   expected_render_text->SetText(WideToUTF16(L"**\x2026"));
 
   scoped_ptr<RenderText> render_text(RenderText::CreateInstance());
   render_text->SetFontList(FontList("serif, Sans serif, 12px"));
   render_text->SetElideBehavior(ELIDE_TAIL);
   render_text->SetDisplayRect(
       Rect(0, 0, expected_render_text->GetContentWidth(), 100));
   render_text->SetObscured(true);
   render_text->SetText(WideToUTF16(L"abcdef"));
   EXPECT_EQ(WideToUTF16(L"abcdef"), render_text->text());
-  EXPECT_EQ(WideToUTF16(L"**\x2026"), render_text->GetLayoutText());
+  EXPECT_EQ(WideToUTF16(L"**\x2026"), render_text->GetDisplayText());
 }
 
 TEST_F(RenderTextTest, TruncatedText) {
   struct {
     const wchar_t* text;
     const wchar_t* layout_text;
   } cases[] = {
     // Strings shorter than the truncation length should be laid out in full.
     { L"",        L""        },
     { kWeak,      kWeak      },
@@ skipping 22 matching lines @@
     { L"0123\x05e9\x05bc\x05c1\x05b8",  L"0123\x2026"                },
     { L"01234\x05e9\x05bc\x05c1\x05b8", L"0123\x2026"                },
     { L"012\xF0\x9D\x84\x9E",           L"012\xF0\x2026"             },
   };
 
   scoped_ptr<RenderText> render_text(RenderText::CreateInstance());
   render_text->set_truncate_length(5);
   for (size_t i = 0; i < arraysize(cases); i++) {
     render_text->SetText(WideToUTF16(cases[i].text));
     EXPECT_EQ(WideToUTF16(cases[i].text), render_text->text());
-    EXPECT_EQ(WideToUTF16(cases[i].layout_text), render_text->GetLayoutText())
+    EXPECT_EQ(WideToUTF16(cases[i].layout_text), render_text->GetDisplayText())
         << "For case " << i << ": " << cases[i].text;
   }
 }
 
 TEST_F(RenderTextTest, TruncatedObscuredText) {
   scoped_ptr<RenderText> render_text(RenderText::CreateInstance());
   render_text->set_truncate_length(3);
   render_text->SetObscured(true);
   render_text->SetText(WideToUTF16(L"abcdef"));
   EXPECT_EQ(WideToUTF16(L"abcdef"), render_text->text());
-  EXPECT_EQ(WideToUTF16(L"**\x2026"), render_text->GetLayoutText());
+  EXPECT_EQ(WideToUTF16(L"**\x2026"), render_text->GetDisplayText());
 }
 
 TEST_F(RenderTextTest, TruncatedCursorMovementLTR) {
   scoped_ptr<RenderText> render_text(RenderText::CreateInstance());
   render_text->set_truncate_length(2);
   render_text->SetText(WideToUTF16(L"abcd"));
 
   EXPECT_EQ(SelectionModel(0, CURSOR_BACKWARD), render_text->selection_model());
   render_text->MoveCursor(LINE_BREAK, CURSOR_RIGHT, false);
   EXPECT_EQ(SelectionModel(4, CURSOR_FORWARD), render_text->selection_model());
@@ skipping 38 matching lines @@
 
   expected.clear();
   expected.push_back(SelectionModel(4, CURSOR_FORWARD));
   // The cursor hops over the elided text to preceeding text.
   expected.push_back(SelectionModel(1, CURSOR_FORWARD));
   expected.push_back(SelectionModel(0, CURSOR_FORWARD));
   expected.push_back(SelectionModel(0, CURSOR_BACKWARD));
   RunMoveCursorLeftRightTest(render_text.get(), expected, CURSOR_RIGHT);
 }
 
-TEST_F(RenderTextTest, GetTextDirection) {
+TEST_F(RenderTextTest, GetDisplayTextDirection) {
   struct {
     const wchar_t* text;
     const base::i18n::TextDirection text_direction;
   } cases[] = {
     // Blank strings and those with no/weak directionality default to LTR.
     { L"",        base::i18n::LEFT_TO_RIGHT },
     { kWeak,      base::i18n::LEFT_TO_RIGHT },
     // Strings that begin with strong LTR characters.
     { kLtr,       base::i18n::LEFT_TO_RIGHT },
     { kLtrRtl,    base::i18n::LEFT_TO_RIGHT },
@@ skipping 10 matching lines @@
   for (size_t i = 0; i < 2; ++i) {
     // Toggle the application default text direction (to try each direction).
     SetRTL(!base::i18n::IsRTL());
     const base::i18n::TextDirection ui_direction = base::i18n::IsRTL() ?
         base::i18n::RIGHT_TO_LEFT : base::i18n::LEFT_TO_RIGHT;
 
     // Ensure that directionality modes yield the correct text directions.
     for (size_t j = 0; j < arraysize(cases); j++) {
       render_text->SetText(WideToUTF16(cases[j].text));
       render_text->SetDirectionalityMode(DIRECTIONALITY_FROM_TEXT);
-      EXPECT_EQ(render_text->GetTextDirection(), cases[j].text_direction);
+      EXPECT_EQ(render_text->GetDisplayTextDirection(),cases[j].text_direction);
       render_text->SetDirectionalityMode(DIRECTIONALITY_FROM_UI);
-      EXPECT_EQ(render_text->GetTextDirection(), ui_direction);
+      EXPECT_EQ(render_text->GetDisplayTextDirection(), ui_direction);
       render_text->SetDirectionalityMode(DIRECTIONALITY_FORCE_LTR);
-      EXPECT_EQ(render_text->GetTextDirection(), base::i18n::LEFT_TO_RIGHT);
+      EXPECT_EQ(render_text->GetDisplayTextDirection(),
+                base::i18n::LEFT_TO_RIGHT);
       render_text->SetDirectionalityMode(DIRECTIONALITY_FORCE_RTL);
-      EXPECT_EQ(render_text->GetTextDirection(), base::i18n::RIGHT_TO_LEFT);
+      EXPECT_EQ(render_text->GetDisplayTextDirection(),
+                base::i18n::RIGHT_TO_LEFT);
     }
   }
 
   EXPECT_EQ(was_rtl, base::i18n::IsRTL());
 
   // Ensure that text changes update the direction for DIRECTIONALITY_FROM_TEXT.
   render_text->SetDirectionalityMode(DIRECTIONALITY_FROM_TEXT);
   render_text->SetText(WideToUTF16(kLtr));
-  EXPECT_EQ(render_text->GetTextDirection(), base::i18n::LEFT_TO_RIGHT);
+  EXPECT_EQ(render_text->GetDisplayTextDirection(), base::i18n::LEFT_TO_RIGHT);
   render_text->SetText(WideToUTF16(kRtl));
-  EXPECT_EQ(render_text->GetTextDirection(), base::i18n::RIGHT_TO_LEFT);
+  EXPECT_EQ(render_text->GetDisplayTextDirection(), base::i18n::RIGHT_TO_LEFT);
 }
 
 TEST_F(RenderTextTest, MoveCursorLeftRightInLtr) {
   scoped_ptr<RenderText> render_text(RenderText::CreateInstance());
 
   // Pure LTR.
   render_text->SetText(ASCIIToUTF16("abc"));
   // |expected| saves the expected SelectionModel when moving cursor from left
   // to right.
   std::vector<SelectionModel> expected;
@@ skipping 722 matching lines @@
 
 TEST_F(RenderTextTest, MinLineHeight) {
   scoped_ptr<RenderText> render_text(RenderText::CreateInstance());
 
   render_text->SetText(ASCIIToUTF16("Hello!"));
   SizeF default_size = render_text->GetStringSizeF();
   ASSERT_NE(0, default_size.height());
   ASSERT_NE(0, default_size.width());
 
   render_text->SetMinLineHeight(default_size.height() / 2);
-  // MacOSX does not recompute the bounds properly, so invoke ResetLayout()
-  // explicitly.
-  // TODO(mukai): fix this.
-  render_text->ResetLayout();
   EXPECT_EQ(default_size.ToString(), render_text->GetStringSizeF().ToString());
 
   render_text->SetMinLineHeight(default_size.height() * 2);
-  render_text->ResetLayout();
   SizeF taller_size = render_text->GetStringSizeF();
   EXPECT_EQ(default_size.height() * 2, taller_size.height());
   EXPECT_EQ(default_size.width(), taller_size.width());
 }
 
 TEST_F(RenderTextTest, SetFontList) {
   scoped_ptr<RenderText> render_text(RenderText::CreateInstance());
   render_text->SetFontList(FontList("Arial,Symbol, 13px"));
   const std::vector<Font>& fonts = render_text->font_list().GetFonts();
   ASSERT_EQ(2U, fonts.size());
@@ skipping 608 matching lines @@
       continue;
 
     for (size_t j = 0; j < kTestStrings[i].lines_count; ++j) {
       SCOPED_TRACE(base::StringPrintf("Line %" PRIuS "", j));
       VerifyLineSegments(kTestStrings[i].line_char_ranges[j],
                          render_text.lines_[j].segments);
     }
   }
 }
 
+// Make sure that multiline mode ignores elide behavior.
+TEST_F(RenderTextTest, Multiline_IgnoreElide) {
+  const wchar_t kTestString[] =
+      L"very very very long string xxxxxxxxxxxxxxxxxxxxxxxxxx";
+  const wchar_t kEllipsis[] = L"\x2026";
+
+  RenderTextHarfBuzz render_text;
+  render_text.SetElideBehavior(ELIDE_TAIL);
+  render_text.SetDisplayRect(Rect(20, 1000));
+  render_text.SetText(base::WideToUTF16(kTestString));
+  EXPECT_NE(base::string16::npos,
+            render_text.GetDisplayText().find(base::WideToUTF16(kEllipsis)));
+
+  render_text.SetMultiline(true);
+  EXPECT_EQ(base::string16::npos,
+            render_text.GetDisplayText().find(base::WideToUTF16(kEllipsis)));
+}
+
 TEST_F(RenderTextTest, NewlineWithoutMultilineFlag) {
   const wchar_t* kTestStrings[] = {
     L"abc\ndef", L"a \n b ", L"ab\n", L"a\n\nb", L"\nab", L"\n",
   };
 
   RenderTextHarfBuzz render_text;
   render_text.SetDisplayRect(Rect(200, 1000));
   Canvas canvas;
 
   for (size_t i = 0; i < arraysize(kTestStrings); ++i) {
@@ skipping 74 matching lines @@
   };
 
   RenderTextHarfBuzz render_text;
 
   for (size_t i = 0; i < arraysize(cases); ++i) {
     SCOPED_TRACE(base::StringPrintf("Case %" PRIuS, i));
 
     base::string16 text = WideToUTF16(cases[i]);
     render_text.SetText(text);
     render_text.EnsureLayout();
-    ASSERT_EQ(1U, render_text.runs_.size());
-    internal::TextRunHarfBuzz* run = render_text.runs_[0];
+    internal::TextRunList* run_list = render_text.GetRunList();
+    ASSERT_EQ(1U, run_list->size());
+    internal::TextRunHarfBuzz* run = run_list->runs()[0];
 
     base::i18n::BreakIterator* iter = render_text.grapheme_iterator_.get();
     auto first_grapheme_bounds = run->GetGraphemeBounds(iter, 0);
     EXPECT_EQ(first_grapheme_bounds, run->GetGraphemeBounds(iter, 1));
     auto second_grapheme_bounds = run->GetGraphemeBounds(iter, 2);
     EXPECT_EQ(first_grapheme_bounds.second, second_grapheme_bounds.first);
   }
 }
 
 // Test the partition of a multi-grapheme cluster into grapheme ranges.
@@ skipping 51 matching lines @@
     }
   }
 }
 
 TEST_F(RenderTextTest, HarfBuzz_RunDirection) {
   RenderTextHarfBuzz render_text;
   const base::string16 mixed =
       WideToUTF16(L"\x05D0\x05D1" L"1234" L"\x05D2\x05D3");
   render_text.SetText(mixed);
   render_text.EnsureLayout();
-  ASSERT_EQ(3U, render_text.runs_.size());
-  EXPECT_TRUE(render_text.runs_[0]->is_rtl);
-  EXPECT_FALSE(render_text.runs_[1]->is_rtl);
-  EXPECT_TRUE(render_text.runs_[2]->is_rtl);
+  internal::TextRunList* run_list = render_text.GetRunList();
+  ASSERT_EQ(3U, run_list->size());
+  EXPECT_TRUE(run_list->runs()[0]->is_rtl);
+  EXPECT_FALSE(run_list->runs()[1]->is_rtl);
+  EXPECT_TRUE(run_list->runs()[2]->is_rtl);
 }
 
 TEST_F(RenderTextTest, HarfBuzz_BreakRunsByUnicodeBlocks) {
   RenderTextHarfBuzz render_text;
 
   // The '\x25B6' "play character" should break runs. http://crbug.com/278913
   render_text.SetText(WideToUTF16(L"x\x25B6y"));
   render_text.EnsureLayout();
-  ASSERT_EQ(3U, render_text.runs_.size());
-  EXPECT_EQ(Range(0, 1), render_text.runs_[0]->range);
-  EXPECT_EQ(Range(1, 2), render_text.runs_[1]->range);
-  EXPECT_EQ(Range(2, 3), render_text.runs_[2]->range);
+  internal::TextRunList* run_list = render_text.GetRunList();
+  ASSERT_EQ(3U, run_list->size());
+  EXPECT_EQ(Range(0, 1), run_list->runs()[0]->range);
+  EXPECT_EQ(Range(1, 2), run_list->runs()[1]->range);
+  EXPECT_EQ(Range(2, 3), run_list->runs()[2]->range);
 
   render_text.SetText(WideToUTF16(L"x \x25B6 y"));
   render_text.EnsureLayout();
-  ASSERT_EQ(3U, render_text.runs_.size());
-  EXPECT_EQ(Range(0, 2), render_text.runs_[0]->range);
-  EXPECT_EQ(Range(2, 3), render_text.runs_[1]->range);
-  EXPECT_EQ(Range(3, 5), render_text.runs_[2]->range);
+  run_list = render_text.GetRunList();
+  ASSERT_EQ(3U, run_list->size());
+  EXPECT_EQ(Range(0, 2), run_list->runs()[0]->range);
+  EXPECT_EQ(Range(2, 3), run_list->runs()[1]->range);
+  EXPECT_EQ(Range(3, 5), run_list->runs()[2]->range);
 }
 
 TEST_F(RenderTextTest, HarfBuzz_BreakRunsByEmoji) {
   RenderTextHarfBuzz render_text;
 
   // \xF0\x9F\x98\x81 (U+1F601) is smile icon emoji. \xE2\x9C\xA8 (U+2728) is
   // a sparkle icon. Both can be drawn with color emoji fonts, so runs should be
   // separated. See crbug.com/448909
   render_text.SetText(UTF8ToUTF16("x\xF0\x9F\x98\x81y\xE2\x9C\xA8"));
   render_text.EnsureLayout();
-  ASSERT_EQ(4U, render_text.runs_.size());
-  EXPECT_EQ(Range(0, 1), render_text.runs_[0]->range);
+  internal::TextRunList* run_list = render_text.GetRunList();
+  ASSERT_EQ(4U, run_list->size());
+  EXPECT_EQ(Range(0, 1), run_list->runs()[0]->range);
   // The length is 2 since U+1F601 is represented as a surrogate pair in UTF16.
-  EXPECT_EQ(Range(1, 3), render_text.runs_[1]->range);
-  EXPECT_EQ(Range(3, 4), render_text.runs_[2]->range);
-  EXPECT_EQ(Range(4, 5), render_text.runs_[3]->range);
+  EXPECT_EQ(Range(1, 3), run_list->runs()[1]->range);
+  EXPECT_EQ(Range(3, 4), run_list->runs()[2]->range);
+  EXPECT_EQ(Range(4, 5), run_list->runs()[3]->range);
 }
 
 TEST_F(RenderTextTest, GlyphBounds) {
   const wchar_t* kTestStrings[] = {
       L"asdf 1234 qwer", L"\x0647\x0654", L"\x0645\x0631\x062D\x0628\x0627"
   };
   scoped_ptr<RenderText> render_text(new RenderTextHarfBuzz);
 
   for (size_t i = 0; i < arraysize(kTestStrings); ++i) {
     render_text->SetText(WideToUTF16(kTestStrings[i]));
     render_text->EnsureLayout();
 
     for (size_t j = 0; j < render_text->text().length(); ++j)
       EXPECT_FALSE(render_text->GetGlyphBounds(j).is_empty());
   }
 }
 
 // Ensure that shaping with a non-existent font does not cause a crash.
 TEST_F(RenderTextTest, HarfBuzz_NonExistentFont) {
   RenderTextHarfBuzz render_text;
   render_text.SetText(ASCIIToUTF16("test"));
   render_text.EnsureLayout();
-  ASSERT_EQ(1U, render_text.runs_.size());
-  internal::TextRunHarfBuzz* run = render_text.runs_[0];
+  internal::TextRunList* run_list = render_text.GetRunList();
+  ASSERT_EQ(1U, run_list->size());
+  internal::TextRunHarfBuzz* run = run_list->runs()[0];
   render_text.ShapeRunWithFont(
-      run, "TheFontThatDoesntExist", FontRenderParams());
+      render_text.text(), "TheFontThatDoesntExist", FontRenderParams(), run);
 }
 
 // Ensure an empty run returns sane values to queries.
 TEST_F(RenderTextTest, HarfBuzz_EmptyRun) {
   internal::TextRunHarfBuzz run;
   const base::string16 kString = ASCIIToUTF16("abcdefgh");
   scoped_ptr<base::i18n::BreakIterator> iter(new base::i18n::BreakIterator(
       kString, base::i18n::BreakIterator::BREAK_CHARACTER));
   ASSERT_TRUE(iter->Init());
 
@@ skipping 12 matching lines @@
 // Ensure a string fits in a display rect with a width equal to the string's.
 TEST_F(RenderTextTest, StringFitsOwnWidth) {
   scoped_ptr<RenderText> render_text(RenderText::CreateInstance());
   const base::string16 kString = ASCIIToUTF16("www.example.com");
 
   render_text->SetText(kString);
   render_text->ApplyStyle(BOLD, true, Range(0, 3));
   render_text->SetElideBehavior(ELIDE_TAIL);
 
   render_text->SetDisplayRect(Rect(0, 0, 500, 100));
-  EXPECT_EQ(kString, render_text->GetLayoutText());
+  EXPECT_EQ(kString, render_text->GetDisplayText());
   render_text->SetDisplayRect(Rect(0, 0, render_text->GetContentWidth(), 100));
-  EXPECT_EQ(kString, render_text->GetLayoutText());
+  EXPECT_EQ(kString, render_text->GetDisplayText());
 }
 
 // TODO(derat): Figure out why this fails on Windows: http://crbug.com/427184
 #if !defined(OS_WIN)
 // Ensure that RenderText examines all of the fonts in its FontList before
 // falling back to other fonts.
 TEST_F(RenderTextTest, HarfBuzz_FontListFallback) {
   // Double-check that the requested fonts are present.
   FontList font_list("Arial, Symbol, 12px");
   const std::vector<Font>& fonts = font_list.GetFonts();
@@ skipping 22 matching lines @@
   PlatformFontWin* font_win = new PlatformFontWin("Meiryo", 12);
   // Japanese name for Meiryo. This name won't be found in the system's linked
   // fonts, forcing RTHB to try the Uniscribe font and its fallbacks.
   font_win->font_ref_->font_name_ = WideToUTF8(L"\x30e1\x30a4\x30ea\x30aa");
   FontList font_list((Font(font_win)));
 
   render_text.SetFontList(font_list);
   // Korean character "han".
   render_text.SetText(WideToUTF16(L"\xd55c"));
   render_text.EnsureLayout();
-  ASSERT_EQ(1U, render_text.runs_.size());
-  EXPECT_EQ(0U, render_text.runs_[0]->CountMissingGlyphs());
+  internal::TextRunList* run_list = render_text.GetRunList();
+  ASSERT_EQ(1U, run_list->size());
+  EXPECT_EQ(0U, run_list->runs()[0]->CountMissingGlyphs());
 }
 #endif  // defined(OS_WIN)
 
 // Ensure that the width reported by RenderText is sufficient for drawing. Draws
 // to a canvas and checks whether any pixel beyond the width is colored.
 TEST_F(RenderTextTest, TextDoesntClip) {
   const wchar_t* kTestStrings[] = { L"Save", L"Remove", L"TEST", L"W", L"WWW" };
   const Size kCanvasSize(300, 50);
   const int kTestWidth = 10;
 
@@ skipping 56 matching lines @@
             base::StringToLowerASCII(fonts[0].GetActualFontNameForTesting()));
 
   scoped_ptr<RenderText> render_text(RenderText::CreateInstance());
   render_text->SetDisplayRect(Rect(0, 0, 25, 25));
   render_text->SetFontList(font_list);
   EXPECT_GT(render_text->GetBaseline(), font_list.GetBaseline());
 }
 #endif
 
 }  // namespace gfx