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"
 #include "base/memory/scoped_ptr.h"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "ui/gfx/font.h"
+#include "ui/gfx/font_list.h"
+#include "ui/gfx/text_utils.h"
 #include "url/gurl.h"
 
 namespace gfx {
 
 namespace {
 
 struct Testcase {
   const std::string input;
   const std::string output;
 };
 
 struct FileTestcase {
   const base::FilePath::StringType input;
   const std::string output;
 };
 
 struct UTF16Testcase {
   const string16 input;
   const string16 output;
 };
 
 struct TestData {
   const std::string a;
   const std::string b;
   const int compare_result;
 };
 
 void RunUrlTest(Testcase* testcases, size_t num_testcases) {
-  static const gfx::Font font;
+  static const FontList font_list;
   for (size_t i = 0; i < num_testcases; ++i) {
     const GURL url(testcases[i].input);
     // Should we test with non-empty language list?
     // That's kinda redundant with net_util_unittests.
+    const float available_width =
+        GetStringWidthF(UTF8ToUTF16(testcases[i].output), font_list);
     EXPECT_EQ(UTF8ToUTF16(testcases[i].output),
-              ElideUrl(url, font,
-                       font.GetStringWidth(UTF8ToUTF16(testcases[i].output)),
-                       std::string()));
+              ElideUrl(url, font_list, available_width, std::string()));
   }
 }
 
-gfx::Font GetTestingFont() {
-  gfx::Font font;
-#if defined(OS_MACOSX)
-  // Use a specific font for certain tests on Mac.
-  // 1) Different Mac machines might be configured with different default font.
-  //    The number of extra pixels needed to make ElideEmail/TestFilenameEliding
-  //    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 GetStringWidthF
+// 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 FontList font_list;
   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));
+              ElideEmail(
+                  UTF8ToUTF16(testcases[i].input),
+                  font_list,
+                  GetStringWidthF(expected_output, font_list)));
   }
 }
 
 TEST(TextEliderTest, 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 gfx::Font font;
+  const Font font;
   for (size_t i = 0; i < arraysize(test_width_factors); ++i) {
     const int test_width = test_width_factors[i] *
                            font.GetAverageCharacterWidth();
     for (size_t j = 0; j < arraysize(test_emails); ++j) {
       // Extra space is available: the email should not be elided.
       const string16 test_email = UTF8ToUTF16(test_emails[j]);
       EXPECT_EQ(test_email, ElideEmail(test_email, font, test_width));
     }
   }
 }
@@ skipping 25 matching lines @@
 }
 
 // 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) {
   const std::string kEllipsisStr(kEllipsis);
 
   // Very little space, would cause double ellipsis.
-  gfx::Font font;
+  FontList font_list;
   GURL url("http://battersbox.com/directory/foo/peter_paul_and_mary.html");
-  int available_width = font.GetStringWidth(
-      UTF8ToUTF16("battersbox.com/" + kEllipsisStr + "/" + kEllipsisStr));
+  float available_width = GetStringWidthF(
+      UTF8ToUTF16("battersbox.com/" + kEllipsisStr + "/" + kEllipsisStr),
+      font_list);
 
   // Create the expected string, after elision. Depending on font size, the
   // directory might become /dir... or /di... or/d... - it never should be
   // shorter than that. (If it is, the font considers d... to be longer
   // than .../... -  that should never happen).
-  ASSERT_GT(font.GetStringWidth(UTF8ToUTF16(kEllipsisStr + "/" + kEllipsisStr)),
-      font.GetStringWidth(UTF8ToUTF16("d" + kEllipsisStr)));
+  ASSERT_GT(GetStringWidthF(UTF8ToUTF16(kEllipsisStr + "/" + kEllipsisStr),
+                            font_list),
+            GetStringWidthF(UTF8ToUTF16("d" + kEllipsisStr), font_list));
   GURL long_url("http://battersbox.com/directorynameisreallylongtoforcetrunc");
-  string16 expected = ElideUrl(long_url, font, available_width, std::string());
+  string16 expected =
+      ElideUrl(long_url, font_list, available_width, std::string());
   // Ensure that the expected result still contains part of the directory name.
   ASSERT_GT(expected.length(), std::string("battersbox.com/d").length());
   EXPECT_EQ(expected,
-             ElideUrl(url, font, available_width, std::string()));
+             ElideUrl(url, font_list, available_width, std::string()));
 
   // More space available - elide directories, partially elide filename.
   Testcase testcases[] = {
     {"http://battersbox.com/directory/foo/peter_paul_and_mary.html",
      "battersbox.com/" + kEllipsisStr + "/peter" + kEllipsisStr},
   };
   RunUrlTest(testcases, arraysize(testcases));
 }
 
 // Test eliding of empty strings, URLs with ports, passwords, queries, etc.
