Uses and returns the fractional width in text eliding

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 51 matching lines @@
   //    tests work might vary per the default font.
   // 2) This specific font helps expose the line width exceeding problem as in
   //    ElideRectangleTextCheckLineWidth.
   font = gfx::Font("LucidaGrande", 12);
 #endif
   return font;
 }
 
 }  // namespace
 
-// TODO(ios): Complex eliding is off by one for some of those tests on iOS.
-// See crbug.com/154019
+// TODO(ios): This test fails on iOS because iOS version of gfx::GetStringWidth
+// that calls [NSString sizeWithFont] returns the rounded string width.
 #if defined(OS_IOS)
 #define MAYBE_ElideEmail DISABLED_ElideEmail
 #else
 #define MAYBE_ElideEmail ElideEmail
 #endif
 TEST(TextEliderTest, MAYBE_ElideEmail) {
   const std::string kEllipsisStr(kEllipsis);
 
   // Test emails and their expected elided forms (from which the available
   // widths will be derived).
@@ skipping 30 matching lines @@
        "noca" + kEllipsisStr + "@no" + kEllipsisStr + "ca"},
       {"at\"@@@@@@@@@...@@.@.@.@@@\"@madness.com",
        "at\"@@@@@@@@@...@@.@." + kEllipsisStr + "@madness.com"},
       // Special case: "m..." takes more than half of the available width; thus
       // 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 gfx::Font font = GetTestingFont();
+  const gfx::Font font;
   for (size_t i = 0; i < arraysize(testcases); ++i) {
     const string16 expected_output = UTF8ToUTF16(testcases[i].output);
-    int available_width = font.GetStringWidth(expected_output);
-#if defined(OS_MACOSX)
-    // Give two extra pixels to offset the ceiling width returned by
-    // GetStringWidth on Mac. This workaround will no longer be needed once
-    // the floating point width is adopted (http://crbug.com/288987).
-    // Note that we need one more pixel than TestFilenameEliding because
-    // multiple strings are elided and we need to offset more.
-    available_width += 2;
-#endif
     EXPECT_EQ(expected_output,
               ElideEmail(UTF8ToUTF16(testcases[i].input),
                          font,
-                         available_width));
+                         font.GetStringWidth(expected_output)));
   }
 }
 
 TEST(TextEliderTest, ElideEmailMoreSpace) {
   const int test_width_factors[] = {
       100,
       10000,
       1000000,
   };
   const std::string test_emails[] = {
@@ skipping 131 matching lines @@
      "C:/" + kEllipsisStr + "/filename"},
 #endif
     {"file://filer/foo/bar/file", "filer/foo/bar/file"},
     {"file://filer/foo/bar/file", "filer/foo/" + kEllipsisStr + "/file"},
     {"file://filer/foo/bar/file", "filer/" + kEllipsisStr + "/file"},
   };
 
   RunUrlTest(testcases, arraysize(testcases));
 }
 
-// TODO(ios): Complex eliding is off by one for some of those tests on iOS.
-// See crbug.com/154019
+// TODO(ios): This test fails on iOS because iOS version of gfx::GetStringWidth
+// that calls [NSString sizeWithFont] returns the rounded string width.
 #if defined(OS_IOS)
 #define MAYBE_TestFilenameEliding DISABLED_TestFilenameEliding
 #else
 #define MAYBE_TestFilenameEliding TestFilenameEliding
 #endif
 TEST(TextEliderTest, MAYBE_TestFilenameEliding) {
   const std::string kEllipsisStr(kEllipsis);
   const base::FilePath::StringType kPathSeparator =
       base::FilePath::StringType().append(1, base::FilePath::kSeparators[0]);
 
@@ skipping 24 matching lines @@
     {FILE_PATH_LITERAL("filename.middleext.longext"),
       "filename.mid" + kEllipsisStr + ".longext"},
     {FILE_PATH_LITERAL("filename.superduperextremelylongext"),
       "filename.sup" + kEllipsisStr + "emelylongext"},
     {FILE_PATH_LITERAL("filenamereallylongtext.superduperextremelylongext"),
       "filenamereall" + kEllipsisStr + "emelylongext"},
     {FILE_PATH_LITERAL("file.name.really.long.text.superduperextremelylongext"),
       "file.name.re" + kEllipsisStr + "emelylongext"}
   };
 
-  static const gfx::Font font = GetTestingFont();
+  static const gfx::Font font;
   for (size_t i = 0; i < arraysize(testcases); ++i) {
     base::FilePath filepath(testcases[i].input);
     string16 expected = UTF8ToUTF16(testcases[i].output);
     expected = base::i18n::GetDisplayStringInLTRDirectionality(expected);
-    int available_width = font.GetStringWidth(UTF8ToUTF16(testcases[i].output));
-#if defined(OS_MACOSX)
-    // Give one extra pixel to offset the ceiling width returned by
-    // GetStringWidth on Mac. This workaround will no longer be needed once
-    // the floating point width is adopted (http://crbug.com/288987).
-    available_width += 1;
-#endif
-    EXPECT_EQ(expected, ElideFilename(filepath, font, available_width));
+    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;
@@ skipping 368 matching lines @@
                                  kAvailableHeight,
                                  cases[i].wrap_behavior,
                                  &lines));
     std::string expected_output(cases[i].output);
     ReplaceSubstringsAfterOffset(&expected_output, 0, "...", kEllipsis);
     const std::string result = UTF16ToUTF8(JoinString(lines, '|'));
     EXPECT_EQ(expected_output, result) << "Case " << i << " failed!";
   }
 }
 
-// TODO(ios): Complex eliding is off by one for some of those tests on iOS.
-// See crbug.com/154019
-#if defined(OS_IOS)
-#define MAYBE_ElideRectangleTextCheckLineWidth \
-    DISABLED_ElideRectangleTextCheckLineWidth
-#else
-#define MAYBE_ElideRectangleTextCheckLineWidth ElideRectangleTextCheckLineWidth
-#endif
-
 // This test is to make sure that the width of each wrapped line does not
 // exceed the available width. On some platform like Mac, this test used to
 // fail because the truncated integer width is returned for the string
 // and the accumulation of the truncated values causes the elide function
 // to wrap incorrectly.
-TEST(TextEliderTest, MAYBE_ElideRectangleTextCheckLineWidth) {
-  gfx::Font font = GetTestingFont();
-  const int kAvailableWidth = 235;
+TEST(TextEliderTest, ElideRectangleTextCheckLineWidth) {
+  gfx::Font font;
+#if defined(OS_MACOSX) && !defined(OS_IOS)
+  // Use a specific font to expose the line width exceeding problem.
+  font = gfx::Font("LucidaGrande", 12);
+#endif
+  const float kAvailableWidth = 235;
   const int kAvailableHeight = 1000;
   const char text[] = "that Russian place we used to go to after fencing";
   std::vector<string16> lines;
   EXPECT_EQ(0, ElideRectangleText(UTF8ToUTF16(text),
                                   font,
                                   kAvailableWidth,
                                   kAvailableHeight,
                                   WRAP_LONG_WORDS,
                                   &lines));
   ASSERT_EQ(2u, lines.size());
@@ skipping 219 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