Revert of Use labels to display views tab titles.

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"
 #include "ui/base/l10n/l10n_util.h"
 #include "ui/gfx/canvas.h"
 #include "ui/views/border.h"
 
 using base::ASCIIToUTF16;
 
 namespace views {
 
 // All text sizing measurements (width and height) should be greater than this.
 const int kMinTextDimension = 4;
 
-// A test utility function to set the application default text direction.
-void SetRTL(bool rtl) {
-  // Override the current locale/direction.
-  base::i18n::SetICUDefaultLocale(rtl ? "he" : "en");
-  EXPECT_EQ(rtl, base::i18n::IsRTL());
-}
-
 TEST(LabelTest, FontPropertySymbol) {
   Label label;
   std::string font_name("symbol");
   gfx::Font font(font_name, 26);
   label.SetFontList(gfx::FontList(font));
   gfx::Font font_used = label.font_list().GetPrimaryFont();
   EXPECT_EQ(font_name, font_used.GetFontName());
   EXPECT_EQ(26, font_used.GetFontSize());
 }
 
@@ skipping 16 matching lines @@
 
 TEST(LabelTest, ColorProperty) {
   Label label;
   SkColor color = SkColorSetARGB(20, 40, 10, 5);
   label.SetAutoColorReadabilityEnabled(false);
   label.SetEnabledColor(color);
   EXPECT_EQ(color, label.enabled_color());
 }
 
 TEST(LabelTest, AlignmentProperty) {
-  const bool was_rtl = base::i18n::IsRTL();
+  Label label;
+  bool reverse_alignment = base::i18n::IsRTL();
 
-  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();
+  label.SetHorizontalAlignment(gfx::ALIGN_RIGHT);
+  EXPECT_EQ(reverse_alignment ? gfx::ALIGN_LEFT : gfx::ALIGN_RIGHT,
+            label.horizontal_alignment());
+  label.SetHorizontalAlignment(gfx::ALIGN_LEFT);
+  EXPECT_EQ(reverse_alignment ? gfx::ALIGN_RIGHT : gfx::ALIGN_LEFT,
+            label.horizontal_alignment());
+  label.SetHorizontalAlignment(gfx::ALIGN_CENTER);
+  EXPECT_EQ(gfx::ALIGN_CENTER, label.horizontal_alignment());
 
-    // 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.SetHorizontalAlignment(gfx::ALIGN_LEFT);
-    EXPECT_EQ(reverse_alignment ? gfx::ALIGN_RIGHT : gfx::ALIGN_LEFT,
-              label.GetHorizontalAlignment());
-    label.SetHorizontalAlignment(gfx::ALIGN_CENTER);
-    EXPECT_EQ(gfx::ALIGN_CENTER, label.GetHorizontalAlignment());
-
-    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(was_rtl, base::i18n::IsRTL());
+  // The label's alignment should not be flipped if the directionality mode is
+  // AUTO_DETECT_DIRECTIONALITY.
+  label.set_directionality_mode(Label::AUTO_DETECT_DIRECTIONALITY);
+  label.SetHorizontalAlignment(gfx::ALIGN_RIGHT);
+  EXPECT_EQ(gfx::ALIGN_RIGHT, label.horizontal_alignment());
+  label.SetHorizontalAlignment(gfx::ALIGN_LEFT);
+  EXPECT_EQ(gfx::ALIGN_LEFT, label.horizontal_alignment());
+  label.SetHorizontalAlignment(gfx::ALIGN_CENTER);
+  EXPECT_EQ(gfx::ALIGN_CENTER, label.horizontal_alignment());
 }
 
 TEST(LabelTest, DirectionalityModeProperty) {
   Label label;
-  EXPECT_EQ(gfx::DIRECTIONALITY_FROM_UI, label.directionality_mode());
+  EXPECT_EQ(Label::USE_UI_DIRECTIONALITY, label.directionality_mode());
 
-  label.set_directionality_mode(gfx::DIRECTIONALITY_FROM_TEXT);
-  EXPECT_EQ(gfx::DIRECTIONALITY_FROM_TEXT, label.directionality_mode());
+  label.set_directionality_mode(Label::AUTO_DETECT_DIRECTIONALITY);
+  EXPECT_EQ(Label::AUTO_DETECT_DIRECTIONALITY, label.directionality_mode());
 
-  label.set_directionality_mode(gfx::DIRECTIONALITY_FROM_UI);
-  EXPECT_EQ(gfx::DIRECTIONALITY_FROM_UI, label.directionality_mode());
+  label.set_directionality_mode(Label::USE_UI_DIRECTIONALITY);
+  EXPECT_EQ(Label::USE_UI_DIRECTIONALITY, label.directionality_mode());
 }
 
 TEST(LabelTest, MultiLineProperty) {
   Label label;
   EXPECT_FALSE(label.is_multi_line());
   label.SetMultiLine(true);
   EXPECT_TRUE(label.is_multi_line());
   label.SetMultiLine(false);
   EXPECT_FALSE(label.is_multi_line());
 }
@@ skipping 210 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(LabelTest, DirectionalityFromText) {
+TEST(LabelTest, AutoDetectDirectionality) {
   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;
+  label.set_directionality_mode(Label::AUTO_DETECT_DIRECTIONALITY);
 
   // Test text starts with RTL character.
   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(),
+                  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.
   label.SetText(base::WideToUTF16(L"ltr \x5d0\x5d1\x5d2 abc"));
+  required_size = label.GetPreferredSize();
+  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);
-  // Force a directionality to simplify alignment value testing.
-  label.set_directionality_mode(gfx::DIRECTIONALITY_FORCE_LTR);
+
+  // 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);
 
   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;
-  int flags = -1;
+  int flags;
 
   // Centered text.
   label.CalculateDrawStringParams(&paint_text, &text_bounds, &flags);
   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,
@@ skipping 88 matching lines @@
   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));
 }
 
-// Pango needs a max height to elide multiline text; that is not supported here.
+// 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);
-  // 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);
+
+  // 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);
 
   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.
   base::string16 paint_text;
   gfx::Rect text_bounds;
-  int flags = -1;
+  int flags;
   label.CalculateDrawStringParams(&paint_text, &text_bounds, &flags);
   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);
+  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(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);
+  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(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);
+  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.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(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);
+  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(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);
+  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(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);
+  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");
 
   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;
-  int flags = -1;
+  int flags;
 
   // Centered text.
   label.CalculateDrawStringParams(&paint_text, &text_bounds, &flags);
   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,
@@ skipping 114 matching lines @@
   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.
   base::string16 paint_text;
   gfx::Rect text_bounds;
-  int flags = -1;
+  int flags;
   label.CalculateDrawStringParams(&paint_text, &text_bounds, &flags);
   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);
@@ skipping 125 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