Add fade eliding for Views Labels; related cleanup.

ui/gfx/text_elider_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.
 //
 // Unit tests for eliding and formatting utility functions.
 
 #include "ui/gfx/text_elider.h"
 
 #include "base/files/file_path.h"
 #include "base/i18n/rtl.h"
@@ skipping 88 matching lines @@
       // the domain must elide to "l..." and not "l...l" as it must allow enough
       // space for the minimal username elision although its half of the
       // available width would normally allow it to elide to "l...l".
       {"mmmmm@llllllllll", "m" + kEllipsisStr + "@l" + kEllipsisStr},
   };
 
   const FontList font_list;
   for (size_t i = 0; i < arraysize(testcases); ++i) {
     const base::string16 expected_output = UTF8ToUTF16(testcases[i].output);
     EXPECT_EQ(expected_output,
-              ElideEmail(
-                  UTF8ToUTF16(testcases[i].input),
-                  font_list,
-                  GetStringWidthF(expected_output, font_list)));
+              ElideText(UTF8ToUTF16(testcases[i].input), font_list,
+                        GetStringWidthF(expected_output, font_list),
+                        ELIDE_EMAIL));
   }
 }
 
 // TODO(338784): Enable this on android.
 #if defined(OS_ANDROID)
 #define MAYBE_ElideEmailMoreSpace DISABLED_ElideEmailMoreSpace
 #else
 #define MAYBE_ElideEmailMoreSpace ElideEmailMoreSpace
 #endif
 TEST(TextEliderTest, MAYBE_ElideEmailMoreSpace) {
   const int test_width_factors[] = {
       100,
       10000,
       1000000,
   };
   const std::string test_emails[] = {
       "a@c",
       "test@email.com",
       "short@verysuperdupperlongdomain.com",
       "supermegalongusername@withasuperlonnnggggdomain.gouv.qc.ca",
   };
 
   const FontList font_list;
   for (size_t i = 0; i < arraysize(test_width_factors); ++i) {
     const int test_width =
         font_list.GetExpectedTextWidth(test_width_factors[i]);
     for (size_t j = 0; j < arraysize(test_emails); ++j) {
       // Extra space is available: the email should not be elided.
       const base::string16 test_email = UTF8ToUTF16(test_emails[j]);
-      EXPECT_EQ(test_email, ElideEmail(test_email, font_list, test_width));
+      EXPECT_EQ(test_email,
+                ElideText(test_email, font_list, test_width, ELIDE_EMAIL));
     }
   }
 }
 
 // TODO(ios): This test fails on iOS because iOS version of GetStringWidthF
 // that calls [NSString sizeWithFont] returns the rounded string width.
 // TODO(338784): Enable this on android.
 #if defined(OS_IOS) || defined(OS_ANDROID)
 #define MAYBE_TestFilenameEliding DISABLED_TestFilenameEliding
 #else
@@ skipping 65 matching lines @@
     { "", 0, "" },
     { "Test", 0, "" },
     { "", kTestWidth, "" },
     { "Tes", kTestWidth, "Tes" },
     { "Test", kTestWidth, "Test" },
     { "Tests", kTestWidth, "Test" },
   };
 
   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(cases); ++i) {
     base::string16 result = ElideText(UTF8ToUTF16(cases[i].input), font_list,
-                                cases[i].width, TRUNCATE_AT_END);
+                                      cases[i].width, TRUNCATE);
     EXPECT_EQ(cases[i].output, UTF16ToUTF8(result));
   }
 }
 
 // TODO(338784): Enable this on android.
 #if defined(OS_ANDROID)
 #define MAYBE_ElideTextEllipsis DISABLED_ElideTextEllipsis
 #else
 #define MAYBE_ElideTextEllipsis ElideTextEllipsis
 #endif
