Add fade eliding for Views Labels; related cleanup.

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 119 matching lines @@
   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(test_text, label.text());
 }
 
 TEST(LabelTest, TooltipProperty) {
   Label label;
-  base::string16 test_text(ASCIIToUTF16("My cool string."));
-  label.SetText(test_text);
+  label.SetText(ASCIIToUTF16("My cool string."));
 
   base::string16 tooltip;
   EXPECT_TRUE(label.GetTooltipText(gfx::Point(), &tooltip));
-  EXPECT_EQ(test_text, tooltip);
+  EXPECT_EQ(label.text(), tooltip);
 
   base::string16 tooltip_text(ASCIIToUTF16("The tooltip!"));
   label.SetTooltipText(tooltip_text);
   EXPECT_TRUE(label.GetTooltipText(gfx::Point(), &tooltip));
   EXPECT_EQ(tooltip_text, tooltip);
 
-  base::string16 empty_text;
-  label.SetTooltipText(empty_text);
+  label.SetTooltipText(base::string16());
   EXPECT_TRUE(label.GetTooltipText(gfx::Point(), &tooltip));
-  EXPECT_EQ(test_text, tooltip);
+  EXPECT_EQ(label.text(), tooltip);
 
   // Make the label big enough to hold the text
   // and expect there to be no tooltip.
   label.SetBounds(0, 0, 1000, 40);
   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(empty_text);
+  label.SetTooltipText(base::string16());
 
   // Shrink the bounds and the tooltip should come back.
   label.SetBounds(0, 0, 1, 1);
   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.
   label.SetMultiLine(true);
   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(empty_text);
+  label.SetTooltipText(base::string16());
 }
 
 TEST(LabelTest, Accessibility) {
   Label label;
-  base::string16 test_text(ASCIIToUTF16("My special text."));
-  label.SetText(test_text);
+  label.SetText(ASCIIToUTF16("My special text."));
 
   ui::AXViewState state;
   label.GetAccessibleState(&state);
   EXPECT_EQ(ui::AX_ROLE_STATIC_TEXT, state.role);
-  EXPECT_EQ(test_text, state.name);
+  EXPECT_EQ(label.text(), state.name);
   EXPECT_TRUE(state.HasStateFlag(ui::AX_STATE_READ_ONLY));
 }
 
 TEST(LabelTest, SingleLineSizing) {
   Label label;
-  base::string16 test_text(ASCIIToUTF16("A not so random string in one line."));
-  label.SetText(test_text);
+  label.SetText(ASCIIToUTF16("A not so random string in one line."));
 
   // GetPreferredSize
   gfx::Size required_size = label.GetPreferredSize();
   EXPECT_GT(required_size.height(), kMinTextDimension);
   EXPECT_GT(required_size.width(), kMinTextDimension);
 
   // Test everything with borders.
   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());
 }
 
 TEST(LabelTest, MultilineSmallAvailableWidthSizing) {
   Label label;
-  base::string16 test_text(ASCIIToUTF16("Too Wide."));
-
   label.SetMultiLine(true);
   label.SetAllowCharacterBreak(true);
-  label.SetElideBehavior(Label::ELIDE_AT_END);
-  label.SetText(test_text);
+  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.
   // Incorrect word splitting may cause infinite loops in text layout.
   gfx::Size required_size = label.GetPreferredSize();
-  for (int i = 1; i < required_size.width(); ++i) {
+  for (int i = 1; i < required_size.width(); ++i)
     EXPECT_GT(label.GetHeightForWidth(i), 0);
-  }
 }
 
 TEST(LabelTest, MultiLineSizing) {
   Label label;
   label.SetFocusable(false);
-  base::string16 test_text(
+  label.SetText(
       ASCIIToUTF16("A random string\nwith multiple lines\nand returns!"));
-  label.SetText(test_text);
   label.SetMultiLine(true);
 
   // GetPreferredSize
   gfx::Size required_size = label.GetPreferredSize();
   EXPECT_GT(required_size.height(), kMinTextDimension);
   EXPECT_GT(required_size.width(), kMinTextDimension);
 
   // SizeToFit with unlimited width.
   label.SizeToFit(0);
   int required_width = label.GetLocalBounds().width();
@@ skipping 61 matching lines @@
             required_size.height() + border.height());
   EXPECT_EQ(required_size_with_border.width(),
             required_size.width() + border.width());
 }
 
 TEST(LabelTest, AutoDetectDirectionality) {
   Label label;
   label.set_directionality_mode(Label::AUTO_DETECT_DIRECTIONALITY);
 
   // Test text starts with RTL character.
-  base::string16 test_text(base::WideToUTF16(L"  \x5d0\x5d1\x5d2 abc"));
-  label.SetText(test_text);
+  label.SetText(base::WideToUTF16(L"  \x5d0\x5d1\x5d2 abc"));
   gfx::Size required_size(label.GetPreferredSize());
   gfx::Size extra(22, 8);
-  label.SetBounds(0,
-                  0,
-                  required_size.width() + extra.width(),
+  label.SetBounds(0, 0, required_size.width() + extra.width(),
                   required_size.height() + extra.height());
 
   base::string16 paint_text;
   gfx::Rect text_bounds;
   int flags;
   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.
-  test_text = (base::WideToUTF16(L"ltr \x5d0\x5d1\x5d2 abc"));
-  label.SetText(test_text);
+  label.SetText(base::WideToUTF16(L"ltr \x5d0\x5d1\x5d2 abc"));
   required_size = label.GetPreferredSize();
-  label.SetBounds(0,
-                  0,
-                  required_size.width() + extra.width(),
+  label.SetBounds(0, 0, required_size.width() + extra.width(),
                   required_size.height() + extra.height());
 
   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(LabelTest, DrawSingleLineString) {
   Label label;
   label.SetFocusable(false);
 
   // Turn off mirroring so that we don't need to figure out if
   // align right really means align left.
   label.set_directionality_mode(Label::AUTO_DETECT_DIRECTIONALITY);
 
-  base::string16 test_text(ASCIIToUTF16("Here's a string with no returns."));
-  label.SetText(test_text);
+  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(),
+  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;
   int flags;
 
   // Centered text.
   label.CalculateDrawStringParams(&paint_text, &text_bounds, &flags);
-  EXPECT_EQ(test_text, paint_text);
+  EXPECT_EQ(label.text(), paint_text);
   // The text should be centered horizontally and vertically.
   EXPECT_EQ(extra.width() / 2, text_bounds.x());
   EXPECT_EQ(extra.height() / 2 , text_bounds.y());
   EXPECT_EQ(required_size.width(), text_bounds.width());
   EXPECT_EQ(required_size.height(), text_bounds.height());
   EXPECT_EQ(gfx::Canvas::TEXT_ALIGN_CENTER,
             flags & (gfx::Canvas::TEXT_ALIGN_LEFT |
                      gfx::Canvas::TEXT_ALIGN_CENTER |
                      gfx::Canvas::TEXT_ALIGN_RIGHT));
 
   // Left aligned text.
   label.SetHorizontalAlignment(gfx::ALIGN_LEFT);
   paint_text.clear();
   text_bounds.SetRect(0, 0, 0, 0);
   label.CalculateDrawStringParams(&paint_text, &text_bounds, &flags);
-  EXPECT_EQ(test_text, paint_text);
+  EXPECT_EQ(label.text(), paint_text);
   // The text should be left aligned horizontally and centered vertically.
   EXPECT_EQ(0, text_bounds.x());
   EXPECT_EQ(extra.height() / 2 , text_bounds.y());
   EXPECT_EQ(required_size.width(), text_bounds.width());
   EXPECT_EQ(required_size.height(), text_bounds.height());
   EXPECT_EQ(gfx::Canvas::TEXT_ALIGN_LEFT,
             flags & (gfx::Canvas::TEXT_ALIGN_LEFT |
                      gfx::Canvas::TEXT_ALIGN_CENTER |
                      gfx::Canvas::TEXT_ALIGN_RIGHT));
 
   // Right aligned text.
   label.SetHorizontalAlignment(gfx::ALIGN_RIGHT);
   paint_text.clear();
   text_bounds.SetRect(0, 0, 0, 0);
   label.CalculateDrawStringParams(&paint_text, &text_bounds, &flags);
-  EXPECT_EQ(test_text, paint_text);
+  EXPECT_EQ(label.text(), paint_text);
   // The text should be right aligned horizontally and centered vertically.
   EXPECT_EQ(extra.width(), text_bounds.x());
   EXPECT_EQ(extra.height() / 2 , text_bounds.y());
   EXPECT_EQ(required_size.width(), text_bounds.width());
   EXPECT_EQ(required_size.height(), text_bounds.height());
   EXPECT_EQ(gfx::Canvas::TEXT_ALIGN_RIGHT,
             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(),
+  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);
   paint_text.clear();
   text_bounds.SetRect(0, 0, 0, 0);
   label.CalculateDrawStringParams(&paint_text, &text_bounds, &flags);
-  EXPECT_EQ(test_text, paint_text);
+  EXPECT_EQ(label.text(), paint_text);
   // The text should be centered horizontally and vertically within the border.
   EXPECT_EQ(border.left() + extra.width() / 2, text_bounds.x());
   EXPECT_EQ(border.top() + extra.height() / 2 , text_bounds.y());
   EXPECT_EQ(required_size.width(), text_bounds.width());
   EXPECT_EQ(required_size.height(), text_bounds.height());
   EXPECT_EQ(gfx::Canvas::TEXT_ALIGN_CENTER,
             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);
   paint_text.clear();
   text_bounds.SetRect(0, 0, 0, 0);
   label.CalculateDrawStringParams(&paint_text, &text_bounds, &flags);
-  EXPECT_EQ(test_text, paint_text);
+  EXPECT_EQ(label.text(), paint_text);
   // The text should be left aligned horizontally and centered vertically.
   EXPECT_EQ(border.left(), text_bounds.x());
   EXPECT_EQ(border.top() + extra.height() / 2 , text_bounds.y());
   EXPECT_EQ(required_size.width(), text_bounds.width());
   EXPECT_EQ(required_size.height(), text_bounds.height());
   EXPECT_EQ(gfx::Canvas::TEXT_ALIGN_LEFT,
             flags & (gfx::Canvas::TEXT_ALIGN_LEFT |
                      gfx::Canvas::TEXT_ALIGN_CENTER |
                      gfx::Canvas::TEXT_ALIGN_RIGHT));
 
   // Right aligned text.
   label.SetHorizontalAlignment(gfx::ALIGN_RIGHT);
   paint_text.clear();
   text_bounds.SetRect(0, 0, 0, 0);
   label.CalculateDrawStringParams(&paint_text, &text_bounds, &flags);
-  EXPECT_EQ(test_text, paint_text);
+  EXPECT_EQ(label.text(), paint_text);
   // The text should be right aligned horizontally and centered vertically.
   EXPECT_EQ(border.left() + extra.width(), text_bounds.x());
   EXPECT_EQ(border.top() + extra.height() / 2 , text_bounds.y());
   EXPECT_EQ(required_size.width(), text_bounds.width());
   EXPECT_EQ(required_size.height(), text_bounds.height());
   EXPECT_EQ(gfx::Canvas::TEXT_ALIGN_RIGHT,
             flags & (gfx::Canvas::TEXT_ALIGN_LEFT |
                      gfx::Canvas::TEXT_ALIGN_CENTER |
                      gfx::Canvas::TEXT_ALIGN_RIGHT));
 }
 
 // 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(LabelTest, DrawMultiLineString) {
   Label label;
   label.SetFocusable(false);
 
   // Turn off mirroring so that we don't need to figure out if
   // align right really means align left.
   label.set_directionality_mode(Label::AUTO_DETECT_DIRECTIONALITY);
 
-  base::string16 test_text(ASCIIToUTF16("Another string\nwith returns\n\n!"));
-  label.SetText(test_text);
+  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.SetBounds(label.x(), label.y(),
                   label.width() + extra.width(),
                   label.height() + extra.height());
 
   // Do some basic verifications for all three alignments.
   base::string16 paint_text;
   gfx::Rect text_bounds;
   int flags;
   label.CalculateDrawStringParams(&paint_text, &text_bounds, &flags);
-  EXPECT_EQ(test_text, paint_text);
+  EXPECT_EQ(label.text(), paint_text);
   EXPECT_EQ(extra.width() / 2, text_bounds.x());
   EXPECT_EQ(extra.height() / 2, text_bounds.y());
   EXPECT_GT(text_bounds.width(), kMinTextDimension);
   EXPECT_GT(text_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 & flags);
   gfx::Rect center_bounds(text_bounds);
 
   label.SetHorizontalAlignment(gfx::ALIGN_LEFT);
   paint_text.clear();
   text_bounds.SetRect(0, 0, 0, 0);
   label.CalculateDrawStringParams(&paint_text, &text_bounds, &flags);
-  EXPECT_EQ(test_text, paint_text);
+  EXPECT_EQ(label.text(), paint_text);
   EXPECT_EQ(0, text_bounds.x());
   EXPECT_EQ(extra.height() / 2, text_bounds.y());
   EXPECT_GT(text_bounds.width(), kMinTextDimension);
   EXPECT_GT(text_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 & flags);
 
   label.SetHorizontalAlignment(gfx::ALIGN_RIGHT);
   paint_text.clear();
   text_bounds.SetRect(0, 0, 0, 0);
   label.CalculateDrawStringParams(&paint_text, &text_bounds, &flags);
-  EXPECT_EQ(test_text, paint_text);
+  EXPECT_EQ(label.text(), paint_text);
   EXPECT_EQ(extra.width(), text_bounds.x());
   EXPECT_EQ(extra.height() / 2, text_bounds.y());
   EXPECT_GT(text_bounds.width(), kMinTextDimension);
   EXPECT_GT(text_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 & 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.SetBounds(label.x(), label.y(),
                   label.width() + extra.width(),
                   label.height() + extra.height());
 
   label.SetHorizontalAlignment(gfx::ALIGN_CENTER);
   paint_text.clear();
   text_bounds.SetRect(0, 0, 0, 0);
   label.CalculateDrawStringParams(&paint_text, &text_bounds, &flags);
-  EXPECT_EQ(test_text, paint_text);
+  EXPECT_EQ(label.text(), paint_text);
   EXPECT_EQ(border.left() + extra.width() / 2, text_bounds.x());
   EXPECT_EQ(border.top() + extra.height() / 2, text_bounds.y());
   EXPECT_EQ(center_bounds.width(), text_bounds.width());
   EXPECT_EQ(center_bounds.height(), text_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 & flags);
 
   label.SetHorizontalAlignment(gfx::ALIGN_LEFT);
   paint_text.clear();
   text_bounds.SetRect(0, 0, 0, 0);
   label.CalculateDrawStringParams(&paint_text, &text_bounds, &flags);
-  EXPECT_EQ(test_text, paint_text);
+  EXPECT_EQ(label.text(), paint_text);
   EXPECT_EQ(border.left(), text_bounds.x());
   EXPECT_EQ(border.top() + extra.height() / 2, text_bounds.y());
   EXPECT_EQ(center_bounds.width(), text_bounds.width());
   EXPECT_EQ(center_bounds.height(), text_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 & flags);
 
   label.SetHorizontalAlignment(gfx::ALIGN_RIGHT);
   paint_text.clear();
   text_bounds.SetRect(0, 0, 0, 0);
   label.CalculateDrawStringParams(&paint_text, &text_bounds, &flags);
-  EXPECT_EQ(test_text, paint_text);
+  EXPECT_EQ(label.text(), paint_text);
   EXPECT_EQ(extra.width() + border.left(), text_bounds.x());
   EXPECT_EQ(border.top() + extra.height() / 2, text_bounds.y());
   EXPECT_EQ(center_bounds.width(), text_bounds.width());
   EXPECT_EQ(center_bounds.height(), text_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 & flags);
 }
 
 TEST(LabelTest, DrawSingleLineStringInRTL) {
   Label label;
   label.SetFocusable(false);
 
   std::string locale = l10n_util::GetApplicationLocale("");
   base::i18n::SetICUDefaultLocale("he");
 
-  base::string16 test_text(ASCIIToUTF16("Here's a string with no returns."));
-  label.SetText(test_text);
+  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(),
+  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;
   int flags;
 
   // Centered text.
   label.CalculateDrawStringParams(&paint_text, &text_bounds, &flags);
-  EXPECT_EQ(test_text, paint_text);
+  EXPECT_EQ(label.text(), paint_text);
   // The text should be centered horizontally and vertically.
   EXPECT_EQ(extra.width() / 2, text_bounds.x());
   EXPECT_EQ(extra.height() / 2 , text_bounds.y());
   EXPECT_EQ(required_size.width(), text_bounds.width());
   EXPECT_EQ(required_size.height(), text_bounds.height());
   EXPECT_EQ(gfx::Canvas::TEXT_ALIGN_CENTER,
             flags & (gfx::Canvas::TEXT_ALIGN_LEFT |
                      gfx::Canvas::TEXT_ALIGN_CENTER |
                      gfx::Canvas::TEXT_ALIGN_RIGHT));
 
   // ALIGN_LEFT label.
   label.SetHorizontalAlignment(gfx::ALIGN_LEFT);
   paint_text.clear();
   text_bounds.SetRect(0, 0, 0, 0);
   label.CalculateDrawStringParams(&paint_text, &text_bounds, &flags);
-  EXPECT_EQ(test_text, paint_text);
+  EXPECT_EQ(label.text(), paint_text);
   // The text should be right aligned horizontally and centered vertically.
   EXPECT_EQ(extra.width(), text_bounds.x());
   EXPECT_EQ(extra.height() / 2 , text_bounds.y());
   EXPECT_EQ(required_size.width(), text_bounds.width());
   EXPECT_EQ(required_size.height(), text_bounds.height());
   EXPECT_EQ(gfx::Canvas::TEXT_ALIGN_RIGHT,
             flags & (gfx::Canvas::TEXT_ALIGN_LEFT |
                      gfx::Canvas::TEXT_ALIGN_CENTER |
                      gfx::Canvas::TEXT_ALIGN_RIGHT));
 
   // ALIGN_RIGHT label.
   label.SetHorizontalAlignment(gfx::ALIGN_RIGHT);
   paint_text.clear();
   text_bounds.SetRect(0, 0, 0, 0);
   label.CalculateDrawStringParams(&paint_text, &text_bounds, &flags);
-  EXPECT_EQ(test_text, paint_text);
+  EXPECT_EQ(label.text(), paint_text);
   // The text should be left aligned horizontally and centered vertically.
   EXPECT_EQ(0, text_bounds.x());
   EXPECT_EQ(extra.height() / 2 , text_bounds.y());
   EXPECT_EQ(required_size.width(), text_bounds.width());
   EXPECT_EQ(required_size.height(), text_bounds.height());
   EXPECT_EQ(gfx::Canvas::TEXT_ALIGN_LEFT,
             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(),
+  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);
   paint_text.clear();
   text_bounds.SetRect(0, 0, 0, 0);
   label.CalculateDrawStringParams(&paint_text, &text_bounds, &flags);
-  EXPECT_EQ(test_text, paint_text);
+  EXPECT_EQ(label.text(), paint_text);
   // The text should be centered horizontally and vertically within the border.
   EXPECT_EQ(border.left() + extra.width() / 2, text_bounds.x());
   EXPECT_EQ(border.top() + extra.height() / 2 , text_bounds.y());
   EXPECT_EQ(required_size.width(), text_bounds.width());
   EXPECT_EQ(required_size.height(), text_bounds.height());
   EXPECT_EQ(gfx::Canvas::TEXT_ALIGN_CENTER,
             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);
   paint_text.clear();
   text_bounds.SetRect(0, 0, 0, 0);
   label.CalculateDrawStringParams(&paint_text, &text_bounds, &flags);
-  EXPECT_EQ(test_text, paint_text);
+  EXPECT_EQ(label.text(), paint_text);
   // The text should be right aligned horizontally and centered vertically.
   EXPECT_EQ(border.left() + extra.width(), text_bounds.x());
   EXPECT_EQ(border.top() + extra.height() / 2 , text_bounds.y());
   EXPECT_EQ(required_size.width(), text_bounds.width());
   EXPECT_EQ(required_size.height(), text_bounds.height());
   EXPECT_EQ(gfx::Canvas::TEXT_ALIGN_RIGHT,
             flags & (gfx::Canvas::TEXT_ALIGN_LEFT |
                      gfx::Canvas::TEXT_ALIGN_CENTER |
                      gfx::Canvas::TEXT_ALIGN_RIGHT));
 
   // ALIGN_RIGHT text.
   label.SetHorizontalAlignment(gfx::ALIGN_RIGHT);
   paint_text.clear();
   text_bounds.SetRect(0, 0, 0, 0);
   label.CalculateDrawStringParams(&paint_text, &text_bounds, &flags);
-  EXPECT_EQ(test_text, paint_text);
+  EXPECT_EQ(label.text(), paint_text);
   // The text should be left aligned horizontally and centered vertically.
   EXPECT_EQ(border.left(), text_bounds.x());
   EXPECT_EQ(border.top() + extra.height() / 2 , text_bounds.y());
   EXPECT_EQ(required_size.width(), text_bounds.width());
   EXPECT_EQ(required_size.height(), text_bounds.height());
   EXPECT_EQ(gfx::Canvas::TEXT_ALIGN_LEFT,
             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(LabelTest, DrawMultiLineStringInRTL) {
   Label label;
   label.SetFocusable(false);
 
   // Test for RTL.
   std::string locale = l10n_util::GetApplicationLocale("");
   base::i18n::SetICUDefaultLocale("he");
 
-  base::string16 test_text(ASCIIToUTF16("Another string\nwith returns\n\n!"));
-  label.SetText(test_text);
+  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.SetBounds(label.x(), label.y(),
                   label.width() + extra.width(),
                   label.height() + extra.height());
 
   // Do some basic verifications for all three alignments.
   base::string16 paint_text;
   gfx::Rect text_bounds;
   int flags;
   label.CalculateDrawStringParams(&paint_text, &text_bounds, &flags);
-  EXPECT_EQ(test_text, paint_text);
+  EXPECT_EQ(label.text(), paint_text);
   EXPECT_EQ(extra.width() / 2, text_bounds.x());
   EXPECT_EQ(extra.height() / 2, text_bounds.y());
   EXPECT_GT(text_bounds.width(), kMinTextDimension);
   EXPECT_GT(text_bounds.height(), kMinTextDimension);
   EXPECT_TRUE(gfx::Canvas::MULTI_LINE & flags);
   EXPECT_TRUE(gfx::Canvas::TEXT_ALIGN_CENTER & flags);
 #if !defined(OS_WIN)
   EXPECT_TRUE(gfx::Canvas::NO_ELLIPSIS & flags);
 #endif
   gfx::Rect center_bounds(text_bounds);
 
   label.SetHorizontalAlignment(gfx::ALIGN_LEFT);
   paint_text.clear();
   text_bounds.SetRect(0, 0, 0, 0);
   label.CalculateDrawStringParams(&paint_text, &text_bounds, &flags);
-  EXPECT_EQ(test_text, paint_text);
+  EXPECT_EQ(label.text(), paint_text);
   EXPECT_EQ(extra.width(), text_bounds.x());
   EXPECT_EQ(extra.height() / 2, text_bounds.y());
   EXPECT_GT(text_bounds.width(), kMinTextDimension);
   EXPECT_GT(text_bounds.height(), kMinTextDimension);
   EXPECT_TRUE(gfx::Canvas::MULTI_LINE & flags);
   EXPECT_TRUE(gfx::Canvas::TEXT_ALIGN_RIGHT & flags);
 #if !defined(OS_WIN)
   EXPECT_TRUE(gfx::Canvas::NO_ELLIPSIS & flags);
 #endif
 
   label.SetHorizontalAlignment(gfx::ALIGN_RIGHT);
   paint_text.clear();
   text_bounds.SetRect(0, 0, 0, 0);
   label.CalculateDrawStringParams(&paint_text, &text_bounds, &flags);
-  EXPECT_EQ(test_text, paint_text);
+  EXPECT_EQ(label.text(), paint_text);
   EXPECT_EQ(0, text_bounds.x());
   EXPECT_EQ(extra.height() / 2, text_bounds.y());
   EXPECT_GT(text_bounds.width(), kMinTextDimension);
   EXPECT_GT(text_bounds.height(), kMinTextDimension);
   EXPECT_TRUE(gfx::Canvas::MULTI_LINE & flags);
   EXPECT_TRUE(gfx::Canvas::TEXT_ALIGN_LEFT & flags);
 #if !defined(OS_WIN)
   EXPECT_TRUE(gfx::Canvas::NO_ELLIPSIS & 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.SetBounds(label.x(), label.y(),
                   label.width() + extra.width(),
                   label.height() + extra.height());
 
   label.SetHorizontalAlignment(gfx::ALIGN_CENTER);
   paint_text.clear();
   text_bounds.SetRect(0, 0, 0, 0);
   label.CalculateDrawStringParams(&paint_text, &text_bounds, &flags);
-  EXPECT_EQ(test_text, paint_text);
+  EXPECT_EQ(label.text(), paint_text);
   EXPECT_EQ(border.left() + extra.width() / 2, text_bounds.x());
   EXPECT_EQ(border.top() + extra.height() / 2, text_bounds.y());
   EXPECT_EQ(center_bounds.width(), text_bounds.width());
   EXPECT_EQ(center_bounds.height(), text_bounds.height());
   EXPECT_TRUE(gfx::Canvas::MULTI_LINE & flags);
   EXPECT_TRUE(gfx::Canvas::TEXT_ALIGN_CENTER & flags);
 #if !defined(OS_WIN)
   EXPECT_TRUE(gfx::Canvas::NO_ELLIPSIS & flags);
 #endif
 
   label.SetHorizontalAlignment(gfx::ALIGN_LEFT);
   paint_text.clear();
   text_bounds.SetRect(0, 0, 0, 0);
   label.CalculateDrawStringParams(&paint_text, &text_bounds, &flags);
-  EXPECT_EQ(test_text, paint_text);
+  EXPECT_EQ(label.text(), paint_text);
   EXPECT_EQ(border.left() + extra.width(), text_bounds.x());
   EXPECT_EQ(border.top() + extra.height() / 2, text_bounds.y());
   EXPECT_EQ(center_bounds.width(), text_bounds.width());
   EXPECT_EQ(center_bounds.height(), text_bounds.height());
   EXPECT_TRUE(gfx::Canvas::MULTI_LINE & flags);
   EXPECT_TRUE(gfx::Canvas::TEXT_ALIGN_RIGHT & flags);
 #if !defined(OS_WIN)
   EXPECT_TRUE(gfx::Canvas::NO_ELLIPSIS & flags);
 #endif
 
   label.SetHorizontalAlignment(gfx::ALIGN_RIGHT);
   paint_text.clear();
   text_bounds.SetRect(0, 0, 0, 0);
   label.CalculateDrawStringParams(&paint_text, &text_bounds, &flags);
-  EXPECT_EQ(test_text, paint_text);
+  EXPECT_EQ(label.text(), paint_text);
   EXPECT_EQ(border.left(), text_bounds.x());
   EXPECT_EQ(border.top() + extra.height() / 2, text_bounds.y());
   EXPECT_EQ(center_bounds.width(), text_bounds.width());
   EXPECT_EQ(center_bounds.height(), text_bounds.height());
   EXPECT_TRUE(gfx::Canvas::MULTI_LINE & flags);
   EXPECT_TRUE(gfx::Canvas::TEXT_ALIGN_LEFT & flags);
 #if !defined(OS_WIN)
   EXPECT_TRUE(gfx::Canvas::NO_ELLIPSIS & flags);
 #endif
 
@@ skipping 38 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