Cleanup render text tests to use RenderTextTestApi.

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 59 matching lines @@
     RenderTextHarfBuzz* render_text =
         static_cast<RenderTextHarfBuzz*>(render_text_);
     return render_text->GetRunList();
   }
 
   void DrawVisualText(internal::SkiaTextRenderer* renderer) {
     render_text_->EnsureLayout();
     render_text_->DrawVisualText(renderer);
   }
 
+  const BreakList<SkColor>& colors() const { return render_text_->colors(); }
+
+  const BreakList<BaselineStyle>& baselines() const {
+    return render_text_->baselines();
+  }
+
+  const BreakList<Font::Weight>& weights() const {
+    return render_text_->weights();
+  }
+
+  const std::vector<BreakList<bool>>& styles() const {
+    return render_text_->styles();
+  }
+
+  const std::vector<internal::Line>& lines() const {
+    return render_text_->lines();
+  }
+
+  SelectionModel EdgeSelectionModel(VisualCursorDirection direction) {
+    return render_text_->EdgeSelectionModel(direction);
+  }
+
+  size_t TextIndexToDisplayIndex(size_t index) {
+    return render_text_->TextIndexToDisplayIndex(index);
+  }
+
+  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);
+  }
+
  private:
   RenderText* render_text_;
 
   DISALLOW_COPY_AND_ASSIGN(RenderTextTestApi);
 };
 
 }  // namespace test
 
 namespace {
 
@@ skipping 250 matching lines @@
 
 #if defined(OS_MACOSX)
   RenderTextMac* GetRenderTextMac() {
     DCHECK_EQ(RENDER_TEXT_MAC, GetParam());
     return static_cast<RenderTextMac*>(GetRenderText());
   }
 #endif
 
   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_;
 
 #if defined(OS_WIN)
   // Needed to bypass DCHECK in GetFallbackFont.
   base::MessageLoopForUI message_loop_;
 #endif
 
   DISALLOW_COPY_AND_ASSIGN(RenderTextTest);
 };
 
 // Test fixture class. Use for tests which are only to be run for
 // RenderTextHarfBuzz.
 class RenderTextHarfBuzzTest : public RenderTextTest {
  public:
   RenderTextHarfBuzzTest() {}
 
   // Overridden from testing::Test:
-  void SetUp() override { DCHECK_EQ(RENDER_TEXT_HARFBUZZ, GetParam()); }
+  void SetUp() override {
+    RenderTextTest::SetUp();
+    DCHECK_EQ(RENDER_TEXT_HARFBUZZ, GetParam());
+  }
+
+ protected:
+  void SetGlyphWidth(float test_width) {
+    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);
+  }
+
+  base::i18n::BreakIterator* GetGraphemeIterator() {
+    return GetRenderTextHarfBuzz()->GetGraphemeIterator();
+  }
 
  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() {}
 
   // Overridden from testing::Test:
-  void SetUp() override { DCHECK_EQ(RENDER_TEXT_MAC, GetParam()); }
+  void SetUp() override {
+    RenderTextTest::SetUp();
+    DCHECK_EQ(RENDER_TEXT_MAC, GetParam());
+  }
+
+ protected:
+  base::ScopedCFTypeRef<CTLineRef> GetCoreTextLine() {
+    return GetRenderTextMac()->line_;
+  }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(RenderTextMacTest);
 };
+#endif
 
 TEST_P(RenderTextTest, DefaultStyles) {
   // Check the default styles applied to new instances and adjusted text.
   RenderText* render_text = GetRenderText();
   EXPECT_TRUE(render_text->text().empty());
   const wchar_t* const cases[] = { kWeak, kLtr, L"Hello", kRtl, L"", L"" };
   for (size_t i = 0; i < arraysize(cases); ++i) {
-    EXPECT_TRUE(render_text->colors().EqualsValueForTesting(SK_ColorBLACK));
-    EXPECT_TRUE(
-        render_text->baselines().EqualsValueForTesting(NORMAL_BASELINE));
+    EXPECT_TRUE(test_api()->colors().EqualsValueForTesting(SK_ColorBLACK));
+    EXPECT_TRUE(test_api()->baselines().EqualsValueForTesting(NORMAL_BASELINE));
     for (size_t style = 0; style < NUM_TEXT_STYLES; ++style)
-      EXPECT_TRUE(render_text->styles()[style].EqualsValueForTesting(false));
+      EXPECT_TRUE(test_api()->styles()[style].EqualsValueForTesting(false));
     render_text->SetText(WideToUTF16(cases[i]));
   }
 }
 
 TEST_P(RenderTextTest, SetStyles) {
   // Ensure custom default styles persist across setting and clearing text.
   RenderText* render_text = GetRenderText();
   const SkColor color = SK_ColorRED;
   render_text->SetColor(color);
   render_text->SetBaselineStyle(SUPERSCRIPT);
   render_text->SetWeight(Font::Weight::BOLD);
   render_text->SetStyle(UNDERLINE, false);
   const wchar_t* const cases[] = { kWeak, kLtr, L"Hello", kRtl, L"", L"" };
   for (size_t i = 0; i < arraysize(cases); ++i) {
-    EXPECT_TRUE(render_text->colors().EqualsValueForTesting(color));
-    EXPECT_TRUE(render_text->baselines().EqualsValueForTesting(SUPERSCRIPT));
+    EXPECT_TRUE(test_api()->colors().EqualsValueForTesting(color));
+    EXPECT_TRUE(test_api()->baselines().EqualsValueForTesting(SUPERSCRIPT));
     EXPECT_TRUE(
-        render_text->weights().EqualsValueForTesting(Font::Weight::BOLD));
-    EXPECT_TRUE(render_text->styles()[UNDERLINE].EqualsValueForTesting(false));
+        test_api()->weights().EqualsValueForTesting(Font::Weight::BOLD));
+    EXPECT_TRUE(test_api()->styles()[UNDERLINE].EqualsValueForTesting(false));
     render_text->SetText(WideToUTF16(cases[i]));
 
     // Ensure custom default styles can be applied after text has been set.
     if (i == 1)
       render_text->SetStyle(STRIKE, true);
     if (i >= 1)
-      EXPECT_TRUE(render_text->styles()[STRIKE].EqualsValueForTesting(true));
+      EXPECT_TRUE(test_api()->styles()[STRIKE].EqualsValueForTesting(true));
   }
 }
 
 TEST_P(RenderTextTest, ApplyStyles) {
   RenderText* render_text = GetRenderText();
   render_text->SetText(ASCIIToUTF16("012345678"));
 
   // Apply a ranged color and style and check the resulting breaks.
   render_text->ApplyColor(SK_ColorRED, Range(1, 4));
   render_text->ApplyBaselineStyle(SUPERIOR, Range(2, 4));
   render_text->ApplyWeight(Font::Weight::BOLD, Range(2, 5));
   std::vector<std::pair<size_t, SkColor> > expected_color;
   expected_color.push_back(std::pair<size_t, SkColor>(0, SK_ColorBLACK));
   expected_color.push_back(std::pair<size_t, SkColor>(1, SK_ColorRED));
   expected_color.push_back(std::pair<size_t, SkColor>(4, SK_ColorBLACK));
-  EXPECT_TRUE(render_text->colors().EqualsForTesting(expected_color));
+  EXPECT_TRUE(test_api()->colors().EqualsForTesting(expected_color));
   std::vector<std::pair<size_t, BaselineStyle>> expected_baseline_style;
   expected_baseline_style.push_back(
       std::pair<size_t, BaselineStyle>(0, NORMAL_BASELINE));
   expected_baseline_style.push_back(
       std::pair<size_t, BaselineStyle>(2, SUPERIOR));
   expected_baseline_style.push_back(
       std::pair<size_t, BaselineStyle>(4, NORMAL_BASELINE));
   EXPECT_TRUE(
-      render_text->baselines().EqualsForTesting(expected_baseline_style));
+      test_api()->baselines().EqualsForTesting(expected_baseline_style));
   std::vector<std::pair<size_t, Font::Weight>> expected_weight;
   expected_weight.push_back(
       std::pair<size_t, Font::Weight>(0, Font::Weight::NORMAL));
   expected_weight.push_back(
       std::pair<size_t, Font::Weight>(2, Font::Weight::BOLD));
   expected_weight.push_back(
       std::pair<size_t, Font::Weight>(5, Font::Weight::NORMAL));
