Cache gfx::RenderText instances in views::Label.

ui/views/controls/label_unittest.cc

Index: ui/views/controls/label_unittest.cc
diff --git a/ui/views/controls/label_unittest.cc b/ui/views/controls/label_unittest.cc
index 56fd144a13abba2cfdadae87ff48ba2575660ce8..4ea921beabcc69e6fc291cc4067db7f8a40e990a 100644
--- a/ui/views/controls/label_unittest.cc
+++ b/ui/views/controls/label_unittest.cc
@@ -77,19 +77,18 @@ TEST_F(LabelTest, AlignmentProperty) {
     // The alignment should be flipped in RTL UI.
     label.SetHorizontalAlignment(gfx::ALIGN_RIGHT);
     EXPECT_EQ(reverse_alignment ? gfx::ALIGN_LEFT : gfx::ALIGN_RIGHT,
-              label.GetHorizontalAlignment());
+              label.horizontal_alignment());
     label.SetHorizontalAlignment(gfx::ALIGN_LEFT);
     EXPECT_EQ(reverse_alignment ? gfx::ALIGN_RIGHT : gfx::ALIGN_LEFT,
-              label.GetHorizontalAlignment());
+              label.horizontal_alignment());
     label.SetHorizontalAlignment(gfx::ALIGN_CENTER);
-    EXPECT_EQ(gfx::ALIGN_CENTER, label.GetHorizontalAlignment());
+    EXPECT_EQ(gfx::ALIGN_CENTER, label.horizontal_alignment());
 
     for (size_t j = 0; j < 2; ++j) {
       label.SetHorizontalAlignment(gfx::ALIGN_TO_HEAD);
       const bool rtl = j == 0;
       label.SetText(rtl ? base::WideToUTF16(L"\x5d0") : ASCIIToUTF16("A"));
-      EXPECT_EQ(rtl ? gfx::ALIGN_RIGHT : gfx::ALIGN_LEFT,
-                label.GetHorizontalAlignment());
+      EXPECT_EQ(gfx::ALIGN_TO_HEAD, label.horizontal_alignment());
     }
   }
 
@@ -112,22 +111,22 @@ TEST_F(LabelTest, ObscuredProperty) {
 
   // The text should be unobscured by default.
   EXPECT_FALSE(label.obscured());
-  EXPECT_EQ(test_text, label.GetLayoutTextForTesting());
+  EXPECT_EQ(test_text, label.GetDisplayTextForTesting());
   EXPECT_EQ(test_text, label.text());
 
   label.SetObscured(true);
   EXPECT_TRUE(label.obscured());
-  EXPECT_EQ(ASCIIToUTF16("*********"), label.GetLayoutTextForTesting());
+  EXPECT_EQ(ASCIIToUTF16("*********"), label.GetDisplayTextForTesting());
   EXPECT_EQ(test_text, label.text());
 
   label.SetText(test_text + test_text);
   EXPECT_EQ(ASCIIToUTF16("******************"),
-            label.GetLayoutTextForTesting());
+            label.GetDisplayTextForTesting());
   EXPECT_EQ(test_text + test_text, label.text());
 
   label.SetObscured(false);
   EXPECT_FALSE(label.obscured());
-  EXPECT_EQ(test_text + test_text, label.GetLayoutTextForTesting());
+  EXPECT_EQ(test_text + test_text, label.GetDisplayTextForTesting());
   EXPECT_EQ(test_text + test_text, label.text());
 }
 
@@ -139,7 +138,7 @@ TEST_F(LabelTest, ObscuredSurrogatePair) {
   label.SetText(test_text);
 
   label.SetObscured(true);
-  EXPECT_EQ(ASCIIToUTF16("*"), label.GetLayoutTextForTesting());
+  EXPECT_EQ(ASCIIToUTF16("*"), label.GetDisplayTextForTesting());
   EXPECT_EQ(test_text, label.text());
 }
 
@@ -357,508 +356,40 @@ TEST_F(LabelTest, MultiLineSizing) {
             required_size.width() + border.width());
 }
 