@@ skipping 52 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 GetStringWidthF
+// 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 FontList font_list;
   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_list,
+        GetStringWidthF(UTF8ToUTF16(testcases[i].output), font_list)));
   }
 }
 
 TEST(TextEliderTest, ElideTextTruncate) {
-  const gfx::Font font;
-  const int kTestWidth = font.GetStringWidth(ASCIIToUTF16("Test"));
+  const FontList font_list;
+  const float kTestWidth = GetStringWidthF(ASCIIToUTF16("Test"), font_list);
   struct TestData {
     const char* input;
-    int width;
+    float 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 = ElideText(UTF8ToUTF16(cases[i].input), font,
+    string16 result = ElideText(UTF8ToUTF16(cases[i].input), font_list,
                                 cases[i].width, TRUNCATE_AT_END);
     EXPECT_EQ(cases[i].output, UTF16ToUTF8(result));
   }
 }
 
 TEST(TextEliderTest, ElideTextEllipsis) {
-  const gfx::Font font;
-  const int kTestWidth = font.GetStringWidth(ASCIIToUTF16("Test"));
+  const FontList font_list;
+  const float kTestWidth = GetStringWidthF(ASCIIToUTF16("Test"), font_list);
   const char* kEllipsis = "\xE2\x80\xA6";
-  const int kEllipsisWidth = font.GetStringWidth(UTF8ToUTF16(kEllipsis));
+  const float kEllipsisWidth =
+      GetStringWidthF(UTF8ToUTF16(kEllipsis), font_list);
   struct TestData {
     const char* input;
-    int width;
+    float width;
     const char* output;
   } cases[] = {
     { "", 0, "" },
     { "Test", 0, "" },
     { "Test", kEllipsisWidth, kEllipsis },
     { "", kTestWidth, "" },
     { "Tes", kTestWidth, "Tes" },
     { "Test", kTestWidth, "Test" },
   };
 
   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(cases); ++i) {
-    string16 result = ElideText(UTF8ToUTF16(cases[i].input), font,
+    string16 result = ElideText(UTF8ToUTF16(cases[i].input), font_list,
                                 cases[i].width, ELIDE_AT_END);
     EXPECT_EQ(cases[i].output, UTF16ToUTF8(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 string16& text,
                                 char16 first_char,
                                 char16 second_char) {
   size_t index = text.find_first_of(first_char);
   while (index != string16::npos) {
     EXPECT_LT(index, text.length() - 1);
     EXPECT_EQ(second_char, text[index + 1]);
     index = text.find_first_of(first_char, index + 1);
   }
   index = text.find_first_of(second_char);
   while (index != string16::npos) {
     EXPECT_GT(index, 0U);
     EXPECT_EQ(first_char, text[index - 1]);
     index = text.find_first_of(second_char, index + 1);
   }
 }
 
 TEST(TextEliderTest, ElideTextSurrogatePairs) {
-  const gfx::Font font;
+  const FontList font_list;
   // The below is 'MUSICAL SYMBOL G CLEF', which is represented in UTF-16 as
   // two characters forming a surrogate pair 0x0001D11E.
   const std::string kSurrogate = "\xF0\x9D\x84\x9E";
   const string16 kTestString =
       UTF8ToUTF16(kSurrogate + "ab" + kSurrogate + kSurrogate + "cd");
-  const int kTestStringWidth = font.GetStringWidth(kTestString);
+  const float kTestStringWidth = GetStringWidthF(kTestString, font_list);
   const char16 kSurrogateFirstChar = kTestString[0];
   const char16 kSurrogateSecondChar = kTestString[1];
   string16 result;
 
   // Elide |kTextString| to all possible widths and check that no instance of
   // |kSurrogate| was split in two.
-  for (int width = 0; width <= kTestStringWidth; width++) {
-    result = ElideText(kTestString, font, width, TRUNCATE_AT_END);
+  for (float width = 0; width <= kTestStringWidth; width++) {
+    result = ElideText(kTestString, font_list, width, TRUNCATE_AT_END);
     CheckSurrogatePairs(result, kSurrogateFirstChar, kSurrogateSecondChar);
 
-    result = ElideText(kTestString, font, width, ELIDE_AT_END);
+    result = ElideText(kTestString, font_list, width, ELIDE_AT_END);
     CheckSurrogatePairs(result, kSurrogateFirstChar, kSurrogateSecondChar);
 
-    result = ElideText(kTestString, font, width, ELIDE_IN_MIDDLE);
+    result = ElideText(kTestString, font_list, width, ELIDE_IN_MIDDLE);
     CheckSurrogatePairs(result, kSurrogateFirstChar, kSurrogateSecondChar);
   }
 }
 
 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');
   string16 million_a(1000000, 'a');
 
   size_t number_of_as = 156;
   string16 long_string_end(
       data_scheme + string16(number_of_as, 'a') + kEllipsisStr);
   UTF16Testcase testcases_end[] = {
      {data_scheme + ten_a,              data_scheme + ten_a},
      {data_scheme + hundred_a,          data_scheme + hundred_a},
      {data_scheme + thousand_a,         long_string_end},
      {data_scheme + ten_thousand_a,     long_string_end},
      {data_scheme + hundred_thousand_a, long_string_end},
      {data_scheme + million_a,          long_string_end},
   };
 
-  const gfx::Font font;
-  int ellipsis_width = font.GetStringWidth(kEllipsisStr);
+  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,
-                        font.GetStringWidth(testcases_end[i].output),
-                        ELIDE_AT_END).size());
+              ElideText(
+                  testcases_end[i].input,
+                  font_list,
+                  GetStringWidthF(testcases_end[i].output, font_list),
+                  ELIDE_AT_END).size());
     EXPECT_EQ(kEllipsisStr,
-              ElideText(testcases_end[i].input, font, ellipsis_width,
+              ElideText(testcases_end[i].input, font_list, ellipsis_width,
                         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),
-                        ELIDE_AT_END).size());
+              ElideText(
+                  testcases_middle[i].input,
+                  font_list,
+                  GetStringWidthF(testcases_middle[i].output, font_list),
+                  ELIDE_AT_END).size());
     EXPECT_EQ(kEllipsisStr,
-              ElideText(testcases_middle[i].input, font, ellipsis_width,
+              ElideText(testcases_middle[i].input, font_list, ellipsis_width,
                         ELIDE_AT_END));
   }
 }
 
 // Verifies display_url is set correctly.
 TEST(TextEliderTest, SortedDisplayURL) {
   SortedDisplayURL d_url(GURL("http://www.google.com"), std::string());
   EXPECT_EQ("www.google.com", UTF16ToASCII(d_url.display_url()));
 }
 