-  EXPECT_TRUE(render_text->weights().EqualsForTesting(expected_weight));
+  EXPECT_TRUE(test_api()->weights().EqualsForTesting(expected_weight));
 
   // Ensure that setting a value overrides the ranged values.
   render_text->SetColor(SK_ColorBLUE);
-  EXPECT_TRUE(render_text->colors().EqualsValueForTesting(SK_ColorBLUE));
+  EXPECT_TRUE(test_api()->colors().EqualsValueForTesting(SK_ColorBLUE));
   render_text->SetBaselineStyle(SUBSCRIPT);
-  EXPECT_TRUE(render_text->baselines().EqualsValueForTesting(SUBSCRIPT));
+  EXPECT_TRUE(test_api()->baselines().EqualsValueForTesting(SUBSCRIPT));
   render_text->SetWeight(Font::Weight::NORMAL);
   EXPECT_TRUE(
-      render_text->weights().EqualsValueForTesting(Font::Weight::NORMAL));
+      test_api()->weights().EqualsValueForTesting(Font::Weight::NORMAL));
 
   // Apply a value over the text end and check the resulting breaks (INT_MAX
   // should be used instead of the text length for the range end)
   const size_t text_length = render_text->text().length();
   render_text->ApplyColor(SK_ColorRED, Range(0, text_length));
   render_text->ApplyBaselineStyle(SUPERIOR, Range(0, text_length));
   render_text->ApplyWeight(Font::Weight::BOLD, Range(2, text_length));
   std::vector<std::pair<size_t, SkColor> > expected_color_end;
   expected_color_end.push_back(std::pair<size_t, SkColor>(0, SK_ColorRED));
-  EXPECT_TRUE(render_text->colors().EqualsForTesting(expected_color_end));
+  EXPECT_TRUE(test_api()->colors().EqualsForTesting(expected_color_end));
   std::vector<std::pair<size_t, BaselineStyle>> expected_baseline_end;
   expected_baseline_end.push_back(
       std::pair<size_t, BaselineStyle>(0, SUPERIOR));
-  EXPECT_TRUE(render_text->baselines().EqualsForTesting(expected_baseline_end));
+  EXPECT_TRUE(test_api()->baselines().EqualsForTesting(expected_baseline_end));
   std::vector<std::pair<size_t, Font::Weight>> expected_weight_end;
   expected_weight_end.push_back(
       std::pair<size_t, Font::Weight>(0, Font::Weight::NORMAL));
   expected_weight_end.push_back(
       std::pair<size_t, Font::Weight>(2, Font::Weight::BOLD));
-  EXPECT_TRUE(render_text->weights().EqualsForTesting(expected_weight_end));
+  EXPECT_TRUE(test_api()->weights().EqualsForTesting(expected_weight_end));
 
   // Ensure ranged values adjust to accommodate text length changes.
   render_text->ApplyStyle(ITALIC, true, Range(0, 2));
   render_text->ApplyStyle(ITALIC, true, Range(3, 6));
   render_text->ApplyStyle(ITALIC, true, Range(7, text_length));
   std::vector<std::pair<size_t, bool> > expected_italic;
   expected_italic.push_back(std::pair<size_t, bool>(0, true));
   expected_italic.push_back(std::pair<size_t, bool>(2, false));
   expected_italic.push_back(std::pair<size_t, bool>(3, true));
   expected_italic.push_back(std::pair<size_t, bool>(6, false));
   expected_italic.push_back(std::pair<size_t, bool>(7, true));
-  EXPECT_TRUE(render_text->styles()[ITALIC].EqualsForTesting(expected_italic));
+  EXPECT_TRUE(test_api()->styles()[ITALIC].EqualsForTesting(expected_italic));
 
   // Changing the text should clear any breaks except for the first one.
   render_text->SetText(ASCIIToUTF16("0123456"));
   expected_italic.resize(1);
-  EXPECT_TRUE(render_text->styles()[ITALIC].EqualsForTesting(expected_italic));
+  EXPECT_TRUE(test_api()->styles()[ITALIC].EqualsForTesting(expected_italic));
   render_text->ApplyStyle(ITALIC, false, Range(2, 4));
   render_text->SetText(ASCIIToUTF16("012345678"));
