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, ElideBehavior) {
+  Label label;
+  base::string16 text(ASCIIToUTF16("This is example text."));
+  label.SetText(text);
+  EXPECT_EQ(gfx::ELIDE_TAIL, label.elide_behavior());
+  gfx::Size size = label.GetPreferredSize();
+  label.SetBoundsRect(gfx::Rect(size));
+  EXPECT_EQ(text, label.GetDisplayTextForTesting());
+
+  size.set_width(size.width() / 2);
+  label.SetBoundsRect(gfx::Rect(size));
+  EXPECT_GT(text.size(), label.GetDisplayTextForTesting().size());
+
+  label.SetElideBehavior(gfx::NO_ELIDE);
+  EXPECT_EQ(text, label.GetDisplayTextForTesting());
+}
+
 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);
+  label.SizeToPreferredSize();
 
   // 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);
+  label.SizeToPreferredSize();
   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);
+  label.SizeToPreferredSize();
   EXPECT_EQ(ASCIIToUTF16("******************"),
-            label.GetLayoutTextForTesting());
+            label.GetDisplayTextForTesting());
   EXPECT_EQ(test_text + test_text, label.text());
 
   label.SetObscured(false);
+  label.SizeToPreferredSize();
   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.SizeToPreferredSize();
 
   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, 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);
+  label.SetBoundsRect(gfx::Rect(required_size));
 
-  // 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());
 
-  // 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());
 
-  // 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;
-#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;
-#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;
-#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;
-#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;
-#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;
-#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());
 }
 
 // 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)
+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