@@ skipping 11 matching lines @@
     { "", 0, "" },
     { "Test", 0, "" },
     { "Test", kEllipsisWidth, kEllipsis },
     { "", kTestWidth, "" },
     { "Tes", kTestWidth, "Tes" },
     { "Test", kTestWidth, "Test" },
   };
 
   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(cases); ++i) {
     base::string16 result = ElideText(UTF8ToUTF16(cases[i].input), font_list,
-                                cases[i].width, ELIDE_AT_END);
+                                      cases[i].width, ELIDE_TAIL);
     EXPECT_EQ(cases[i].output, UTF16ToUTF8(result));
   }
 }
 
 // TODO(338784): Enable this on android.
 #if defined(OS_ANDROID)
 #define MAYBE_ElideTextEllipsisFront DISABLED_ElideTextEllipsisFront
 #else
 #define MAYBE_ElideTextEllipsisFront ElideTextEllipsisFront
 #endif
@@ skipping 14 matching lines @@
     { "Test",    0,                base::string16() },
     { "Test",    kEllipsisWidth,   UTF8ToUTF16(kEllipsisStr) },
     { "",        kTestWidth,       base::string16() },
     { "Tes",     kTestWidth,       ASCIIToUTF16("Tes") },
     { "Test",    kTestWidth,       ASCIIToUTF16("Test") },
     { "Test123", kEllipsis23Width, UTF8ToUTF16(kEllipsisStr + "23") },
   };
 
   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(cases); ++i) {
     base::string16 result = ElideText(UTF8ToUTF16(cases[i].input), font_list,
-                                      cases[i].width, ELIDE_AT_BEGINNING);
+                                      cases[i].width, ELIDE_HEAD);
     EXPECT_EQ(cases[i].output, result);
   }
 }
 
 // Checks that all occurrences of |first_char| are followed by |second_char| and
 // all occurrences of |second_char| are preceded by |first_char| in |text|.
 static void CheckSurrogatePairs(const base::string16& text,
                                 base::char16 first_char,
                                 base::char16 second_char) {
   size_t index = text.find_first_of(first_char);
@@ skipping 24 matching lines @@
   const base::string16 kTestString =
       UTF8ToUTF16(kSurrogate + "ab" + kSurrogate + kSurrogate + "cd");
   const float kTestStringWidth = GetStringWidthF(kTestString, font_list);
   const base::char16 kSurrogateFirstChar = kTestString[0];
   const base::char16 kSurrogateSecondChar = kTestString[1];
   base::string16 result;
 
   // Elide |kTextString| to all possible widths and check that no instance of
   // |kSurrogate| was split in two.
   for (float width = 0; width <= kTestStringWidth; width++) {
-    result = ElideText(kTestString, font_list, width, TRUNCATE_AT_END);
+    result = ElideText(kTestString, font_list, width, TRUNCATE);
     CheckSurrogatePairs(result, kSurrogateFirstChar, kSurrogateSecondChar);
 
-    result = ElideText(kTestString, font_list, width, ELIDE_AT_END);
+    result = ElideText(kTestString, font_list, width, ELIDE_TAIL);
     CheckSurrogatePairs(result, kSurrogateFirstChar, kSurrogateSecondChar);
 
-    result = ElideText(kTestString, font_list, width, ELIDE_IN_MIDDLE);
+    result = ElideText(kTestString, font_list, width, ELIDE_MIDDLE);
     CheckSurrogatePairs(result, kSurrogateFirstChar, kSurrogateSecondChar);
 
-    result = ElideText(kTestString, font_list, width, ELIDE_AT_BEGINNING);
+    result = ElideText(kTestString, font_list, width, ELIDE_HEAD);
     CheckSurrogatePairs(result, kSurrogateFirstChar, kSurrogateSecondChar);
   }
 }
 
 // TODO(338784): Enable this on android.
 #if defined(OS_ANDROID)
 #define MAYBE_ElideTextLongStrings DISABLED_ElideTextLongStrings
 #else
 #define MAYBE_ElideTextLongStrings ElideTextLongStrings
 #endif