-  EXPECT_TRUE(render_text->styles()[ITALIC].EqualsForTesting(expected_italic));
+  EXPECT_TRUE(test_api()->styles()[ITALIC].EqualsForTesting(expected_italic));
   render_text->ApplyStyle(ITALIC, false, Range(0, 1));
   render_text->SetText(ASCIIToUTF16("0123456"));
   expected_italic.begin()->second = false;
-  EXPECT_TRUE(render_text->styles()[ITALIC].EqualsForTesting(expected_italic));
+  EXPECT_TRUE(test_api()->styles()[ITALIC].EqualsForTesting(expected_italic));
   render_text->ApplyStyle(ITALIC, true, Range(2, 4));
   render_text->SetText(ASCIIToUTF16("012345678"));
-  EXPECT_TRUE(render_text->styles()[ITALIC].EqualsForTesting(expected_italic));
+  EXPECT_TRUE(test_api()->styles()[ITALIC].EqualsForTesting(expected_italic));
 
   // TODO(tmoniuszko): Enable when RenderTextMac::IsValidCursorIndex is
   //                   implemented. See http://crbug.com/131618.
   if (GetParam() != RENDER_TEXT_MAC) {
     // Styles shouldn't be changed mid-grapheme.
     render_text->SetText(
         WideToUTF16(L"0"
                     L"\x0915\x093f"
                     L"1"
                     L"\x0915\x093f"
                     L"2"));
     render_text->ApplyStyle(UNDERLINE, true, Range(2, 5));
     std::vector<std::pair<size_t, bool>> expected_underline;
     expected_underline.push_back(std::pair<size_t, bool>(0, false));
     expected_underline.push_back(std::pair<size_t, bool>(1, true));
     expected_underline.push_back(std::pair<size_t, bool>(6, false));
     EXPECT_TRUE(
-        render_text->styles()[UNDERLINE].EqualsForTesting(expected_underline));
+        test_api()->styles()[UNDERLINE].EqualsForTesting(expected_underline));
   }
 }
 
 TEST_P(RenderTextTest, AppendTextKeepsStyles) {
   RenderText* render_text = GetRenderText();
   // Setup basic functionality.
   render_text->SetText(ASCIIToUTF16("abc"));
   render_text->ApplyColor(SK_ColorRED, Range(0, 1));
   render_text->ApplyBaselineStyle(SUPERSCRIPT, Range(1, 2));
   render_text->ApplyStyle(UNDERLINE, true, Range(2, 3));
   // Verify basic functionality.
   std::vector<std::pair<size_t, SkColor>> expected_color;
   expected_color.push_back(std::pair<size_t, SkColor>(0, SK_ColorRED));
   expected_color.push_back(std::pair<size_t, SkColor>(1, SK_ColorBLACK));
-  EXPECT_TRUE(render_text->colors().EqualsForTesting(expected_color));
+  EXPECT_TRUE(test_api()->colors().EqualsForTesting(expected_color));
   std::vector<std::pair<size_t, BaselineStyle>> expected_baseline;
   expected_baseline.push_back(
       std::pair<size_t, BaselineStyle>(0, NORMAL_BASELINE));
   expected_baseline.push_back(std::pair<size_t, BaselineStyle>(1, SUPERSCRIPT));
   expected_baseline.push_back(
       std::pair<size_t, BaselineStyle>(2, NORMAL_BASELINE));
-  EXPECT_TRUE(render_text->baselines().EqualsForTesting(expected_baseline));
+  EXPECT_TRUE(test_api()->baselines().EqualsForTesting(expected_baseline));
   std::vector<std::pair<size_t, bool>> expected_style;
   expected_style.push_back(std::pair<size_t, bool>(0, false));
   expected_style.push_back(std::pair<size_t, bool>(2, true));
-  EXPECT_TRUE(
-      render_text->styles()[UNDERLINE].EqualsForTesting(expected_style));
+  EXPECT_TRUE(test_api()->styles()[UNDERLINE].EqualsForTesting(expected_style));
   // Ensure AppendText maintains current text styles.
   render_text->AppendText(ASCIIToUTF16("def"));
   EXPECT_EQ(render_text->GetDisplayText(), ASCIIToUTF16("abcdef"));
-  EXPECT_TRUE(render_text->colors().EqualsForTesting(expected_color));
-  EXPECT_TRUE(render_text->baselines().EqualsForTesting(expected_baseline));
-  EXPECT_TRUE(
-      render_text->styles()[UNDERLINE].EqualsForTesting(expected_style));
+  EXPECT_TRUE(test_api()->colors().EqualsForTesting(expected_color));
+  EXPECT_TRUE(test_api()->baselines().EqualsForTesting(expected_baseline));
+  EXPECT_TRUE(test_api()->styles()[UNDERLINE].EqualsForTesting(expected_style));
 }
 
 void TestVisualCursorMotionInObscuredField(
     RenderText* render_text,
     const base::string16& text,
     SelectionBehavior selection_behavior) {
   const bool select = selection_behavior != SELECTION_NONE;
   ASSERT_TRUE(render_text->obscured());
   render_text->SetText(text);
   int len = text.length();
@@ skipping 41 matching lines @@
   render_text->SetText(invalid_surrogates);
   EXPECT_EQ(ASCIIToUTF16("**"), render_text->GetDisplayText());
   const base::char16 valid_surrogates[] = {0xD800, 0xDC00, 0};
   render_text->SetText(valid_surrogates);
   EXPECT_EQ(ASCIIToUTF16("*"), render_text->GetDisplayText());
   EXPECT_EQ(0U, render_text->cursor_position());
   render_text->MoveCursor(CHARACTER_BREAK, CURSOR_RIGHT, SELECTION_NONE);
   EXPECT_EQ(2U, render_text->cursor_position());
 
   // Test index conversion and cursor validity with a valid surrogate pair.
-  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_EQ(0U, test_api()->TextIndexToDisplayIndex(0U));
+  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);
   for (int x = -1; x <= 20; ++x) {
     SelectionModel selection = render_text->FindCursorPosition(Point(x, 0));
@@ skipping 1010 matching lines @@
   if (base::win::GetVersion() < base::win::VERSION_VISTA)
     return;
 #endif
 
   RenderText* render_text = GetRenderText();
   for (size_t i = 0; i < arraysize(cases); i++) {
     render_text->SetText(cases[i].text);
     bool ltr = (cases[i].expected_text_direction == base::i18n::LEFT_TO_RIGHT);
 
     SelectionModel start_edge =
-        render_text->EdgeSelectionModel(ltr ? CURSOR_LEFT : CURSOR_RIGHT);
+        test_api()->EdgeSelectionModel(ltr ? CURSOR_LEFT : CURSOR_RIGHT);
     EXPECT_EQ(start_edge, SelectionModel(0, CURSOR_BACKWARD));
 
     SelectionModel end_edge =
-        render_text->EdgeSelectionModel(ltr ? CURSOR_RIGHT : CURSOR_LEFT);
+        test_api()->EdgeSelectionModel(ltr ? CURSOR_RIGHT : CURSOR_LEFT);
     EXPECT_EQ(end_edge, SelectionModel(cases[i].text.length(), CURSOR_FORWARD));
   }
 }
 
 TEST_P(RenderTextTest, SelectAll) {
   const wchar_t* const cases[] =
       { kWeak, kLtr, kLtrRtl, kLtrRtlLtr, kRtl, kRtlLtr, kRtlLtrRtl };
 
   // Ensure that SelectAll respects the |reversed| argument regardless of
   // application locale and text content directionality.
@@ skipping 921 matching lines @@
 
   RenderText* render_text = GetRenderText();
   render_text->SetDisplayRect(Rect(1, 1000));
   render_text->SetMultiline(true);
   render_text->SetWordWrapBehavior(WRAP_LONG_WORDS);
 
   for (size_t i = 0; i < arraysize(kTestStrings); ++i) {
     SCOPED_TRACE(base::StringPrintf("kTestStrings[%" PRIuS "]", i));
     render_text->SetText(WideToUTF16(kTestStrings[i]));
     render_text->Draw(canvas());
-    EXPECT_GT(render_text->lines_.size(), 1U);
+    EXPECT_GT(test_api()->lines().size(), 1U);
   }
 }
 
 // Ensure strings wrap onto multiple lines for a normal available width.
 TEST_P(RenderTextHarfBuzzTest, Multiline_NormalWidth) {
   const struct {
     const wchar_t* const text;
     const Range first_line_char_range;
     const Range second_line_char_range;
     bool is_ltr;
   } kTestStrings[] = {
     { L"abc defg hijkl", Range(0, 9), Range(9, 14), true },
     { L"qwertyzxcvbn", Range(0, 10), Range(10, 12), true },
     { L"\x0627\x0644\x0644\x063A\x0629 "
       L"\x0627\x0644\x0639\x0631\x0628\x064A\x0629",
       Range(0, 6), Range(6, 13), false },
     { L"\x062A\x0641\x0627\x062D \x05EA\x05E4\x05D5\x05D6\x05D9"
       L"\x05DA\x05DB\x05DD", Range(0, 5), Range(5, 13), false }
   };
 
   RenderTextHarfBuzz* render_text = GetRenderTextHarfBuzz();
 
   // Specify the fixed width for characters to suppress the possible variations
   // of linebreak results.
-  render_text->set_glyph_width_for_test(5);
+  SetGlyphWidth(5);
   render_text->SetDisplayRect(Rect(50, 1000));
   render_text->SetMultiline(true);
   render_text->SetWordWrapBehavior(WRAP_LONG_WORDS);
   render_text->SetHorizontalAlignment(ALIGN_TO_HEAD);
 
   for (size_t i = 0; i < arraysize(kTestStrings); ++i) {
     SCOPED_TRACE(base::StringPrintf("kTestStrings[%" PRIuS "]", i));
     render_text->SetText(WideToUTF16(kTestStrings[i].text));
     DrawVisualText();
 
-    ASSERT_EQ(2U, render_text->lines_.size());
-    ASSERT_EQ(1U, render_text->lines_[0].segments.size());
+    ASSERT_EQ(2U, test_api()->lines().size());
+    ASSERT_EQ(1U, test_api()->lines()[0].segments.size());
     EXPECT_EQ(kTestStrings[i].first_line_char_range,
-              render_text->lines_[0].segments[0].char_range);
-    ASSERT_EQ(1U, render_text->lines_[1].segments.size());
+              test_api()->lines()[0].segments[0].char_range);
+    ASSERT_EQ(1U, test_api()->lines()[1].segments.size());
     EXPECT_EQ(kTestStrings[i].second_line_char_range,
-              render_text->lines_[1].segments[0].char_range);
+              test_api()->lines()[1].segments[0].char_range);
 
     std::vector<TestSkiaTextRenderer::TextLog> text_log;
     renderer()->GetTextLogAndReset(&text_log);
     ASSERT_EQ(2U, text_log.size());
     // NOTE: this expectation compares the character length and glyph counts,
     // which isn't always equal. This is okay only because all the test
     // strings are simple (like, no compound characters nor UTF16-surrogate
     // pairs). Be careful in case more complicated test strings are added.
     EXPECT_EQ(kTestStrings[i].first_line_char_range.length(),
               text_log[0].glyph_count);
