Prepare to use gfx::RenderText 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 78 matching lines @@
       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(was_rtl, base::i18n::IsRTL());
 }
 
-TEST_F(LabelTest, DirectionalityModeProperty) {
-  Label label;
-  EXPECT_EQ(gfx::DIRECTIONALITY_FROM_UI, label.directionality_mode());
-
-  label.set_directionality_mode(gfx::DIRECTIONALITY_FROM_TEXT);
-  EXPECT_EQ(gfx::DIRECTIONALITY_FROM_TEXT, label.directionality_mode());
-
-  label.set_directionality_mode(gfx::DIRECTIONALITY_FROM_UI);
-  EXPECT_EQ(gfx::DIRECTIONALITY_FROM_UI, label.directionality_mode());
-}
-
 TEST_F(LabelTest, MultiLineProperty) {
   Label label;
-  EXPECT_FALSE(label.is_multi_line());
+  EXPECT_FALSE(label.multi_line());
   label.SetMultiLine(true);
-  EXPECT_TRUE(label.is_multi_line());
+  EXPECT_TRUE(label.multi_line());
   label.SetMultiLine(false);
-  EXPECT_FALSE(label.is_multi_line());
+  EXPECT_FALSE(label.multi_line());
 }
 
 TEST_F(LabelTest, ObscuredProperty) {
   Label label;
   base::string16 test_text(ASCIIToUTF16("Password!"));
   label.SetText(test_text);
 
-  // Should be false by default...
-  EXPECT_FALSE(label.is_obscured());
-  EXPECT_EQ(test_text, label.layout_text());
+  // The text should be unobscured by default.
+  EXPECT_FALSE(label.obscured());
+  EXPECT_EQ(test_text, label.GetLayoutTextForTesting());
   EXPECT_EQ(test_text, label.text());
 
   label.SetObscured(true);
-  EXPECT_TRUE(label.is_obscured());
-  EXPECT_EQ(ASCIIToUTF16("*********"), label.layout_text());
+  EXPECT_TRUE(label.obscured());
+  EXPECT_EQ(ASCIIToUTF16("*********"), label.GetLayoutTextForTesting());
   EXPECT_EQ(test_text, label.text());
 
   label.SetText(test_text + test_text);
-  EXPECT_EQ(ASCIIToUTF16("******************"), label.layout_text());
+  EXPECT_EQ(ASCIIToUTF16("******************"),
+            label.GetLayoutTextForTesting());
   EXPECT_EQ(test_text + test_text, label.text());
 
   label.SetObscured(false);
-  EXPECT_FALSE(label.is_obscured());
-  EXPECT_EQ(test_text + test_text, label.layout_text());
+  EXPECT_FALSE(label.obscured());
+  EXPECT_EQ(test_text + test_text, label.GetLayoutTextForTesting());
   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.layout_text());
+  EXPECT_EQ(ASCIIToUTF16("*"), label.GetLayoutTextForTesting());
   EXPECT_EQ(test_text, label.text());
 }
 
 TEST_F(LabelTest, TooltipProperty) {
   Label label;
   label.SetText(ASCIIToUTF16("My cool string."));
 
   base::string16 tooltip;
   EXPECT_TRUE(label.GetTooltipText(gfx::Point(), &tooltip));
   EXPECT_EQ(label.text(), tooltip);
@@ skipping 13 matching lines @@
   EXPECT_FALSE(label.GetTooltipText(gfx::Point(), &tooltip));
 
   // Verify that setting the tooltip still shows it.
   label.SetTooltipText(tooltip_text);
   EXPECT_TRUE(label.GetTooltipText(gfx::Point(), &tooltip));
   EXPECT_EQ(tooltip_text, tooltip);
   // Clear out the tooltip.
   label.SetTooltipText(base::string16());
 
   // Shrink the bounds and the tooltip should come back.
-  label.SetBounds(0, 0, 1, 1);
+  label.SetBounds(0, 0, 10, 10);
   EXPECT_TRUE(label.GetTooltipText(gfx::Point(), &tooltip));
 
   // Make the label obscured and there is no tooltip.
   label.SetObscured(true);
   EXPECT_FALSE(label.GetTooltipText(gfx::Point(), &tooltip));
 
   // Obscuring the text shouldn't permanently clobber the tooltip.
   label.SetObscured(false);
   EXPECT_TRUE(label.GetTooltipText(gfx::Point(), &tooltip));
 
-  // Make the label multiline and there is no tooltip.
+  // Making the label multiline shouldn't eliminate the tooltip.
   label.SetMultiLine(true);
+  EXPECT_TRUE(label.GetTooltipText(gfx::Point(), &tooltip));
+  // Expanding the multiline label bounds should eliminate the tooltip.
+  label.SetBounds(0, 0, 1000, 1000);
   EXPECT_FALSE(label.GetTooltipText(gfx::Point(), &tooltip));
 
   // Verify that setting the tooltip still shows it.
   label.SetTooltipText(tooltip_text);
   EXPECT_TRUE(label.GetTooltipText(gfx::Point(), &tooltip));
   EXPECT_EQ(tooltip_text, tooltip);
   // Clear out the tooltip.
   label.SetTooltipText(base::string16());
 }
 
 TEST_F(LabelTest, Accessibility) {
   Label label;
   label.SetText(ASCIIToUTF16("My special text."));
 
   ui::AXViewState state;
   label.GetAccessibleState(&state);
   EXPECT_EQ(ui::AX_ROLE_STATIC_TEXT, state.role);
   EXPECT_EQ(label.text(), state.name);
   EXPECT_TRUE(state.HasStateFlag(ui::AX_STATE_READ_ONLY));
 }
 
