Remove net dependency from ui/gfx

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"
 
 using base::ASCIIToUTF16;
 using base::UTF16ToUTF8;
 using base::UTF16ToWide;
 using base::UTF8ToUTF16;
 using base::WideToUTF16;
 
 namespace gfx {
 
 namespace {
@@ skipping 12 matching lines @@
   const base::string16 input;
   const base::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 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_list, available_width, std::string()));
-  }
-}
-
 }  // namespace
 
 // 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)
+// TODO(338784): Enable this on android.
+#if defined(OS_IOS) || defined(OS_ANDROID)
 #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).
   // For elided forms in which both the username and domain must be elided:
@@ skipping 40 matching lines @@
   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)));
   }
 }
 
-TEST(TextEliderTest, ElideEmailMoreSpace) {
+// 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));
     }
   }
 }
 
-// Test eliding of commonplace URLs.
-TEST(TextEliderTest, TestGeneralEliding) {
-  const std::string kEllipsisStr(kEllipsis);
-  Testcase testcases[] = {
-    {"http://www.google.com/intl/en/ads/",
-     "www.google.com/intl/en/ads/"},
-    {"http://www.google.com/intl/en/ads/", "www.google.com/intl/en/ads/"},
-    {"http://www.google.com/intl/en/ads/",
-     "google.com/intl/" + kEllipsisStr + "/ads/"},
-    {"http://www.google.com/intl/en/ads/",
-     "google.com/" + kEllipsisStr + "/ads/"},
-    {"http://www.google.com/intl/en/ads/", "google.com/" + kEllipsisStr},
-    {"http://www.google.com/intl/en/ads/", "goog" + kEllipsisStr},
-    {"https://subdomain.foo.com/bar/filename.html",
-     "subdomain.foo.com/bar/filename.html"},
-    {"https://subdomain.foo.com/bar/filename.html",
-     "subdomain.foo.com/" + kEllipsisStr + "/filename.html"},
-    {"http://subdomain.foo.com/bar/filename.html",
-     kEllipsisStr + "foo.com/" + kEllipsisStr + "/filename.html"},
-    {"http://www.google.com/intl/en/ads/?aLongQueryWhichIsNotRequired",
-     "www.google.com/intl/en/ads/?aLongQ" + kEllipsisStr},
-  };
-
-  RunUrlTest(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) {
-  const std::string kEllipsisStr(kEllipsis);
-
-  // Very little space, would cause double ellipsis.
-  FontList font_list;
-  GURL url("http://battersbox.com/directory/foo/peter_paul_and_mary.html");
-  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(GetStringWidthF(UTF8ToUTF16(kEllipsisStr + "/" + kEllipsisStr),
-                            font_list),
-            GetStringWidthF(UTF8ToUTF16("d" + kEllipsisStr), font_list));
-  GURL long_url("http://battersbox.com/directorynameisreallylongtoforcetrunc");
-  base::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_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.
-TEST(TextEliderTest, TestMoreEliding) {
-  const std::string kEllipsisStr(kEllipsis);
-  Testcase testcases[] = {
-    {"http://www.google.com/foo?bar", "www.google.com/foo?bar"},
-    {"http://xyz.google.com/foo?bar", "xyz.google.com/foo?" + kEllipsisStr},
-    {"http://xyz.google.com/foo?bar", "xyz.google.com/foo" + kEllipsisStr},
-    {"http://xyz.google.com/foo?bar", "xyz.google.com/fo" + kEllipsisStr},
-    {"http://a.b.com/pathname/c?d", "a.b.com/" + kEllipsisStr + "/c?d"},
-    {"", ""},
-    {"http://foo.bar..example.com...hello/test/filename.html",
-     "foo.bar..example.com...hello/" + kEllipsisStr + "/filename.html"},
-    {"http://foo.bar../", "foo.bar.."},
-    {"http://xn--1lq90i.cn/foo", "\xe5\x8c\x97\xe4\xba\xac.cn/foo"},
-    {"http://me:mypass@secrethost.com:99/foo?bar#baz",
-     "secrethost.com:99/foo?bar#baz"},
-    {"http://me:mypass@ss%xxfdsf.com/foo", "ss%25xxfdsf.com/foo"},
-    {"mailto:elgoato@elgoato.com", "mailto:elgoato@elgoato.com"},
-    {"javascript:click(0)", "javascript:click(0)"},
-    {"https://chess.eecs.berkeley.edu:4430/login/arbitfilename",
-     "chess.eecs.berkeley.edu:4430/login/arbitfilename"},
-    {"https://chess.eecs.berkeley.edu:4430/login/arbitfilename",
-     kEllipsisStr + "berkeley.edu:4430/" + kEllipsisStr + "/arbitfilename"},
-
-    // Unescaping.
-    {"http://www/%E4%BD%A0%E5%A5%BD?q=%E4%BD%A0%E5%A5%BD#\xe4\xbd\xa0",
-     "www/\xe4\xbd\xa0\xe5\xa5\xbd?q=\xe4\xbd\xa0\xe5\xa5\xbd#\xe4\xbd\xa0"},
-
-    // Invalid unescaping for path. The ref will always be valid UTF-8. We don't
-    // bother to do too many edge cases, since these are handled by the escaper
-    // unittest.
-    {"http://www/%E4%A0%E5%A5%BD?q=%E4%BD%A0%E5%A5%BD#\xe4\xbd\xa0",
-     "www/%E4%A0%E5%A5%BD?q=\xe4\xbd\xa0\xe5\xa5\xbd#\xe4\xbd\xa0"},
-  };
-
-  RunUrlTest(testcases, arraysize(testcases));
-}
-
-// Test eliding of file: URLs.
-TEST(TextEliderTest, TestFileURLEliding) {
-  const std::string kEllipsisStr(kEllipsis);
-  Testcase testcases[] = {
-    {"file:///C:/path1/path2/path3/filename",
-     "file:///C:/path1/path2/path3/filename"},
-    {"file:///C:/path1/path2/path3/filename",
-     "C:/path1/path2/path3/filename"},
-// GURL parses "file:///C:path" differently on windows than it does on posix.
-#if defined(OS_WIN)
-    {"file:///C:path1/path2/path3/filename",
-     "C:/path1/path2/" + kEllipsisStr + "/filename"},
-    {"file:///C:path1/path2/path3/filename",
-     "C:/path1/" + kEllipsisStr + "/filename"},
-    {"file:///C:path1/path2/path3/filename",
-     "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): This test fails on iOS because iOS version of GetStringWidthF
 // that calls [NSString sizeWithFont] returns the rounded string width.
-#if defined(OS_IOS)
+// TODO(338784): Enable this on android.
+#if defined(OS_IOS) || defined(OS_ANDROID)
 #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]);
 
   FileTestcase testcases[] = {
@@ skipping 33 matching lines @@
   static const FontList font_list;
   for (size_t i = 0; i < arraysize(testcases); ++i) {
     base::FilePath filepath(testcases[i].input);
     base::string16 expected = UTF8ToUTF16(testcases[i].output);
     expected = base::i18n::GetDisplayStringInLTRDirectionality(expected);
     EXPECT_EQ(expected, ElideFilename(filepath, font_list,
         GetStringWidthF(UTF8ToUTF16(testcases[i].output), font_list)));
   }
 }
 
-TEST(TextEliderTest, ElideTextTruncate) {
+// TODO(338784): Enable this on android.
+#if defined(OS_ANDROID)
+#define MAYBE_ElideTextTruncate DISABLED_ElideTextTruncate
+#else
+#define MAYBE_ElideTextTruncate ElideTextTruncate
+#endif
+TEST(TextEliderTest, MAYBE_ElideTextTruncate) {
   const FontList font_list;
   const float kTestWidth = GetStringWidthF(ASCIIToUTF16("Test"), font_list);
   struct TestData {
     const char* input;
     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) {
     base::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) {
+// TODO(338784): Enable this on android.
+#if defined(OS_ANDROID)
+#define MAYBE_ElideTextEllipsis DISABLED_ElideTextEllipsis
+#else
+#define MAYBE_ElideTextEllipsis ElideTextEllipsis
+#endif
+TEST(TextEliderTest, MAYBE_ElideTextEllipsis) {
   const FontList font_list;
   const float kTestWidth = GetStringWidthF(ASCIIToUTF16("Test"), font_list);
   const char* kEllipsis = "\xE2\x80\xA6";
   const float kEllipsisWidth =
       GetStringWidthF(UTF8ToUTF16(kEllipsis), font_list);
   struct TestData {
     const char* input;
     float width;
     const char* output;
   } cases[] = {
@@ skipping 24 matching lines @@
     index = text.find_first_of(first_char, index + 1);
   }
   index = text.find_first_of(second_char);
   while (index != base::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) {
+// TODO(338784): Enable this on android.
+#if defined(OS_ANDROID)
+#define MAYBE_ElideTextSurrogatePairs DISABLED_ElideTextSurrogatePairs
+#else
+#define MAYBE_ElideTextSurrogatePairs ElideTextSurrogatePairs
+#endif
+TEST(TextEliderTest, MAYBE_ElideTextSurrogatePairs) {
   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 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);
     CheckSurrogatePairs(result, kSurrogateFirstChar, kSurrogateSecondChar);
 
     result = ElideText(kTestString, font_list, width, ELIDE_AT_END);
     CheckSurrogatePairs(result, kSurrogateFirstChar, kSurrogateSecondChar);
 
     result = ElideText(kTestString, font_list, width, ELIDE_IN_MIDDLE);
     CheckSurrogatePairs(result, kSurrogateFirstChar, kSurrogateSecondChar);
   }
 }
 
-TEST(TextEliderTest, ElideTextLongStrings) {
+// TODO(338784): Enable this on android.
+#if defined(OS_ANDROID)
+#define MAYBE_ElideTextLongStrings DISABLED_ElideTextLongStrings
+#else
+#define MAYBE_ElideTextLongStrings ElideTextLongStrings
+#endif
+TEST(TextEliderTest, MAYBE_ElideTextLongStrings) {
   const base::string16 kEllipsisStr = UTF8ToUTF16(kEllipsis);
   base::string16 data_scheme(UTF8ToUTF16("data:text/plain,"));
   size_t data_scheme_length = data_scheme.length();
 
   base::string16 ten_a(10, 'a');
   base::string16 hundred_a(100, 'a');
   base::string16 thousand_a(1000, 'a');
   base::string16 ten_thousand_a(10000, 'a');
   base::string16 hundred_thousand_a(100000, 'a');
   base::string16 million_a(1000000, 'a');
@@ skipping 47 matching lines @@
                   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_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()));
-}
-
-// Verifies DisplayURL::Compare works correctly.
-TEST(TextEliderTest, SortedDisplayURLCompare) {
-  UErrorCode create_status = U_ZERO_ERROR;
-  scoped_ptr<icu::Collator> collator(
-      icu::Collator::createInstance(create_status));
-  if (!U_SUCCESS(create_status))
-    return;
-
-  TestData tests[] = {
-    // IDN comparison. Hosts equal, so compares on path.
-    { "http://xn--1lq90i.cn/a", "http://xn--1lq90i.cn/b", -1},
-
-    // Because the host and after host match, this compares the full url.
-    { "http://www.x/b", "http://x/b", -1 },
-
-    // Because the host and after host match, this compares the full url.
-    { "http://www.a:1/b", "http://a:1/b", 1 },
-
-    // The hosts match, so these end up comparing on the after host portion.
-    { "http://www.x:0/b", "http://x:1/b", -1 },
-    { "http://www.x/a", "http://x/b", -1 },
-    { "http://x/b", "http://www.x/a", 1 },
-
-    // Trivial Equality.
-    { "http://a/", "http://a/", 0 },
-
-    // Compares just hosts.
-    { "http://www.a/", "http://b/", -1 },
-  };
-
-  for (size_t i = 0; i < arraysize(tests); ++i) {
-    SortedDisplayURL url1(GURL(tests[i].a), std::string());
-    SortedDisplayURL url2(GURL(tests[i].b), std::string());
-    EXPECT_EQ(tests[i].compare_result, url1.Compare(url2, collator.get()));
-    EXPECT_EQ(-tests[i].compare_result, url2.Compare(url1, collator.get()));
-  }
-}
-
 TEST(TextEliderTest, ElideString) {
   struct TestData {
     const char* input;
     int max_len;
     bool result;
     const char* output;
   } cases[] = {
     { "Hello", 0, true, "" },
     { "", 0, false, "" },
     { "Hello, my name is Tom", 1, true, "H" },
     { "Hello, my name is Tom", 2, true, "He" },
     { "Hello, my name is Tom", 3, true, "H.m" },
     { "Hello, my name is Tom", 4, true, "H..m" },
     { "Hello, my name is Tom", 5, true, "H...m" },
     { "Hello, my name is Tom", 6, true, "He...m" },
     { "Hello, my name is Tom", 7, true, "He...om" },
     { "Hello, my name is Tom", 10, true, "Hell...Tom" },
     { "Hello, my name is Tom", 100, false, "Hello, my name is Tom" }
   };
   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(cases); ++i) {
     base::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) {
+// TODO(338784): Enable this on android.
+#if defined(OS_ANDROID)
+#define MAYBE_ElideRectangleText DISABLED_ElideRectangleText
+#else
+#define MAYBE_ElideRectangleText ElideRectangleText
+#endif
+TEST(TextEliderTest, MAYBE_ElideRectangleText) {
   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;
     float available_pixel_width;
     int available_pixel_height;
     bool truncated_y;
     const char* output;
@@ skipping 36 matching lines @@
                                  &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) {
+// TODO(338784): Enable this on android.
+#if defined(OS_ANDROID)
+#define MAYBE_ElideRectangleTextPunctuation \
+    DISABLED_ElideRectangleTextPunctuation
+#else
+#define MAYBE_ElideRectangleTextPunctuation ElideRectangleTextPunctuation
+#endif
+TEST(TextEliderTest, MAYBE_ElideRectangleTextPunctuation) {
   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;
     float available_pixel_width;
     int available_pixel_height;
     bool wrap_words;
@@ skipping 19 matching lines @@
                                  &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) {
+// TODO(338784): Enable this on android.
+#if defined(OS_ANDROID)
+#define MAYBE_ElideRectangleTextLongWords DISABLED_ElideRectangleTextLongWords
+#else
+#define MAYBE_ElideRectangleTextLongWords ElideRectangleTextLongWords
+#endif
+TEST(TextEliderTest, MAYBE_ElideRectangleTextLongWords) {
   const FontList font_list;
   const int kAvailableHeight = 1000;
   const base::string16 kElidedTesting =
       UTF8ToUTF16(std::string("Tes") + kEllipsis);
   const float elided_width = GetStringWidthF(kElidedTesting, font_list);
   const float test_width = GetStringWidthF(ASCIIToUTF16("Test"), font_list);
 
   struct TestData {
     const char* input;
     float available_pixel_width;
@@ skipping 44 matching lines @@
     const std::string result = UTF16ToUTF8(JoinString(lines, '|'));
     EXPECT_EQ(expected_output, result) << "Case " << i << " failed!";
   }
 }
 
 // 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, ElideRectangleTextCheckLineWidth) {
+// TODO(338784): Enable this on android.
+#if defined(OS_ANDROID)
+#define MAYBE_ElideRectangleTextCheckLineWidth \
+    DISABLED_ElideRectangleTextCheckLineWidth
+#else
+#define MAYBE_ElideRectangleTextCheckLineWidth ElideRectangleTextCheckLineWidth
+#endif
+TEST(TextEliderTest, MAYBE_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<base::string16> lines;
   EXPECT_EQ(0, ElideRectangleText(UTF8ToUTF16(text),
@@ skipping 225 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