Change signature of |ui::ElideText()|. Add a truncate mode.

ui/base/text/text_elider_unittest.cc

 // Copyright (c) 2011 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 "base/file_path.h"
 #include "base/i18n/rtl.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/string_util.h"
 #include "base/utf_string_conversions.h"
 #include "googleurl/src/gurl.h"
@@ skipping 64 matching lines @@
      "www.google.com/intl/en/ads/?aLongQ" + kEllipsisStr},
   };
 
   RunTest(testcases, arraysize(testcases));
 }
 
 // When there is very little space available, the elision code will shorten
 // both path AND file name to an ellipsis - ".../...". To avoid this result,
 // there is a hack in place that simply treats them as one string in this
 // case.
-TEST(TextEliderTest, TestTrailingEllipsisSlashEllipsisHack)
-{
+TEST(TextEliderTest, TestTrailingEllipsisSlashEllipsisHack) {
   const std::string kEllipsisStr(kEllipsis);
 
   // Very little space, would cause double ellipsis.
   gfx::Font font;
   GURL url("http://battersbox.com/directory/foo/peter_paul_and_mary.html");
   int available_width = font.GetStringWidth(
       UTF8ToUTF16("battersbox.com/" + kEllipsisStr + "/" + kEllipsisStr));
   EXPECT_EQ(UTF8ToUTF16("battersbox.com/dir" + kEllipsisStr),
              ElideUrl(url, font, available_width, std::string()));
 
@@ skipping 111 matching lines @@
   for (size_t i = 0; i < arraysize(testcases); ++i) {
     FilePath filepath(testcases[i].input);
     string16 expected = UTF8ToUTF16(testcases[i].output);
     expected = base::i18n::GetDisplayStringInLTRDirectionality(expected);
     EXPECT_EQ(expected, ElideFilename(filepath,
         font,
         font.GetStringWidth(UTF8ToUTF16(testcases[i].output))));
   }
 }
 
+TEST(TextEliderTest, ElideTextTruncate) {
+  const gfx::Font font;
+  const int kTestWidth = font.GetStringWidth(ASCIIToUTF16("Test"));
+  struct TestData {
+    const char* input;
+    int width;
+    const char* output;
+  } cases[] = {
+    { "", 0, "" },
+    { "Test", 0, "" },
+    { "", kTestWidth, "" },
+    { "Tes", kTestWidth, "Tes" },
+    { "Test", kTestWidth, "Test" },
+    { "Tests", kTestWidth, "Test" },
+  };
+
+  for (size_t i = 0; i < ARRAYSIZE_UNSAFE(cases); ++i) {
+    string16 result = ui::ElideText(UTF8ToUTF16(cases[i].input), font,
+                                    cases[i].width, ui::TRUNCATE_AT_END);
+    EXPECT_EQ(cases[i].output, UTF16ToUTF8(result));
+  }
+}
+
 TEST(TextEliderTest, ElideTextLongStrings) {
   const string16 kEllipsisStr = UTF8ToUTF16(kEllipsis);
   string16 data_scheme(UTF8ToUTF16("data:text/plain,"));
   size_t data_scheme_length = data_scheme.length();
 
   string16 ten_a(10, 'a');
   string16 hundred_a(100, 'a');
   string16 thousand_a(1000, 'a');
   string16 ten_thousand_a(10000, 'a');
   string16 hundred_thousand_a(100000, 'a');
@@ skipping 12 matching lines @@
   };
 
   const gfx::Font font;
   int ellipsis_width = font.GetStringWidth(kEllipsisStr);
   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,
                         font.GetStringWidth(testcases_end[i].output),
-                        false).size());
+                        ui::ELIDE_AT_END).size());
     EXPECT_EQ(kEllipsisStr,
-              ElideText(testcases_end[i].input, font, ellipsis_width, false));
+              ElideText(testcases_end[i].input, font, ellipsis_width,
+                        ui::ELIDE_AT_END));
   }
 
   size_t number_of_trailing_as = (data_scheme_length + number_of_as) / 2;
   string16 long_string_middle(data_scheme +
       string16(number_of_as - number_of_trailing_as, 'a') + kEllipsisStr +
       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,
                         font.GetStringWidth(testcases_middle[i].output),
-                        false).size());
+                        ui::ELIDE_AT_END).size());
     EXPECT_EQ(kEllipsisStr,
               ElideText(testcases_middle[i].input, font, ellipsis_width,
-                        false));
+                        ui::ELIDE_AT_END));
   }
 }
 
 // Verifies display_url is set correctly.
 TEST(TextEliderTest, SortedDisplayURL) {
   ui::SortedDisplayURL d_url(GURL("http://www.google.com"), std::string());
   EXPECT_EQ("www.google.com", UTF16ToASCII(d_url.display_url()));
 }
 
 // Verifies DisplayURL::Compare works correctly.
@@ skipping 280 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(ui::TruncateString(string, 11)));
 
   // Test completely truncates string if break is on initial whitespace.
   EXPECT_EQ(L"\x2026", UTF16ToWide(ui::TruncateString(ASCIIToUTF16("   "), 2)));
 }
 
 }  // namespace ui