@@ skipping 17 matching lines @@
                                     L"\x62E\x628\x632", L"\x62E \x628 \x632" };
 
   RenderText* render_text = GetRenderText();
   render_text->SetDisplayRect(Rect(1000, 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]));
     render_text->Draw(canvas());
-    EXPECT_EQ(1U, render_text->lines_.size());
+    EXPECT_EQ(1U, test_api()->lines().size());
   }
 }
 
 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() } },
   };
 
   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());
-    EXPECT_EQ(kTestStrings[i].lines_count, render_text->lines_.size());
-    if (kTestStrings[i].lines_count != render_text->lines_.size())
+    EXPECT_EQ(kTestStrings[i].lines_count, test_api()->lines().size());
+    if (kTestStrings[i].lines_count != test_api()->lines().size())
       continue;
 
     for (size_t j = 0; j < kTestStrings[i].lines_count; ++j) {
       SCOPED_TRACE(base::StringPrintf("Line %" PRIuS "", j));
       // There might be multiple segments in one line. Merge all the segments
       // ranges in the same line.
-      const size_t segment_size = render_text->lines()[j].segments.size();
+      const size_t segment_size = test_api()->lines()[j].segments.size();
       Range line_range;
       if (segment_size > 0)
-        line_range =
-            Range(render_text->lines()[j].segments[0].char_range.start(),
-                  render_text->lines()[j]
-                      .segments[segment_size - 1]
-                      .char_range.end());
+        line_range = Range(
+            test_api()->lines()[j].segments[0].char_range.start(),
+            test_api()->lines()[j].segments[segment_size - 1].char_range.end());
       EXPECT_EQ(kTestStrings[i].line_char_ranges[j], line_range);
     }
   }
 }
 
 // Make sure that multiline mode ignores elide behavior.
 TEST_P(RenderTextHarfBuzzTest, Multiline_IgnoreElide) {
   const wchar_t kTestString[] =
       L"very very very long string xxxxxxxxxxxxxxxxxxxxxxxxxx";
   const wchar_t kEllipsis[] = L"\x2026";
@@ skipping 51 matching lines @@
     // arabic, 2nd line shorter
     { L"\x62a\x62b\x62c\x62d\x62e\x62f\x630\n\x660\x661\x662\x663\x664",
       ALIGN_RIGHT },
     // arabic, 2nd line longer
     { L"\x660\x661\x662\x663\x664\n\x62a\x62b\x62c\x62d\x62e\x62f\x630",
       ALIGN_RIGHT },
   };
   const int kGlyphSize = 5;
   RenderTextHarfBuzz* render_text = GetRenderTextHarfBuzz();
   render_text->SetHorizontalAlignment(ALIGN_TO_HEAD);