+TEST_F(LabelTest, EmptyLabelSizing) {
+  Label label;
+  const gfx::Size expected_size(0, gfx::FontList().GetHeight());
+  EXPECT_EQ(expected_size, label.GetPreferredSize());
+  label.SetMultiLine(!label.multi_line());
+  EXPECT_EQ(expected_size, label.GetPreferredSize());
+}
+
 TEST_F(LabelTest, SingleLineSizing) {
   Label label;
   label.SetText(ASCIIToUTF16("A not so random string in one line."));
+  const gfx::Size size = label.GetPreferredSize();
+  EXPECT_GT(size.height(), kMinTextDimension);
+  EXPECT_GT(size.width(), kMinTextDimension);
 
-  // GetPreferredSize
-  gfx::Size required_size = label.GetPreferredSize();
-  EXPECT_GT(required_size.height(), kMinTextDimension);
-  EXPECT_GT(required_size.width(), kMinTextDimension);
+  // Setting a size smaller than preferred should not change the preferred size.
+  label.SetSize(gfx::Size(size.width() / 2, size.height() / 2));
+  EXPECT_EQ(size, label.GetPreferredSize());
 
-  // Test everything with borders.
-  gfx::Insets border(10, 20, 30, 40);
+  const gfx::Insets border(10, 20, 30, 40);
   label.SetBorder(Border::CreateEmptyBorder(
       border.top(), border.left(), border.bottom(), border.right()));
-
-  // 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());
+  const gfx::Size size_with_border = label.GetPreferredSize();
+  EXPECT_EQ(size_with_border.height(), size.height() + border.height());
+  EXPECT_EQ(size_with_border.width(), size.width() + border.width());
 }
 
 TEST_F(LabelTest, MultilineSmallAvailableWidthSizing) {
   Label label;
   label.SetMultiLine(true);
   label.SetAllowCharacterBreak(true);
   label.SetText(ASCIIToUTF16("Too Wide."));
 
   // Check that Label can be laid out at a variety of small sizes,
   // splitting the words into up to one character per line if necessary.
@@ skipping 79 matching lines @@
   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.set_directionality_mode(gfx::DIRECTIONALITY_FROM_TEXT);
   label.SetBounds(0, 0, 1000, 1000);
   base::string16 paint_text;
   gfx::Rect text_bounds;
   int flags = -1;
 
   // Test text starts with RTL character.
   label.SetText(base::WideToUTF16(L"  \x5d0\x5d1\x5d2 abc"));
   label.CalculateDrawStringParams(&paint_text, &text_bounds, &flags);
   EXPECT_EQ(gfx::Canvas::FORCE_RTL_DIRECTIONALITY,
             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"));
   label.CalculateDrawStringParams(&paint_text, &text_bounds, &flags);
   EXPECT_EQ(gfx::Canvas::FORCE_LTR_DIRECTIONALITY,
             flags & (gfx::Canvas::FORCE_RTL_DIRECTIONALITY |
                      gfx::Canvas::FORCE_LTR_DIRECTIONALITY));
 }
 
 TEST_F(LabelTest, DrawSingleLineString) {
   Label label;
   label.SetFocusable(false);
-  // Force a directionality to simplify alignment value testing.
-  label.set_directionality_mode(gfx::DIRECTIONALITY_FORCE_LTR);
 
   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.
   base::string16 paint_text;
   gfx::Rect text_bounds;
@@ skipping 103 matching lines @@
   EXPECT_EQ(gfx::Canvas::TEXT_ALIGN_RIGHT,
             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);
-  // Force a directionality to simplify alignment value testing.
-  label.set_directionality_mode(gfx::DIRECTIONALITY_FORCE_LTR);
   // 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());
@@ skipping 364 matching lines @@
   // 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.set_subpixel_rendering_enabled(false);
+  label.SetSubpixelRenderingEnabled(false);
   EXPECT_EQ(flag, label.ComputeDrawStringFlags() & flag);
-  label.set_subpixel_rendering_enabled(true);
+  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);
 }
 
 // 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
@@ skipping 28 matching lines @@
   EXPECT_FALSE(label.GetTooltipHandlerForPoint(gfx::Point(2, 51)));
   EXPECT_FALSE(label.GetTooltipHandlerForPoint(gfx::Point(-1, 20)));
 
   // 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)));
 }
 
 }  // namespace views