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 367 matching lines @@
   EXPECT_EQ(valid_expect_5_and_6, render_text->GetLayoutText());
 }
 
 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 05:53:37]

nit: display_text

     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->GetLayoutText());
     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"));
 
@@ skipping 902 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 multiple mode ignores elide behavior.

[msw, 2015/02/13 05:53:37]

"multi-line", not "multiple". Ultimately, we want multi-line render text to
support eliding, so I'm not sure this test is worthwhile.

[oshima, 2015/02/13 21:03:12]

Done.

+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.GetLayoutText().find(base::WideToUTF16(kEllipsis)));
+
+  render_text.SetMultiline(true);
+  EXPECT_EQ(base::string16::npos,
+            render_text.GetLayoutText().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 57 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