-TEST_F(LabelTest, DirectionalityFromText) {
-  Label label;
-  label.SetBounds(0, 0, 1000, 1000);
-
-  // Test text starts with RTL character.
-  label.SetText(base::WideToUTF16(L"  \x5d0\x5d1\x5d2 abc"));
-  const Label::DrawStringParams* params = label.CalculateDrawStringParams();
-  EXPECT_EQ(gfx::Canvas::FORCE_RTL_DIRECTIONALITY,
-            params->flags & (gfx::Canvas::FORCE_RTL_DIRECTIONALITY |
-                             gfx::Canvas::FORCE_LTR_DIRECTIONALITY));
-
-  // Test text starts with LTR character.
-  label.SetText(base::WideToUTF16(L"ltr \x5d0\x5d1\x5d2 abc"));
-  params = label.CalculateDrawStringParams();
-  EXPECT_EQ(gfx::Canvas::FORCE_LTR_DIRECTIONALITY,
-            params->flags & (gfx::Canvas::FORCE_RTL_DIRECTIONALITY |
-                             gfx::Canvas::FORCE_LTR_DIRECTIONALITY));
-}
-
-TEST_F(LabelTest, DrawSingleLineString) {
-  Label label;
-  label.SetFocusable(false);
-
-  label.SetText(ASCIIToUTF16("Here's a string with no returns."));
-  gfx::Size required_size(label.GetPreferredSize());
-  gfx::Size extra(22, 8);
-  label.SetBounds(0, 0, required_size.width() + extra.width(),
-                  required_size.height() + extra.height());
-
-  // Do some basic verifications for all three alignments.
-  // Centered text.
-  const Label::DrawStringParams* params = label.CalculateDrawStringParams();
-  EXPECT_EQ(label.text(), params->text);
-  // The text should be centered horizontally and vertically.
-  EXPECT_EQ(extra.width() / 2, params->bounds.x());
-  EXPECT_EQ(0, params->bounds.y());
-  EXPECT_EQ(required_size.width(), params->bounds.width());
-  EXPECT_EQ(label.height(), params->bounds.height());
-  EXPECT_EQ(gfx::Canvas::TEXT_ALIGN_CENTER,
-            params->flags & (gfx::Canvas::TEXT_ALIGN_LEFT |
-                             gfx::Canvas::TEXT_ALIGN_CENTER |
-                             gfx::Canvas::TEXT_ALIGN_RIGHT));
-
-  // Left aligned text.
-  label.SetHorizontalAlignment(gfx::ALIGN_LEFT);
-  label.ResetLayoutCache();
-  params = label.CalculateDrawStringParams();
-  EXPECT_EQ(label.text(), params->text);
-  // The text should be left aligned horizontally and centered vertically.
-  EXPECT_EQ(0, params->bounds.x());
-  EXPECT_EQ(0, params->bounds.y());
-  EXPECT_EQ(required_size.width(), params->bounds.width());
-  EXPECT_EQ(label.height(), params->bounds.height());
-  EXPECT_EQ(gfx::Canvas::TEXT_ALIGN_LEFT,
-            params->flags & (gfx::Canvas::TEXT_ALIGN_LEFT |
-                             gfx::Canvas::TEXT_ALIGN_CENTER |
-                             gfx::Canvas::TEXT_ALIGN_RIGHT));
-
-  // Right aligned text.
-  label.SetHorizontalAlignment(gfx::ALIGN_RIGHT);
-  label.ResetLayoutCache();
-  params = label.CalculateDrawStringParams();
-  EXPECT_EQ(label.text(), params->text);
-  // The text should be right aligned horizontally and centered vertically.
-  EXPECT_EQ(extra.width(), params->bounds.x());
-  EXPECT_EQ(0, params->bounds.y());
-  EXPECT_EQ(required_size.width(), params->bounds.width());
-  EXPECT_EQ(label.height(), params->bounds.height());
-  EXPECT_EQ(gfx::Canvas::TEXT_ALIGN_RIGHT,
-            params->flags & (gfx::Canvas::TEXT_ALIGN_LEFT |
-                             gfx::Canvas::TEXT_ALIGN_CENTER |
-                             gfx::Canvas::TEXT_ALIGN_RIGHT));
-
-  // Test single line drawing with a border.
-  gfx::Insets border(39, 34, 8, 96);
-  label.SetBorder(Border::CreateEmptyBorder(
-      border.top(), border.left(), border.bottom(), border.right()));
-
-  gfx::Size required_size_with_border(label.GetPreferredSize());
-  EXPECT_EQ(required_size.width() + border.width(),
-            required_size_with_border.width());
-  EXPECT_EQ(required_size.height() + border.height(),
-            required_size_with_border.height());
-  label.SetBounds(0, 0, required_size_with_border.width() + extra.width(),
-                  required_size_with_border.height() + extra.height());
-
-  // Centered text with border.
-  label.SetHorizontalAlignment(gfx::ALIGN_CENTER);
-  label.ResetLayoutCache();
-  params = label.CalculateDrawStringParams();
-  EXPECT_EQ(label.text(), params->text);
-  // The text should be centered horizontally and vertically within the border.
-  EXPECT_EQ(border.left() + extra.width() / 2, params->bounds.x());
-  EXPECT_EQ(border.top(), params->bounds.y());
-  EXPECT_EQ(required_size.width(), params->bounds.width());
-  EXPECT_EQ(label.GetContentsBounds().height(), params->bounds.height());
-  EXPECT_EQ(gfx::Canvas::TEXT_ALIGN_CENTER,
-            params->flags & (gfx::Canvas::TEXT_ALIGN_LEFT |
-                             gfx::Canvas::TEXT_ALIGN_CENTER |
-                             gfx::Canvas::TEXT_ALIGN_RIGHT));
-
-  // Left aligned text with border.
-  label.SetHorizontalAlignment(gfx::ALIGN_LEFT);
-  label.ResetLayoutCache();
-  params = label.CalculateDrawStringParams();
-  EXPECT_EQ(label.text(), params->text);
-  // The text should be left aligned horizontally and centered vertically.
-  EXPECT_EQ(border.left(), params->bounds.x());
-  EXPECT_EQ(border.top(), params->bounds.y());
-  EXPECT_EQ(required_size.width(), params->bounds.width());
-  EXPECT_EQ(label.GetContentsBounds().height(), params->bounds.height());
-  EXPECT_EQ(gfx::Canvas::TEXT_ALIGN_LEFT,
-            params->flags & (gfx::Canvas::TEXT_ALIGN_LEFT |
-                             gfx::Canvas::TEXT_ALIGN_CENTER |
-                             gfx::Canvas::TEXT_ALIGN_RIGHT));
-
-  // Right aligned text with border.
-  label.SetHorizontalAlignment(gfx::ALIGN_RIGHT);
-  label.ResetLayoutCache();
-  params = label.CalculateDrawStringParams();
-  EXPECT_EQ(label.text(), params->text);
-  // The text should be right aligned horizontally and centered vertically.
-  EXPECT_EQ(border.left() + extra.width(), params->bounds.x());
-  EXPECT_EQ(border.top(), params->bounds.y());
-  EXPECT_EQ(required_size.width(), params->bounds.width());
-  EXPECT_EQ(label.GetContentsBounds().height(), params->bounds.height());
-  EXPECT_EQ(gfx::Canvas::TEXT_ALIGN_RIGHT,
-            params->flags & (gfx::Canvas::TEXT_ALIGN_LEFT |
-                             gfx::Canvas::TEXT_ALIGN_CENTER |
-                             gfx::Canvas::TEXT_ALIGN_RIGHT));
-}
-
-// Pango needs a max height to elide multiline text; that is not supported here.
-TEST_F(LabelTest, DrawMultiLineString) {
-  Label label;
-  label.SetFocusable(false);
-  // Set a background color to prevent gfx::Canvas::NO_SUBPIXEL_RENDERING flags.
-  label.SetBackgroundColor(SK_ColorWHITE);
-
-  label.SetText(ASCIIToUTF16("Another string\nwith returns\n\n!"));
-  label.SetMultiLine(true);
-  label.SizeToFit(0);
-  gfx::Size extra(50, 10);
-  label.SetBounds(label.x(), label.y(),
-                  label.width() + extra.width(),
-                  label.height() + extra.height());
-
-  // Do some basic verifications for all three alignments.
-  const Label::DrawStringParams* params = label.CalculateDrawStringParams();
-  EXPECT_EQ(label.text(), params->text);
-  EXPECT_EQ(extra.width() / 2, params->bounds.x());
-  EXPECT_EQ(extra.height() / 2, params->bounds.y());
-  EXPECT_GT(params->bounds.width(), kMinTextDimension);
-  EXPECT_GT(params->bounds.height(), kMinTextDimension);
-  int expected_flags = gfx::Canvas::MULTI_LINE |
-                       gfx::Canvas::TEXT_ALIGN_CENTER |
-                       gfx::Canvas::FORCE_LTR_DIRECTIONALITY;
-#if !defined(OS_WIN)
-  expected_flags |= gfx::Canvas::NO_ELLIPSIS;
-#endif
-  EXPECT_EQ(expected_flags, expected_flags);
-  gfx::Rect center_bounds(params->bounds);
-
-  label.SetHorizontalAlignment(gfx::ALIGN_LEFT);
-  label.ResetLayoutCache();
-  params = label.CalculateDrawStringParams();
-  EXPECT_EQ(label.text(), params->text);
-  EXPECT_EQ(0, params->bounds.x());
-  EXPECT_EQ(extra.height() / 2, params->bounds.y());
-  EXPECT_GT(params->bounds.width(), kMinTextDimension);
-  EXPECT_GT(params->bounds.height(), kMinTextDimension);
-  expected_flags = gfx::Canvas::MULTI_LINE |
-                   gfx::Canvas::TEXT_ALIGN_LEFT |
-                   gfx::Canvas::FORCE_LTR_DIRECTIONALITY;
-#if !defined(OS_WIN)
-  expected_flags |= gfx::Canvas::NO_ELLIPSIS;
-#endif
-  EXPECT_EQ(expected_flags, expected_flags);
-
-  label.SetHorizontalAlignment(gfx::ALIGN_RIGHT);
-  label.ResetLayoutCache();
-  params = label.CalculateDrawStringParams();
-  EXPECT_EQ(label.text(), params->text);
-  EXPECT_EQ(extra.width(), params->bounds.x());
-  EXPECT_EQ(extra.height() / 2, params->bounds.y());
-  EXPECT_GT(params->bounds.width(), kMinTextDimension);
-  EXPECT_GT(params->bounds.height(), kMinTextDimension);
-  expected_flags = gfx::Canvas::MULTI_LINE |
-                   gfx::Canvas::TEXT_ALIGN_RIGHT |
-                   gfx::Canvas::FORCE_LTR_DIRECTIONALITY;
-#if !defined(OS_WIN)
-  expected_flags |= gfx::Canvas::NO_ELLIPSIS;
-#endif
-  EXPECT_EQ(expected_flags, expected_flags);
-
-  // Test multiline drawing with a border.
-  gfx::Insets border(19, 92, 23, 2);
-  label.SetBorder(Border::CreateEmptyBorder(
-      border.top(), border.left(), border.bottom(), border.right()));
-  label.SizeToFit(0);
-  label.SetBounds(label.x(), label.y(),
-                  label.width() + extra.width(),
-                  label.height() + extra.height());
-
-  label.SetHorizontalAlignment(gfx::ALIGN_CENTER);
-  label.ResetLayoutCache();
-  params = label.CalculateDrawStringParams();
-  EXPECT_EQ(label.text(), params->text);
-  EXPECT_EQ(border.left() + extra.width() / 2, params->bounds.x());
-  EXPECT_EQ(border.top() + extra.height() / 2, params->bounds.y());
-  EXPECT_EQ(center_bounds.width(), params->bounds.width());
-  EXPECT_EQ(center_bounds.height(), params->bounds.height());
-  expected_flags = gfx::Canvas::MULTI_LINE |
-                   gfx::Canvas::TEXT_ALIGN_CENTER |
-                   gfx::Canvas::FORCE_LTR_DIRECTIONALITY;
-#if !defined(OS_WIN)
-  expected_flags |= gfx::Canvas::NO_ELLIPSIS;
-#endif
-  EXPECT_EQ(expected_flags, expected_flags);
-
-  label.SetHorizontalAlignment(gfx::ALIGN_LEFT);
-  label.ResetLayoutCache();
-  params = label.CalculateDrawStringParams();
-  EXPECT_EQ(label.text(), params->text);
-  EXPECT_EQ(border.left(), params->bounds.x());
-  EXPECT_EQ(border.top() + extra.height() / 2, params->bounds.y());
-  EXPECT_EQ(center_bounds.width(), params->bounds.width());
-  EXPECT_EQ(center_bounds.height(), params->bounds.height());
-  expected_flags = gfx::Canvas::MULTI_LINE |
-                   gfx::Canvas::TEXT_ALIGN_LEFT |
-                   gfx::Canvas::FORCE_LTR_DIRECTIONALITY;
-#if !defined(OS_WIN)
-  expected_flags |= gfx::Canvas::NO_ELLIPSIS;
-#endif
-  EXPECT_EQ(expected_flags, expected_flags);
-
-  label.SetHorizontalAlignment(gfx::ALIGN_RIGHT);
-  label.ResetLayoutCache();
-  params = label.CalculateDrawStringParams();
-  EXPECT_EQ(label.text(), params->text);
-  EXPECT_EQ(extra.width() + border.left(), params->bounds.x());
-  EXPECT_EQ(border.top() + extra.height() / 2, params->bounds.y());
-  EXPECT_EQ(center_bounds.width(), params->bounds.width());
-  EXPECT_EQ(center_bounds.height(), params->bounds.height());
-  expected_flags = gfx::Canvas::MULTI_LINE |
-                   gfx::Canvas::TEXT_ALIGN_RIGHT |
-                   gfx::Canvas::FORCE_LTR_DIRECTIONALITY;
-#if !defined(OS_WIN)
-  expected_flags |= gfx::Canvas::NO_ELLIPSIS;
-#endif
-  EXPECT_EQ(expected_flags, expected_flags);
-}
-
-TEST_F(LabelTest, DrawSingleLineStringInRTL) {
+// Verifies if the combination of text eliding and multiline doesn't cause
+// any side effects of size / layout calculation.
+TEST_F(LabelTest, MultiLineSizingWithElide) {
+  const base::string16 text =
+      ASCIIToUTF16("A random string\nwith multiple lines\nand returns!");
   Label label;
   label.SetFocusable(false);
-
-  std::string locale = l10n_util::GetApplicationLocale("");
-  base::i18n::SetICUDefaultLocale("he");
-
-  label.SetText(ASCIIToUTF16("Here's a string with no returns."));
-  gfx::Size required_size(label.GetPreferredSize());
-  gfx::Size extra(22, 8);
-  label.SetBounds(0, 0, required_size.width() + extra.width(),
-                  required_size.height() + extra.height());
-
-  // Do some basic verifications for all three alignments.
-  // Centered text.
-  const Label::DrawStringParams* params = label.CalculateDrawStringParams();
-  EXPECT_EQ(label.text(), params->text);
-  // The text should be centered horizontally and vertically.
-  EXPECT_EQ(extra.width() / 2, params->bounds.x());
-  EXPECT_EQ(0, params->bounds.y());
-  EXPECT_EQ(required_size.width(), params->bounds.width());
-  EXPECT_EQ(label.height(), params->bounds.height());
-  EXPECT_EQ(gfx::Canvas::TEXT_ALIGN_CENTER,
-            params->flags & (gfx::Canvas::TEXT_ALIGN_LEFT |
-                             gfx::Canvas::TEXT_ALIGN_CENTER |
-                             gfx::Canvas::TEXT_ALIGN_RIGHT));
-
-  // ALIGN_LEFT label.
-  label.SetHorizontalAlignment(gfx::ALIGN_LEFT);
-  label.ResetLayoutCache();
-  params = label.CalculateDrawStringParams();
-  EXPECT_EQ(label.text(), params->text);
-  // The text should be right aligned horizontally and centered vertically.
-  EXPECT_EQ(extra.width(), params->bounds.x());
-  EXPECT_EQ(0, params->bounds.y());
-  EXPECT_EQ(required_size.width(), params->bounds.width());
-  EXPECT_EQ(label.height(), params->bounds.height());
-  EXPECT_EQ(gfx::Canvas::TEXT_ALIGN_RIGHT,
-            params->flags & (gfx::Canvas::TEXT_ALIGN_LEFT |
-                             gfx::Canvas::TEXT_ALIGN_CENTER |
-                             gfx::Canvas::TEXT_ALIGN_RIGHT));
-
-  // ALIGN_RIGHT label.
-  label.SetHorizontalAlignment(gfx::ALIGN_RIGHT);
-  label.ResetLayoutCache();
-  params = label.CalculateDrawStringParams();
-  EXPECT_EQ(label.text(), params->text);
-  // The text should be left aligned horizontally and centered vertically.
-  EXPECT_EQ(0, params->bounds.x());
-  EXPECT_EQ(0, params->bounds.y());
-  EXPECT_EQ(required_size.width(), params->bounds.width());
-  EXPECT_EQ(label.height(), params->bounds.height());
-  EXPECT_EQ(gfx::Canvas::TEXT_ALIGN_LEFT,
-            params->flags & (gfx::Canvas::TEXT_ALIGN_LEFT |
-                             gfx::Canvas::TEXT_ALIGN_CENTER |
-                             gfx::Canvas::TEXT_ALIGN_RIGHT));
-
-
-  // Test single line drawing with a border.
-  gfx::Insets border(39, 34, 8, 96);
-  label.SetBorder(Border::CreateEmptyBorder(
-      border.top(), border.left(), border.bottom(), border.right()));
-
-  gfx::Size required_size_with_border(label.GetPreferredSize());
-  EXPECT_EQ(required_size.width() + border.width(),
-            required_size_with_border.width());
-  EXPECT_EQ(required_size.height() + border.height(),
-            required_size_with_border.height());
-  label.SetBounds(0, 0, required_size_with_border.width() + extra.width(),
-                  required_size_with_border.height() + extra.height());
-
-  // Centered text with border.
-  label.SetHorizontalAlignment(gfx::ALIGN_CENTER);
-  label.ResetLayoutCache();
-  params = label.CalculateDrawStringParams();
-  EXPECT_EQ(label.text(), params->text);
-  // The text should be centered horizontally and vertically within the border.
-  EXPECT_EQ(border.left() + extra.width() / 2, params->bounds.x());
-  EXPECT_EQ(border.top(), params->bounds.y());
-  EXPECT_EQ(required_size.width(), params->bounds.width());
-  EXPECT_EQ(label.GetContentsBounds().height(), params->bounds.height());
-  EXPECT_EQ(gfx::Canvas::TEXT_ALIGN_CENTER,
-            params->flags & (gfx::Canvas::TEXT_ALIGN_LEFT |
-                             gfx::Canvas::TEXT_ALIGN_CENTER |
-                             gfx::Canvas::TEXT_ALIGN_RIGHT));
-
-  // ALIGN_LEFT text with border.
-  label.SetHorizontalAlignment(gfx::ALIGN_LEFT);
-  label.ResetLayoutCache();
-  params = label.CalculateDrawStringParams();
-  EXPECT_EQ(label.text(), params->text);
-  // The text should be right aligned horizontally and centered vertically.
-  EXPECT_EQ(border.left() + extra.width(), params->bounds.x());
-  EXPECT_EQ(border.top(), params->bounds.y());
-  EXPECT_EQ(required_size.width(), params->bounds.width());
-  EXPECT_EQ(label.GetContentsBounds().height(), params->bounds.height());
-  EXPECT_EQ(gfx::Canvas::TEXT_ALIGN_RIGHT,
-            params->flags & (gfx::Canvas::TEXT_ALIGN_LEFT |
-                             gfx::Canvas::TEXT_ALIGN_CENTER |
-                             gfx::Canvas::TEXT_ALIGN_RIGHT));
-
-  // ALIGN_RIGHT text.
-  label.SetHorizontalAlignment(gfx::ALIGN_RIGHT);
-  label.ResetLayoutCache();
-  params = label.CalculateDrawStringParams();
-  EXPECT_EQ(label.text(), params->text);
-  // The text should be left aligned horizontally and centered vertically.
-  EXPECT_EQ(border.left(), params->bounds.x());
-  EXPECT_EQ(border.top(), params->bounds.y());
-  EXPECT_EQ(required_size.width(), params->bounds.width());
-  EXPECT_EQ(label.GetContentsBounds().height(), params->bounds.height());
-  EXPECT_EQ(gfx::Canvas::TEXT_ALIGN_LEFT,
-            params->flags & (gfx::Canvas::TEXT_ALIGN_LEFT |
-                             gfx::Canvas::TEXT_ALIGN_CENTER |
-                             gfx::Canvas::TEXT_ALIGN_RIGHT));
-
-  // Reset locale.
-  base::i18n::SetICUDefaultLocale(locale);
-}
-
-// On Linux the underlying pango routines require a max height in order to
-// ellide multiline text. So until that can be resolved, we set all
-// multiline lables to not ellide in Linux only.
-TEST_F(LabelTest, DrawMultiLineStringInRTL) {
-  Label label;
-  label.SetFocusable(false);
-
-  // Test for RTL.
-  std::string locale = l10n_util::GetApplicationLocale("");
-  base::i18n::SetICUDefaultLocale("he");
-
-  label.SetText(ASCIIToUTF16("Another string\nwith returns\n\n!"));
+  label.SetText(text);
   label.SetMultiLine(true);
-  label.SizeToFit(0);
-  gfx::Size extra(50, 10);
-  label.SetBounds(label.x(), label.y(),
-                  label.width() + extra.width(),
-                  label.height() + extra.height());
-
-  // Do some basic verifications for all three alignments.
-  const Label::DrawStringParams* params = label.CalculateDrawStringParams();
-  EXPECT_EQ(label.text(), params->text);
-  EXPECT_EQ(extra.width() / 2, params->bounds.x());
-  EXPECT_EQ(extra.height() / 2, params->bounds.y());
-  EXPECT_GT(params->bounds.width(), kMinTextDimension);
-  EXPECT_GT(params->bounds.height(), kMinTextDimension);
-  EXPECT_TRUE(gfx::Canvas::MULTI_LINE & params->flags);
-  EXPECT_TRUE(gfx::Canvas::TEXT_ALIGN_CENTER & params->flags);
-#if !defined(OS_WIN)
-  EXPECT_TRUE(gfx::Canvas::NO_ELLIPSIS & params->flags);
-#endif
-  gfx::Rect center_bounds(params->bounds);
-
-  label.SetHorizontalAlignment(gfx::ALIGN_LEFT);
-  label.ResetLayoutCache();
-  params = label.CalculateDrawStringParams();
-  EXPECT_EQ(label.text(), params->text);
-  EXPECT_EQ(extra.width(), params->bounds.x());
-  EXPECT_EQ(extra.height() / 2, params->bounds.y());
-  EXPECT_GT(params->bounds.width(), kMinTextDimension);
-  EXPECT_GT(params->bounds.height(), kMinTextDimension);
-  EXPECT_TRUE(gfx::Canvas::MULTI_LINE & params->flags);
-  EXPECT_TRUE(gfx::Canvas::TEXT_ALIGN_RIGHT & params->flags);
-#if !defined(OS_WIN)
-  EXPECT_TRUE(gfx::Canvas::NO_ELLIPSIS & params->flags);
-#endif
-
-  label.SetHorizontalAlignment(gfx::ALIGN_RIGHT);
-  label.ResetLayoutCache();
-  params = label.CalculateDrawStringParams();
-  EXPECT_EQ(label.text(), params->text);
-  EXPECT_EQ(0, params->bounds.x());
-  EXPECT_EQ(extra.height() / 2, params->bounds.y());
-  EXPECT_GT(params->bounds.width(), kMinTextDimension);
-  EXPECT_GT(params->bounds.height(), kMinTextDimension);
-  EXPECT_TRUE(gfx::Canvas::MULTI_LINE & params->flags);
-  EXPECT_TRUE(gfx::Canvas::TEXT_ALIGN_LEFT & params->flags);
-#if !defined(OS_WIN)
-  EXPECT_TRUE(gfx::Canvas::NO_ELLIPSIS & params->flags);
-#endif
-
-  // Test multiline drawing with a border.
-  gfx::Insets border(19, 92, 23, 2);
-  label.SetBorder(Border::CreateEmptyBorder(
-      border.top(), border.left(), border.bottom(), border.right()));
-  label.SizeToFit(0);
-  label.SetBounds(label.x(), label.y(),
-                  label.width() + extra.width(),
-                  label.height() + extra.height());
-
-  label.SetHorizontalAlignment(gfx::ALIGN_CENTER);
-  label.ResetLayoutCache();
-  params = label.CalculateDrawStringParams();
-  EXPECT_EQ(label.text(), params->text);
-  EXPECT_EQ(border.left() + extra.width() / 2, params->bounds.x());
-  EXPECT_EQ(border.top() + extra.height() / 2, params->bounds.y());
-  EXPECT_EQ(center_bounds.width(), params->bounds.width());
-  EXPECT_EQ(center_bounds.height(), params->bounds.height());
-  EXPECT_TRUE(gfx::Canvas::MULTI_LINE & params->flags);
-  EXPECT_TRUE(gfx::Canvas::TEXT_ALIGN_CENTER & params->flags);
-#if !defined(OS_WIN)
-  EXPECT_TRUE(gfx::Canvas::NO_ELLIPSIS & params->flags);
-#endif
 
-  label.SetHorizontalAlignment(gfx::ALIGN_LEFT);
-  label.ResetLayoutCache();
-  params = label.CalculateDrawStringParams();
-  EXPECT_EQ(label.text(), params->text);
-  EXPECT_EQ(border.left() + extra.width(), params->bounds.x());
-  EXPECT_EQ(border.top() + extra.height() / 2, params->bounds.y());
-  EXPECT_EQ(center_bounds.width(), params->bounds.width());
-  EXPECT_EQ(center_bounds.height(), params->bounds.height());
-  EXPECT_TRUE(gfx::Canvas::MULTI_LINE & params->flags);
-  EXPECT_TRUE(gfx::Canvas::TEXT_ALIGN_RIGHT & params->flags);
-#if !defined(OS_WIN)
-  EXPECT_TRUE(gfx::Canvas::NO_ELLIPSIS & params->flags);
-#endif
-
-  label.SetHorizontalAlignment(gfx::ALIGN_RIGHT);
-  label.ResetLayoutCache();
-  params = label.CalculateDrawStringParams();
-  EXPECT_EQ(label.text(), params->text);
-  EXPECT_EQ(border.left(), params->bounds.x());
-  EXPECT_EQ(border.top() + extra.height() / 2, params->bounds.y());
-  EXPECT_EQ(center_bounds.width(), params->bounds.width());
-  EXPECT_EQ(center_bounds.height(), params->bounds.height());
-  EXPECT_TRUE(gfx::Canvas::MULTI_LINE & params->flags);
-  EXPECT_TRUE(gfx::Canvas::TEXT_ALIGN_LEFT & params->flags);
-#if !defined(OS_WIN)
-  EXPECT_TRUE(gfx::Canvas::NO_ELLIPSIS & params->flags);
-#endif
-
-  // Reset Locale
-  base::i18n::SetICUDefaultLocale(locale);
-}
+  gfx::Size required_size = label.GetPreferredSize();
+  EXPECT_GT(required_size.height(), kMinTextDimension);
+  EXPECT_GT(required_size.width(), kMinTextDimension);
 
-// Ensure the subpixel rendering flag and background color alpha are respected.
-TEST_F(LabelTest, DisableSubpixelRendering) {
-  Label label;
-  label.SetBackgroundColor(SK_ColorWHITE);
-  const int flag = gfx::Canvas::NO_SUBPIXEL_RENDERING;
-  EXPECT_EQ(0, label.ComputeDrawStringFlags() & flag);
-  label.SetSubpixelRenderingEnabled(false);
-  EXPECT_EQ(flag, label.ComputeDrawStringFlags() & flag);
-  label.SetSubpixelRenderingEnabled(true);
-  EXPECT_EQ(0, label.ComputeDrawStringFlags() & flag);
-  // Text cannot be drawn with subpixel rendering on transparent backgrounds.
-  label.SetBackgroundColor(SkColorSetARGB(64, 255, 255, 255));
-  EXPECT_EQ(flag, label.ComputeDrawStringFlags() & flag);
+  label.SetElideBehavior(gfx::ELIDE_TAIL);
+  EXPECT_EQ(required_size.ToString(), label.GetPreferredSize().ToString());
+  EXPECT_EQ(text, label.GetDisplayTextForTesting());
+
+  label.SizeToFit(required_size.width() - 1);
+  gfx::Size narrow_size = label.GetPreferredSize();
+  EXPECT_GT(required_size.width(), narrow_size.width());
+  EXPECT_LT(required_size.height(), narrow_size.height());
+  EXPECT_EQ(text, label.GetDisplayTextForTesting());
+
+  // SetBounds() doesn't change the preferred size.
+  label.SetBounds(0, 0, narrow_size.width() - 1, narrow_size.height());
+  EXPECT_EQ(narrow_size.ToString(), label.GetPreferredSize().ToString());
+  EXPECT_EQ(text, label.GetDisplayTextForTesting());
+
+  // Paint() doesn't change the preferred size.
+  gfx::Canvas canvas;
+  label.Paint(&canvas, CullSet());
+  EXPECT_EQ(narrow_size.ToString(), label.GetPreferredSize().ToString());
+  EXPECT_EQ(text, label.GetDisplayTextForTesting());
 }
 
 // Check that labels support GetTooltipHandlerForPoint.
@@ -919,4 +450,64 @@ TEST_F(LabelTest, GetTooltipHandlerForPoint) {
   EXPECT_FALSE(label.GetTooltipHandlerForPoint(gfx::Point(3, 11)));
 }
 
+// Check that label releases its internal layout data when it's unnecessary.
+TEST_F(LabelTest, ResetRenderTextData) {
+  Label label;
+  label.SetText(ASCIIToUTF16("Example"));
+  label.SizeToPreferredSize();
+  gfx::Size preferred_size = label.GetPreferredSize();
+
+  EXPECT_NE(gfx::Size().ToString(), preferred_size.ToString());
+  EXPECT_EQ(0u, label.lines_.size());
+
+  gfx::Canvas canvas(preferred_size, 1.0f, true);
+  label.Paint(&canvas, CullSet());
+  EXPECT_EQ(1u, label.lines_.size());
+
+  // Label should recreate its RenderText object when it's invisible, to release
+  // the layout structures and data.
+  label.SetVisible(false);
+  EXPECT_EQ(0u, label.lines_.size());
+
+  // Querying fields or size information should not recompute the layout
+  // unnecessarily.
+  EXPECT_EQ(ASCIIToUTF16("Example"), label.text());
+  EXPECT_EQ(0u, label.lines_.size());
+
+  EXPECT_EQ(preferred_size.ToString(), label.GetPreferredSize().ToString());
+  EXPECT_EQ(0u, label.lines_.size());
+
+  // RenderText data should be back when it's necessary.
+  label.SetVisible(true);
+  EXPECT_EQ(0u, label.lines_.size());
+
+  label.Paint(&canvas, CullSet());
+  EXPECT_EQ(1u, label.lines_.size());
+
+  // Changing layout just resets |lines_|. It'll recover next time it's drawn.
+  label.SetBounds(0, 0, 10, 10);
+  EXPECT_EQ(0u, label.lines_.size());
+
+  label.Paint(&canvas, CullSet());
+  EXPECT_EQ(1u, label.lines_.size());
+}
+
+#if !defined(OS_MACOSX)

[tapted, 2015/02/27 01:21:00]

Note that since SetMultiline now calls render_text_->SetMultiline(multi_line);
without waiting for a paint, there are more test failures on Mac:

6 tests crashed:
    LabelTest.EmptyLabelSizing
    LabelTest.MultiLineProperty
    LabelTest.MultiLineSizing
    LabelTest.MultiLineSizingWithElide
    LabelTest.MultilineSmallAvailableWidthSizing
    LabelTest.TooltipProperty

these all die at
[FATAL:render_text_mac.cc(115)] Check failed: !multiline(). RenderTextMac does
not support multi line
gfx::RenderTextMac::OnLayoutTextAttributeChanged(bool) + 266
gfx::RenderText::OnTextAttributeChanged() + 2424
gfx::RenderText::SetMultiline(bool) + 115
views::Label::SetMultiLine(bool) + 376

I think this is the right way to die (e.g. as opposed to Label::SetMultiLine()
checking render_text_->MultilineSupported()), so (unless there are other
opinions) I don't think anything needs to change except the tests.

I'm happy to do this in a follow-up.

Probably we want EmptyLabelSizing and TooltipProperty enabled, but doing
something that makes sense on Mac, and the MultiLine tests just disabled until
we know where that's needed on Mac and how best to fix it.

[Jun Mukai, 2015/02/27 02:06:47]

Thanks for the followup.  I haven't noticed oshima has added a DCHECK for
multiline() in RenderTextMac().

Then, for now, I think it's better to revive two flags -- multi_line_ in
views::Label and replace_newline_chars_ in RenderText.

+TEST_F(LabelTest, MultilineSupportedRenderText) {
+  scoped_ptr<gfx::RenderText> render_text(gfx::RenderText::CreateInstance());
+  ASSERT_TRUE(render_text->MultilineSupported());
+
+  Label label;
+  label.SetText(ASCIIToUTF16("Example of\nmultilined label"));
+  label.SetMultiLine(true);
+  label.SizeToPreferredSize();
+
+  gfx::Canvas canvas(label.GetPreferredSize(), 1.0f, true);
+  label.Paint(&canvas, CullSet());
+
+  // There's only one 'line', RenderText itself supports multiple lines.
+  EXPECT_EQ(1u, label.lines_.size());
+}
+#endif
+
 }  // namespace views