-  render_text->set_glyph_width_for_test(kGlyphSize);
+  SetGlyphWidth(kGlyphSize);
   render_text->SetDisplayRect(Rect(100, 1000));
   render_text->SetMultiline(true);
 
   for (size_t i = 0; i < arraysize(kTestStrings); ++i) {
     SCOPED_TRACE(base::StringPrintf("kTestStrings[%" PRIuS "] %ls", i,
                                     kTestStrings[i].text));
     render_text->SetText(WideToUTF16(kTestStrings[i].text));
     render_text->Draw(canvas());
-    ASSERT_LE(2u, render_text->lines().size());
+    ASSERT_LE(2u, test_api()->lines().size());
     if (kTestStrings[i].alignment == ALIGN_LEFT) {
-      EXPECT_EQ(0, render_text->GetAlignmentOffset(0).x());
-      EXPECT_EQ(0, render_text->GetAlignmentOffset(1).x());
+      EXPECT_EQ(0, test_api()->GetAlignmentOffset(0).x());
+      EXPECT_EQ(0, test_api()->GetAlignmentOffset(1).x());
     } else {
       std::vector<base::string16> lines = base::SplitString(
           base::WideToUTF16(kTestStrings[i].text),
           base::string16(1, '\n'), base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL);
       ASSERT_EQ(2u, lines.size());
       int difference = (lines[0].length() - lines[1].length()) * kGlyphSize;
-      EXPECT_EQ(render_text->GetAlignmentOffset(0).x() + difference,
-                render_text->GetAlignmentOffset(1).x());
+      EXPECT_EQ(test_api()->GetAlignmentOffset(0).x() + difference,
+                test_api()->GetAlignmentOffset(1).x());
     }
   }
 }
 
 TEST_P(RenderTextHarfBuzzTest, Multiline_WordWrapBehavior) {
   const int kGlyphSize = 5;
   const struct {
     const WordWrapBehavior behavior;
     const size_t num_lines;
     const Range char_ranges[4];
   } kTestScenarios[] = {
     { IGNORE_LONG_WORDS, 3u,
       { Range(0, 4), Range(4, 11), Range(11, 14), Range::InvalidRange() } },
     { TRUNCATE_LONG_WORDS, 3u,
       { Range(0, 4), Range(4, 8), Range(11, 14), Range::InvalidRange() } },
     { WRAP_LONG_WORDS, 4u,
       { Range(0, 4), Range(4, 8), Range(8, 11), Range(11, 14) } },
     // TODO(mukai): implement ELIDE_LONG_WORDS. It's not used right now.
   };
   RenderTextHarfBuzz* render_text = GetRenderTextHarfBuzz();
   render_text->SetMultiline(true);
   render_text->SetText(ASCIIToUTF16("foo fooooo foo"));
-  render_text->set_glyph_width_for_test(kGlyphSize);
+  SetGlyphWidth(kGlyphSize);
   render_text->SetDisplayRect(Rect(0, 0, kGlyphSize * 4, 0));
 
   for (size_t i = 0; i < arraysize(kTestScenarios); ++i) {
     SCOPED_TRACE(base::StringPrintf(
         "kTestScenarios[%" PRIuS "] %d", i, kTestScenarios[i].behavior));
     render_text->SetWordWrapBehavior(kTestScenarios[i].behavior);
     render_text->Draw(canvas());
 
-    ASSERT_EQ(kTestScenarios[i].num_lines, render_text->lines().size());
-    for (size_t j = 0; j < render_text->lines().size(); ++j) {
+    ASSERT_EQ(kTestScenarios[i].num_lines, test_api()->lines().size());
+    for (size_t j = 0; j < test_api()->lines().size(); ++j) {
       SCOPED_TRACE(base::StringPrintf("%" PRIuS "-th line", j));
       EXPECT_EQ(kTestScenarios[i].char_ranges[j],
-                render_text->lines()[j].segments[0].char_range);
+                test_api()->lines()[j].segments[0].char_range);
       EXPECT_EQ(kTestScenarios[i].char_ranges[j].length() * kGlyphSize,
-                render_text->lines()[j].size.width());
+                test_api()->lines()[j].size.width());
     }
   }
 }
 
 TEST_P(RenderTextHarfBuzzTest, Multiline_LineBreakerBehavior) {
   const int kGlyphSize = 5;
   const struct {
     const wchar_t* const text;
     const WordWrapBehavior behavior;
     const Range char_ranges[3];
@@ skipping 21 matching lines @@
       { L"asingleword", WRAP_LONG_WORDS,
         {Range(0, 4), Range(4, 8), Range(8, 11) } },
       { L"That's good", WRAP_LONG_WORDS,
         {Range(0, 4), Range(4, 7), Range(7, 11) } },
       { L"That's \"g\".", WRAP_LONG_WORDS,
         {Range(0, 4), Range(4, 7), Range(7, 11) } },
   };
 
   RenderTextHarfBuzz* render_text = GetRenderTextHarfBuzz();
   render_text->SetMultiline(true);
-  render_text->set_glyph_width_for_test(kGlyphSize);
+  SetGlyphWidth(kGlyphSize);
   render_text->SetDisplayRect(Rect(0, 0, kGlyphSize * 4, 0));
 
   for (size_t i = 0; i < arraysize(kTestScenarios); ++i) {
     SCOPED_TRACE(base::StringPrintf("kTestStrings[%" PRIuS "]", i));
     render_text->SetText(WideToUTF16(kTestScenarios[i].text));
     render_text->SetWordWrapBehavior(kTestScenarios[i].behavior);
     render_text->Draw(canvas());
 
-    ASSERT_EQ(3u, render_text->lines().size());
-    for (size_t j = 0; j < render_text->lines().size(); ++j) {
+    ASSERT_EQ(3u, test_api()->lines().size());
+    for (size_t j = 0; j < test_api()->lines().size(); ++j) {
       SCOPED_TRACE(base::StringPrintf("%" PRIuS "-th line", j));
       // Merge all the segments ranges in the same line.
-      size_t segment_size = render_text->lines()[j].segments.size();
+      size_t segment_size = test_api()->lines()[j].segments.size();
       Range line_range;
       if (segment_size > 0)
-        line_range =
-            Range(render_text->lines()[j].segments[0].char_range.start(),
-                  render_text->lines()[j]
-                      .segments[segment_size - 1]
-                      .char_range.end());
+        line_range = Range(
+            test_api()->lines()[j].segments[0].char_range.start(),
+            test_api()->lines()[j].segments[segment_size - 1].char_range.end());
       EXPECT_EQ(kTestScenarios[i].char_ranges[j], line_range);
       EXPECT_EQ(kTestScenarios[i].char_ranges[j].length() * kGlyphSize,
-                render_text->lines()[j].size.width());
+                test_api()->lines()[j].size.width());
     }
   }
 }
 
 // Test that Surrogate pairs or combining character sequences do not get
 // separated by line breaking.
 TEST_P(RenderTextHarfBuzzTest, Multiline_SurrogatePairsOrCombiningChars) {
   RenderTextHarfBuzz* render_text = GetRenderTextHarfBuzz();
   render_text->SetMultiline(true);
   render_text->SetWordWrapBehavior(WRAP_LONG_WORDS);
@@ skipping 24 matching lines @@
         std::min(kSurrogateWidth, kCombiningCharsWidth) / 2,
         { Range(0, 2), Range(2, 3), Range(3, 5) } },
   };
 
   for (size_t i = 0; i < arraysize(kTestScenarios); ++i) {
     SCOPED_TRACE(base::StringPrintf("kTestStrings[%" PRIuS "]", i));
     render_text->SetText(kTestScenarios[i].text);
     render_text->SetDisplayRect(Rect(0, 0, kTestScenarios[i].display_width, 0));
     render_text->Draw(canvas());
 
-    ASSERT_EQ(3u, render_text->lines().size());
-    for (size_t j = 0; j < render_text->lines().size(); ++j) {
+    ASSERT_EQ(3u, test_api()->lines().size());
+    for (size_t j = 0; j < test_api()->lines().size(); ++j) {
       SCOPED_TRACE(base::StringPrintf("%" PRIuS "-th line", j));
       // There is only one segment in each line.
       EXPECT_EQ(kTestScenarios[i].char_ranges[j],
-                render_text->lines()[j].segments[0].char_range);
+                test_api()->lines()[j].segments[0].char_range);
     }
   }
 }
 
 // Test that Zero width characters have the correct line breaking behavior.
 TEST_P(RenderTextHarfBuzzTest, Multiline_ZeroWidthChars) {
   RenderTextHarfBuzz* render_text = GetRenderTextHarfBuzz();
   render_text->SetMultiline(true);
   render_text->SetWordWrapBehavior(WRAP_LONG_WORDS);
 
   const base::char16 kZeroWidthSpace = {0x200B};
   const base::string16 text(UTF8ToUTF16("test") + kZeroWidthSpace +
                             UTF8ToUTF16("\n") + kZeroWidthSpace +
                             UTF8ToUTF16("test."));
   const int kTestWidth =
       GetStringWidth(UTF8ToUTF16("test"), render_text->font_list());
   const Range char_ranges[3] = {Range(0, 5), Range(6, 11), Range(11, 12)};
 
   render_text->SetText(text);
   render_text->SetDisplayRect(Rect(0, 0, kTestWidth, 0));
   render_text->Draw(canvas());
 
-  ASSERT_EQ(3u, render_text->lines().size());
-  for (size_t j = 0; j < render_text->lines().size(); ++j) {
+  ASSERT_EQ(3u, test_api()->lines().size());
+  for (size_t j = 0; j < test_api()->lines().size(); ++j) {
     SCOPED_TRACE(base::StringPrintf("%" PRIuS "-th line", j));
-    int segment_size = render_text->lines()[j].segments.size();
+    int segment_size = test_api()->lines()[j].segments.size();
     ASSERT_GT(segment_size, 0);
     Range line_range(
-        render_text->lines()[j].segments[0].char_range.start(),
-        render_text->lines()[j].segments[segment_size - 1].char_range.end());
+        test_api()->lines()[j].segments[0].char_range.start(),
+        test_api()->lines()[j].segments[segment_size - 1].char_range.end());
     EXPECT_EQ(char_ranges[j], line_range);
   }
 }
 
 TEST_P(RenderTextHarfBuzzTest, NewlineWithoutMultilineFlag) {
   const wchar_t* kTestStrings[] = {
     L"abc\ndef", L"a \n b ", L"ab\n", L"a\n\nb", L"\nab", L"\n",
   };
 
   RenderText* render_text = GetRenderText();
   render_text->SetDisplayRect(Rect(200, 1000));
 
   for (size_t i = 0; i < arraysize(kTestStrings); ++i) {
     SCOPED_TRACE(base::StringPrintf("kTestStrings[%" PRIuS "]", i));
     render_text->SetText(WideToUTF16(kTestStrings[i]));
     render_text->Draw(canvas());
 
-    EXPECT_EQ(1U, render_text->lines_.size());
+    EXPECT_EQ(1U, test_api()->lines().size());
   }
 }
 
 // Make sure the horizontal positions of runs in a line (left-to-right for
 // LTR languages and right-to-left for RTL languages).
 TEST_P(RenderTextHarfBuzzTest, HarfBuzz_HorizontalPositions) {
   const struct {
     const wchar_t* const text;
     const Range first_run_char_range;
     const Range second_run_char_range;
     bool is_rtl;
   } kTestStrings[] = {
     { L"abc\x3042\x3044\x3046\x3048\x304A", Range(0, 3), Range(3, 8), false },
     { L"\x062A\x0641\x0627\x062D"
       L"\x05EA\x05E4\x05D5\x05D6\x05D9\x05DA\x05DB\x05DD",
       Range(0, 4), Range(4, 12), true },
   };
 
   RenderTextHarfBuzz* render_text = GetRenderTextHarfBuzz();
 
   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->EnsureLayout();
-    const internal::TextRunList* run_list = render_text->GetRunList();
+    test_api()->EnsureLayout();
+    const internal::TextRunList* run_list = GetHarfBuzzRunList();
     ASSERT_EQ(2U, run_list->runs().size());
     EXPECT_EQ(kTestStrings[i].first_run_char_range, run_list->runs()[0]->range);
     EXPECT_EQ(kTestStrings[i].second_run_char_range,
               run_list->runs()[1]->range);
     // If it's RTL, the visual order is reversed.
     if (kTestStrings[i].is_rtl) {
       EXPECT_EQ(1U, run_list->logical_to_visual(0));
       EXPECT_EQ(0U, run_list->logical_to_visual(1));
     } else {
       EXPECT_EQ(0U, run_list->logical_to_visual(0));
       EXPECT_EQ(1U, run_list->logical_to_visual(1));
     }
 
-    render_text->DrawVisualText(renderer());
+    DrawVisualText();
 
     std::vector<TestSkiaTextRenderer::TextLog> text_log;
     renderer()->GetTextLogAndReset(&text_log);
 
     EXPECT_EQ(2U, text_log.size());
 
     // Verifies the DrawText happens in the visual order and left-to-right.
     // If the text is RTL, the logically first run should be drawn at last.
     EXPECT_EQ(run_list->runs()[run_list->logical_to_visual(0)]->glyph_count,
               text_log[0].glyph_count);
@@ skipping 71 matching lines @@
     L"\x0e08\x0e33\x0E50",
   };
 
   RenderTextHarfBuzz* render_text = GetRenderTextHarfBuzz();
 
   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();