@@ skipping 57 matching lines @@
   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(cases); ++i) {
     string16 output;
     EXPECT_EQ(cases[i].result,
               ElideString(UTF8ToUTF16(cases[i].input),
                           cases[i].max_len, &output));
     EXPECT_EQ(cases[i].output, UTF16ToUTF8(output));
   }
 }
 
 TEST(TextEliderTest, ElideRectangleText) {
-  const gfx::Font font;
-  const int line_height = font.GetHeight();
-  const int test_width = font.GetStringWidth(ASCIIToUTF16("Test"));
+  const FontList font_list;
+  const int line_height = font_list.GetHeight();
+  const float test_width = GetStringWidthF(ASCIIToUTF16("Test"), font_list);
 
   struct TestData {
     const char* input;
-    int available_pixel_width;
+    float available_pixel_width;
     int available_pixel_height;
     bool truncated_y;
     const char* output;
   } cases[] = {
     { "", 0, 0, false, NULL },
     { "", 1, 1, false, NULL },
     { "Test", test_width, 0, true, NULL },
     { "Test", test_width, 1, false, "Test" },
     { "Test", test_width, line_height, false, "Test" },
     { "Test Test", test_width, line_height, true, "Test" },
@@ skipping 15 matching lines @@
     { "Test\n\nTest\n", 2 * test_width, line_height * 5, false, "Test||Test|" },
     { "Test\n\n\nTest", 2 * test_width, line_height * 5, false, "Test|||Test" },
     { "Te ", test_width, line_height, false, "Te" },
     { "Te  Te Test", test_width, 3 * line_height, false, "Te|Te|Test" },
   };
 
   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(cases); ++i) {
     std::vector<string16> lines;
     EXPECT_EQ(cases[i].truncated_y ? INSUFFICIENT_SPACE_VERTICAL : 0,
               ElideRectangleText(UTF8ToUTF16(cases[i].input),
-                                 font,
+                                 font_list,
                                  cases[i].available_pixel_width,
                                  cases[i].available_pixel_height,
                                  TRUNCATE_LONG_WORDS,
                                  &lines));
     if (cases[i].output) {
       const std::string result = UTF16ToUTF8(JoinString(lines, '|'));
       EXPECT_EQ(cases[i].output, result) << "Case " << i << " failed!";
     } else {
       EXPECT_TRUE(lines.empty()) << "Case " << i << " failed!";
     }
   }
 }
 
 TEST(TextEliderTest, ElideRectangleTextPunctuation) {
-  const gfx::Font font;
-  const int line_height = font.GetHeight();
-  const int test_width = font.GetStringWidth(ASCIIToUTF16("Test"));
-  const int test_t_width = font.GetStringWidth(ASCIIToUTF16("Test T"));
+  const FontList font_list;
+  const int line_height = font_list.GetHeight();
+  const float test_width = GetStringWidthF(ASCIIToUTF16("Test"), font_list);
+  const float test_t_width = GetStringWidthF(ASCIIToUTF16("Test T"), font_list);
 
   struct TestData {
     const char* input;
-    int available_pixel_width;
+    float available_pixel_width;
     int available_pixel_height;
     bool wrap_words;
     bool truncated_x;
     const char* output;
   } cases[] = {
     { "Test T.", test_t_width, line_height * 2, false, false, "Test|T." },
     { "Test T ?", test_t_width, line_height * 2, false, false, "Test|T ?" },
     { "Test. Test", test_width, line_height * 3, false, true, "Test|Test" },
     { "Test. Test", test_width, line_height * 3, true, false, "Test|.|Test" },
   };
 
   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(cases); ++i) {
     std::vector<string16> lines;
     const WordWrapBehavior wrap_behavior =
         (cases[i].wrap_words ? WRAP_LONG_WORDS : TRUNCATE_LONG_WORDS);
     EXPECT_EQ(cases[i].truncated_x ? INSUFFICIENT_SPACE_HORIZONTAL : 0,
               ElideRectangleText(UTF8ToUTF16(cases[i].input),
-                                 font,
+                                 font_list,
                                  cases[i].available_pixel_width,
                                  cases[i].available_pixel_height,
                                  wrap_behavior,
                                  &lines));
     if (cases[i].output) {
       const std::string result = UTF16ToUTF8(JoinString(lines, '|'));
       EXPECT_EQ(cases[i].output, result) << "Case " << i << " failed!";
     } else {
       EXPECT_TRUE(lines.empty()) << "Case " << i << " failed!";
     }
   }
 }
 
 TEST(TextEliderTest, ElideRectangleTextLongWords) {
-  const gfx::Font font;
+  const FontList font_list;
   const int kAvailableHeight = 1000;
   const string16 kElidedTesting = UTF8ToUTF16(std::string("Tes") + kEllipsis);
-  const int elided_width = font.GetStringWidth(kElidedTesting);
-  const int test_width = font.GetStringWidth(ASCIIToUTF16("Test"));
+  const float elided_width = GetStringWidthF(kElidedTesting, font_list);
+  const float test_width = GetStringWidthF(ASCIIToUTF16("Test"), font_list);
 
   struct TestData {
     const char* input;
-    int available_pixel_width;
+    float available_pixel_width;
     WordWrapBehavior wrap_behavior;
     bool truncated_x;
     const char* output;
   } cases[] = {
     { "Testing", test_width, IGNORE_LONG_WORDS, false, "Testing" },
     { "X Testing", test_width, IGNORE_LONG_WORDS, false, "X|Testing" },
     { "Test Testing", test_width, IGNORE_LONG_WORDS, false, "Test|Testing" },
     { "Test\nTesting", test_width, IGNORE_LONG_WORDS, false, "Test|Testing" },
     { "Test Tests ", test_width, IGNORE_LONG_WORDS, false, "Test|Tests" },
     { "Test Tests T", test_width, IGNORE_LONG_WORDS, false, "Test|Tests|T" },
@@ skipping 17 matching lines @@
     { "Test Tests ", test_width, WRAP_LONG_WORDS, false, "Test|Test|s" },
     { "Test Tests T", test_width, WRAP_LONG_WORDS, false, "Test|Test|s T" },
     { "TestTestTest", test_width, WRAP_LONG_WORDS, false, "Test|Test|Test" },
     { "TestTestTestT", test_width, WRAP_LONG_WORDS, false, "Test|Test|Test|T" },
   };
 
   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(cases); ++i) {
     std::vector<string16> lines;
     EXPECT_EQ(cases[i].truncated_x ? INSUFFICIENT_SPACE_HORIZONTAL : 0,
               ElideRectangleText(UTF8ToUTF16(cases[i].input),
-                                 font,
+                                 font_list,
                                  cases[i].available_pixel_width,
                                  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) {
+  FontList font_list;
+#if defined(OS_MACOSX) && !defined(OS_IOS)
+  // Use a specific font to expose the line width exceeding problem.
+  font_list = FontList(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,
+                                  font_list,
                                   kAvailableWidth,
                                   kAvailableHeight,
                                   WRAP_LONG_WORDS,
                                   &lines));
   ASSERT_EQ(2u, lines.size());
-  EXPECT_LE(font.GetStringWidth(lines[0]), kAvailableWidth);
-  EXPECT_LE(font.GetStringWidth(lines[1]), kAvailableWidth);
+  EXPECT_LE(GetStringWidthF(lines[0], font_list), kAvailableWidth);
+  EXPECT_LE(GetStringWidthF(lines[1], font_list), kAvailableWidth);
 }
 
 TEST(TextEliderTest, ElideRectangleString) {
   struct TestData {
     const char* input;
     int max_rows;
     int max_cols;
     bool result;
     const char* output;
   } cases[] = {
@@ skipping 207 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