@@ skipping 23 matching lines @@
      { data_scheme + hundred_thousand_a, long_string_end },
      { data_scheme + million_a,          long_string_end },
   };
 
   const FontList font_list;
   float ellipsis_width = GetStringWidthF(kEllipsisStr, font_list);
   for (size_t i = 0; i < arraysize(testcases_end); ++i) {
     // Compare sizes rather than actual contents because if the test fails,
     // output is rather long.
     EXPECT_EQ(testcases_end[i].output.size(),
-              ElideText(
-                  testcases_end[i].input,
-                  font_list,
-                  GetStringWidthF(testcases_end[i].output, font_list),
-                  ELIDE_AT_END).size());
+              ElideText(testcases_end[i].input, font_list,
+                        GetStringWidthF(testcases_end[i].output, font_list),
+                        ELIDE_TAIL).size());
     EXPECT_EQ(kEllipsisStr,
               ElideText(testcases_end[i].input, font_list, ellipsis_width,
-                        ELIDE_AT_END));
+                        ELIDE_TAIL));
   }
 
   size_t number_of_trailing_as = (data_scheme_length + number_of_as) / 2;
   base::string16 long_string_middle(data_scheme +
       base::string16(number_of_as - number_of_trailing_as, 'a') + kEllipsisStr +
       base::string16(number_of_trailing_as, 'a'));
   UTF16Testcase testcases_middle[] = {
      { data_scheme + ten_a,              data_scheme + ten_a },
      { data_scheme + hundred_a,          data_scheme + hundred_a },
      { data_scheme + thousand_a,         long_string_middle },
      { data_scheme + ten_thousand_a,     long_string_middle },
      { data_scheme + hundred_thousand_a, long_string_middle },
      { data_scheme + million_a,          long_string_middle },
   };
 
   for (size_t i = 0; i < arraysize(testcases_middle); ++i) {
     // Compare sizes rather than actual contents because if the test fails,
     // output is rather long.
     EXPECT_EQ(testcases_middle[i].output.size(),
-              ElideText(
-                  testcases_middle[i].input,
-                  font_list,
-                  GetStringWidthF(testcases_middle[i].output, font_list),
-                  ELIDE_IN_MIDDLE).size());
+              ElideText(testcases_middle[i].input, font_list,
+                        GetStringWidthF(testcases_middle[i].output, font_list),
+                        ELIDE_MIDDLE).size());
     EXPECT_EQ(kEllipsisStr,
               ElideText(testcases_middle[i].input, font_list, ellipsis_width,
-                        ELIDE_IN_MIDDLE));
+                        ELIDE_MIDDLE));
   }
 
   base::string16 long_string_beginning(
       kEllipsisStr + base::string16(number_of_as, 'a'));
   UTF16Testcase testcases_beginning[] = {
      { data_scheme + ten_a,              data_scheme + ten_a },
      { data_scheme + hundred_a,          data_scheme + hundred_a },
      { data_scheme + thousand_a,         long_string_beginning },
      { data_scheme + ten_thousand_a,     long_string_beginning },
      { data_scheme + hundred_thousand_a, long_string_beginning },
      { data_scheme + million_a,          long_string_beginning },
   };
   for (size_t i = 0; i < arraysize(testcases_beginning); ++i) {
     EXPECT_EQ(testcases_beginning[i].output.size(),
               ElideText(
                   testcases_beginning[i].input, font_list,
                   GetStringWidthF(testcases_beginning[i].output, font_list),
-                  ELIDE_AT_BEGINNING).size());
+                  ELIDE_HEAD).size());
     EXPECT_EQ(kEllipsisStr,
               ElideText(testcases_beginning[i].input, font_list, ellipsis_width,
-                        ELIDE_AT_BEGINNING));
+                        ELIDE_HEAD));
   }
 }
 
 TEST(TextEliderTest, ElideString) {
   struct TestData {
     const char* input;
     int max_len;
     bool result;
     const char* output;
   } cases[] = {
@@ skipping 445 matching lines @@
 
   // Test adds ... at right spot when there is not enough room to break at a
   // word boundary.
   EXPECT_EQ(L"foooooey\x2026", UTF16ToWide(TruncateString(string, 11)));
 
   // Test completely truncates string if break is on initial whitespace.
   EXPECT_EQ(L"\x2026", UTF16ToWide(TruncateString(ASCIIToUTF16("   "), 2)));
 }
 
 }  // namespace gfx