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

ui/views/controls/label_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/views/controls/label.h"
 
 #include "base/i18n/rtl.h"
 #include "base/strings/utf_string_conversions.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "ui/accessibility/ax_view_state.h"
@@ skipping 59 matching lines @@
 
   Label label;
   for (size_t i = 0; i < 2; ++i) {
     // Toggle the application default text direction (to try each direction).
     SetRTL(!base::i18n::IsRTL());
     bool reverse_alignment = base::i18n::IsRTL();
 
     // 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());
     }
   }
 
   EXPECT_EQ(was_rtl, base::i18n::IsRTL());
 }
 
 TEST_F(LabelTest, MultiLineProperty) {
   Label label;
   EXPECT_FALSE(label.multi_line());
   label.SetMultiLine(true);
   EXPECT_TRUE(label.multi_line());
   label.SetMultiLine(false);
   EXPECT_FALSE(label.multi_line());
 }
 
 TEST_F(LabelTest, ObscuredProperty) {
   Label label;
   base::string16 test_text(ASCIIToUTF16("Password!"));
   label.SetText(test_text);
 
   // 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());
 }
 
 TEST_F(LabelTest, ObscuredSurrogatePair) {
   // 'MUSICAL SYMBOL G CLEF': represented in UTF-16 as two characters
   // forming the surrogate pair 0x0001D11E.
   Label label;
   base::string16 test_text = base::UTF8ToUTF16("\xF0\x9D\x84\x9E");
   label.SetText(test_text);
 
   label.SetObscured(true);
-  EXPECT_EQ(ASCIIToUTF16("*"), label.GetLayoutTextForTesting());
+  EXPECT_EQ(ASCIIToUTF16("*"), label.GetDisplayTextForTesting());
   EXPECT_EQ(test_text, label.text());
 }
 
 TEST_F(LabelTest, TooltipProperty) {
   Label label;
   label.SetText(ASCIIToUTF16("My cool string."));
 
   // Initially, label has no bounds, its text does not fit, and therefore its
   // text should be returned as the tooltip text.
   base::string16 tooltip;
@@ skipping 197 matching lines @@
 
   // GetPreferredSize and borders.
   label.SetBounds(0, 0, 0, 0);
   gfx::Size required_size_with_border = label.GetPreferredSize();
   EXPECT_EQ(required_size_with_border.height(),
             required_size.height() + border.height());
   EXPECT_EQ(required_size_with_border.width(),
             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) {
+// 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);
+  label.SetText(text);
+  label.SetMultiLine(true);
 
-  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());
+  gfx::Size required_size = label.GetPreferredSize();
+  EXPECT_GT(required_size.height(), kMinTextDimension);
+  EXPECT_GT(required_size.width(), kMinTextDimension);
 
-  // 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));
+  label.SetElideBehavior(gfx::ELIDE_TAIL);
+  EXPECT_EQ(required_size.ToString(), label.GetPreferredSize().ToString());
+  EXPECT_EQ(text, label.GetDisplayTextForTesting());
 
-  // 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));
+  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());
 
-  // 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));
+  // 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());
 
-  // 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) {
-  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.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);
-}
-
-// 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);
+  // 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.
 TEST_F(LabelTest, GetTooltipHandlerForPoint) {
   // A root view must be defined for this test because the hit-testing
   // behaviour used by GetTooltipHandlerForPoint() is defined by
   // the ViewTargeter installed on the root view.
   Widget widget;
   Widget::InitParams init_params =
       CreateParams(Widget::InitParams::TYPE_POPUP);
@@ skipping 40 matching lines @@
   EXPECT_FALSE(label.GetTooltipHandlerForPoint(gfx::Point(2, 51)));
   EXPECT_FALSE(label.GetTooltipHandlerForPoint(gfx::Point(-1, 20)));
   label.SetHandlesTooltips(true);
 
   // GetTooltipHandlerForPoint works should work in child bounds.
   label.SetBounds(2, 2, 10, 10);
   EXPECT_EQ(&label, label.GetTooltipHandlerForPoint(gfx::Point(1, 5)));
   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