Optimize some code in RenderTextHarfbuzz.

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 405 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);
   }
 
-  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() {}
 
@@ skipping 2771 matching lines @@
   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);
     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 = 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);
+    auto first_grapheme_bounds = run->GetGraphemeBounds(render_text, 0);
+    EXPECT_EQ(first_grapheme_bounds, run->GetGraphemeBounds(render_text, 1));
+    auto second_grapheme_bounds = run->GetGraphemeBounds(render_text, 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 {
     uint32_t glyph_to_char[2];
     Range bounds[4];
     bool is_rtl;
@@ skipping 20 matching lines @@
     },
   };
 
   internal::TextRunHarfBuzz run((Font()));
   run.range = Range(0, 4);
   run.glyph_count = 2;
   run.glyph_to_char.resize(2);
   run.positions.reset(new SkPoint[4]);
   run.width = 20;
 
-  const base::string16 kString = ASCIIToUTF16("abcd");
-  std::unique_ptr<base::i18n::BreakIterator> iter(new base::i18n::BreakIterator(
-      kString, base::i18n::BreakIterator::BREAK_CHARACTER));
-  ASSERT_TRUE(iter->Init());
+  RenderTextHarfBuzz* render_text = GetRenderTextHarfBuzz();
+  render_text->SetText(ASCIIToUTF16("abcd"));
 
   for (size_t i = 0; i < arraysize(cases); ++i) {
     std::copy(cases[i].glyph_to_char, cases[i].glyph_to_char + 2,
               run.glyph_to_char.begin());
     run.is_rtl = cases[i].is_rtl;
     for (int j = 0; j < 2; ++j)
       run.positions[j].set(j * 10, 0);
 
     for (size_t j = 0; j < 4; ++j) {
       SCOPED_TRACE(base::StringPrintf("Case %" PRIuS ", char %" PRIuS, i, j));
       EXPECT_EQ(cases[i].bounds[j],
-                run.GetGraphemeBounds(iter.get(), j).Round());
+                run.GetGraphemeBounds(render_text, j).Round());
     }
   }
 }
 
 TEST_P(RenderTextHarfBuzzTest, HarfBuzz_RunDirection) {
   RenderTextHarfBuzz* render_text = GetRenderTextHarfBuzz();
   const base::string16 mixed = WideToUTF16(
       L"\x05D0\x05D1"
       L"1234"
       L"\x05D2\x05D3"
@@ skipping 108 matching lines @@
   internal::TextRunList* run_list = GetHarfBuzzRunList();
   ASSERT_EQ(1U, run_list->size());
   internal::TextRunHarfBuzz* run = run_list->runs()[0];
   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());
+  RenderTextHarfBuzz* render_text = GetRenderTextHarfBuzz();
+  render_text->SetText(ASCIIToUTF16("abcdefgh"));
 
   run.range = Range(3, 8);
   run.glyph_count = 0;
   EXPECT_EQ(Range(0, 0), run.CharRangeToGlyphRange(Range(4, 5)));
-  EXPECT_EQ(Range(0, 0), run.GetGraphemeBounds(iter.get(), 4).Round());
+  EXPECT_EQ(Range(0, 0), run.GetGraphemeBounds(render_text, 4).Round());
   Range chars;
   Range glyphs;
   run.GetClusterAt(4, &chars, &glyphs);
   EXPECT_EQ(Range(3, 8), chars);
   EXPECT_EQ(Range(0, 0), glyphs);
 }
 
 // Ensure the line breaker doesn't compute the word's width bigger than the
 // actual size. See http://crbug.com/470073
 TEST_P(RenderTextHarfBuzzTest, HarfBuzz_WordWidthWithDiacritics) {
@@ skipping 376 matching lines @@
                         ::testing::Values(RENDER_TEXT_HARFBUZZ),
                         PrintRenderTextBackend());
 #endif
 
 INSTANTIATE_TEST_CASE_P(,
                         RenderTextHarfBuzzTest,
                         ::testing::Values(RENDER_TEXT_HARFBUZZ),
                         PrintRenderTextBackend());
 
 }  // namespace gfx