-    internal::TextRunList* run_list = render_text->GetRunList();
+    test_api()->EnsureLayout();
+    internal::TextRunList* run_list = GetHarfBuzzRunList();
     ASSERT_EQ(1U, run_list->size());
     internal::TextRunHarfBuzz* run = run_list->runs()[0];
 
-    base::i18n::BreakIterator* iter = render_text->grapheme_iterator_.get();
+    base::i18n::BreakIterator* iter = GetGraphemeIterator();
     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.end(), second_grapheme_bounds.start());
   }
 }
 
 // Test the partition of a multi-grapheme cluster into grapheme ranges.
 TEST_P(RenderTextHarfBuzzTest, HarfBuzz_SubglyphGraphemePartition) {
   struct {
@@ skipping 54 matching lines @@
   RenderTextHarfBuzz* render_text = GetRenderTextHarfBuzz();
   const base::string16 mixed = WideToUTF16(
       L"\x05D0\x05D1"
       L"1234"
       L"\x05D2\x05D3"
       L"abc");
   render_text->SetText(mixed);
 
   // Get the run list for both display directions.
   render_text->SetDirectionalityMode(DIRECTIONALITY_FORCE_LTR);
-  render_text->EnsureLayout();
-  internal::TextRunList* run_list = render_text->GetRunList();
+  test_api()->EnsureLayout();
+  internal::TextRunList* run_list = GetHarfBuzzRunList();
   ASSERT_EQ(4U, 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);
   EXPECT_FALSE(run_list->runs()[3]->is_rtl);
 
   // The Latin letters should appear to the right of the other runs.
   EXPECT_EQ(2U, run_list->logical_to_visual(0));
   EXPECT_EQ(1U, run_list->logical_to_visual(1));
   EXPECT_EQ(0U, run_list->logical_to_visual(2));
   EXPECT_EQ(3U, run_list->logical_to_visual(3));
 
   render_text->SetDirectionalityMode(DIRECTIONALITY_FORCE_RTL);
-  render_text->EnsureLayout();
-  run_list = render_text->GetRunList();
+  test_api()->EnsureLayout();
+  run_list = GetHarfBuzzRunList();
   ASSERT_EQ(4U, 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);
   EXPECT_FALSE(run_list->runs()[3]->is_rtl);
 
   // The Latin letters should appear to the left of the other runs.
   EXPECT_EQ(3U, run_list->logical_to_visual(0));
   EXPECT_EQ(2U, run_list->logical_to_visual(1));
   EXPECT_EQ(1U, run_list->logical_to_visual(2));
   EXPECT_EQ(0U, run_list->logical_to_visual(3));
 }
 
 TEST_P(RenderTextHarfBuzzTest, HarfBuzz_BreakRunsByUnicodeBlocks) {
   RenderTextHarfBuzz* render_text = GetRenderTextHarfBuzz();
 
   // The '\x25B6' "play character" should break runs. http://crbug.com/278913
   render_text->SetText(WideToUTF16(L"x\x25B6y"));
-  render_text->EnsureLayout();
-  internal::TextRunList* run_list = render_text->GetRunList();
+  test_api()->EnsureLayout();
+  internal::TextRunList* run_list = GetHarfBuzzRunList();
   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();
-  run_list = render_text->GetRunList();
+  test_api()->EnsureLayout();
+  run_list = GetHarfBuzzRunList();
   ASSERT_EQ(4U, 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, 4), run_list->runs()[2]->range);
   EXPECT_EQ(Range(4, 5), run_list->runs()[3]->range);
 }
 
 TEST_P(RenderTextHarfBuzzTest, HarfBuzz_BreakRunsByEmoji) {
   RenderTextHarfBuzz* render_text = GetRenderTextHarfBuzz();
 
   // \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();
-  internal::TextRunList* run_list = render_text->GetRunList();
+  test_api()->EnsureLayout();
+  internal::TextRunList* run_list = GetHarfBuzzRunList();
   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), 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_P(RenderTextHarfBuzzTest, HarfBuzz_BreakRunsByAscii) {
   RenderTextHarfBuzz* render_text = GetRenderTextHarfBuzz();
 
   // \xF0\x9F\x90\xB1 (U+1F431) is a cat face. It should be put into a separate
   // run from the ASCII period character.
   render_text->SetText(UTF8ToUTF16("\xF0\x9F\x90\xB1."));
-  render_text->EnsureLayout();
-  internal::TextRunList* run_list = render_text->GetRunList();
+  test_api()->EnsureLayout();
+  internal::TextRunList* run_list = GetHarfBuzzRunList();
   ASSERT_EQ(2U, run_list->size());
   // U+1F431 is represented as a surrogate pair in UTF16.
   EXPECT_EQ(Range(0, 2), run_list->runs()[0]->range);
   EXPECT_EQ(Range(2, 3), run_list->runs()[1]->range);
 }
 
 TEST_P(RenderTextHarfBuzzTest, GlyphBounds) {
   const wchar_t* kTestStrings[] = {
       L"asdf 1234 qwer", L"\x0647\x0654", L"\x0645\x0631\x062D\x0628\x0627"
   };
   RenderText* render_text = GetRenderText();
 
   for (size_t i = 0; i < arraysize(kTestStrings); ++i) {
     render_text->SetText(WideToUTF16(kTestStrings[i]));
-    render_text->EnsureLayout();
+    test_api()->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_P(RenderTextHarfBuzzTest, HarfBuzz_NonExistentFont) {
   RenderTextHarfBuzz* render_text = GetRenderTextHarfBuzz();
   render_text->SetText(ASCIIToUTF16("test"));
-  render_text->EnsureLayout();
-  internal::TextRunList* run_list = render_text->GetRunList();
+  test_api()->EnsureLayout();
+  internal::TextRunList* run_list = GetHarfBuzzRunList();
   ASSERT_EQ(1U, run_list->size());
   internal::TextRunHarfBuzz* run = run_list->runs()[0];
-  render_text->ShapeRunWithFont(render_text->text(),
-                                Font("TheFontThatDoesntExist", 13),
-                                FontRenderParams(), run);
+  ShapeRunWithFont(render_text->text(), Font("TheFontThatDoesntExist", 13),
+                   FontRenderParams(), run);
 }
 
 // Ensure an empty run returns sane values to queries.
 TEST_P(RenderTextHarfBuzzTest, HarfBuzz_EmptyRun) {
   internal::TextRunHarfBuzz run((Font()));
   const base::string16 kString = ASCIIToUTF16("abcdefgh");
   std::unique_ptr<base::i18n::BreakIterator> iter(new base::i18n::BreakIterator(
       kString, base::i18n::BreakIterator::BREAK_CHARACTER));
   ASSERT_TRUE(iter->Init());
 
@@ skipping 72 matching lines @@
   RenderTextHarfBuzz* render_text = GetRenderTextHarfBuzz();
   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();
-  internal::TextRunList* run_list = render_text->GetRunList();
+  test_api()->EnsureLayout();
+  internal::TextRunList* run_list = GetHarfBuzzRunList();
   ASSERT_EQ(1U, run_list->size());
   EXPECT_EQ(0U, run_list->runs()[0]->CountMissingGlyphs());
 }
 #endif  // defined(OS_WIN)
 
 // Ensure that the fallback fonts offered by GetFallbackFonts() are
 // tried. Note this test assumes the font "Arial" doesn't provide a unicode
 // glyph for a particular character, and that there exists a system fallback
 // font which does.
 // TODO(msw): Fallback doesn't find a glyph on Linux.
 #if !defined(OS_LINUX)
 TEST_P(RenderTextHarfBuzzTest, HarfBuzz_UnicodeFallback) {
   RenderTextHarfBuzz* render_text = GetRenderTextHarfBuzz();
   render_text->SetFontList(FontList("Arial, 12px"));
 
   // Korean character "han".
   render_text->SetText(WideToUTF16(L"\xd55c"));
-  render_text->EnsureLayout();
-  internal::TextRunList* run_list = render_text->GetRunList();
+  test_api()->EnsureLayout();
+  internal::TextRunList* run_list = GetHarfBuzzRunList();
   ASSERT_EQ(1U, run_list->size());
   EXPECT_EQ(0U, run_list->runs()[0]->CountMissingGlyphs());
 }
 #endif  // !defined(OS_LINUX)
 
 // http://crbug/624513
 #if !defined(OS_WIN)
 // Ensure that the width reported by RenderText is sufficient for drawing. Draws
 // to a canvas and checks if any pixel beyond the bounding rectangle is colored.
 TEST_P(RenderTextTest, TextDoesntClip) {
@@ skipping 160 matching lines @@
   }
 }
 
 #if defined(OS_MACOSX)
 TEST_P(RenderTextMacTest, Mac_ElidedText) {
   RenderTextMac* render_text = GetRenderTextMac();
   base::string16 text(ASCIIToUTF16("This is an example."));
   render_text->SetText(text);
   Size string_size = render_text->GetStringSize();
   render_text->SetDisplayRect(Rect(string_size));
-  render_text->EnsureLayout();
+  test_api()->EnsureLayout();
   // NOTE: Character and glyph counts are only comparable for simple text.
   EXPECT_EQ(text.size(),
-            static_cast<size_t>(CTLineGetGlyphCount(render_text->line_)));
+            static_cast<size_t>(CTLineGetGlyphCount(GetCoreTextLine())));
 
   render_text->SetElideBehavior(ELIDE_TAIL);
   string_size.set_width(string_size.width() / 2);
   render_text->SetDisplayRect(Rect(string_size));
-  render_text->EnsureLayout();
-  CFIndex glyph_count = CTLineGetGlyphCount(render_text->line_);
+  test_api()->EnsureLayout();
+  CFIndex glyph_count = CTLineGetGlyphCount(GetCoreTextLine());
   EXPECT_GT(text.size(), static_cast<size_t>(glyph_count));
   EXPECT_NE(0, glyph_count);
 }
 #endif  // defined(OS_MACOSX)
 
 // Ensure color changes are picked up by the RenderText implementation.
 TEST_P(RenderTextTest, ColorChange) {
   RenderText* render_text = GetRenderText();
   render_text->SetText(ASCIIToUTF16("x"));
   DrawVisualText();
@@ skipping 87 matching lines @@
                         ::testing::Values(RENDER_TEXT_HARFBUZZ),
                         PrintRenderTextBackend());
 #endif
 
 INSTANTIATE_TEST_CASE_P(,
                         RenderTextHarfBuzzTest,
                         ::testing::Values(RENDER_TEXT_HARFBUZZ),
                         PrintRenderTextBackend());
 
 }  // namespace gfx