Move text_elider from app/gfx to app/

TBR=darin
BUG=none
TEST=none


git-svn-id: svn://svn.chromium.org/chrome/trunk/src@42090 0039d316-1c4b-4281-b951-d872f2087c98

3 files changed, 0 insertions, 779 deletions

diff --git a/app/gfx/text_elider.cc b/app/gfx/text_elider.cc
deleted file mode 100644
index c96c731..0000000
--- a/app/gfx/text_elider.cc
+++ /dev/null
@@ -1,422 +0,0 @@
-// Copyright (c) 2009 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 <vector>
-
-#include "app/gfx/font.h"
-#include "app/gfx/text_elider.h"
-#include "app/l10n_util.h"
-#include "base/file_path.h"
-#include "base/string_util.h"
-#include "base/sys_string_conversions.h"
-#include "base/utf_string_conversions.h"
-#include "googleurl/src/gurl.h"
-#include "net/base/escape.h"
-#include "net/base/net_util.h"
-#include "net/base/registry_controlled_domain.h"
-
-const wchar_t kEllipsis[] = L"\x2026";
-
-namespace gfx {
-
-// This function takes a GURL object and elides it. It returns a string
-// which composed of parts from subdomain, domain, path, filename and query.
-// A "..." is added automatically at the end if the elided string is bigger
-// than the available pixel width. For available pixel width = 0, a formatted,
-// but un-elided, string is returned.
-//
-// TODO(pkasting): http://b/119635 This whole function gets
-// kerning/ligatures/etc. issues potentially wrong by assuming that the width of
-// a rendered string is always the sum of the widths of its substrings.  Also I
-// suspect it could be made simpler.
-std::wstring ElideUrl(const GURL& url,
-                      const gfx::Font& font,
-                      int available_pixel_width,
-                      const std::wstring& languages) {
-  // Get a formatted string and corresponding parsing of the url.
-  url_parse::Parsed parsed;
-  std::wstring url_string = net::FormatUrl(url, languages, true,
-      UnescapeRule::SPACES, &parsed, NULL, NULL);
-  if (available_pixel_width <= 0)
-    return url_string;
-
-  // If non-standard or not file type, return plain eliding.
-  if (!(url.SchemeIsFile() || url.IsStandard()))
-    return ElideText(url_string, font, available_pixel_width);
-
-  // Now start eliding url_string to fit within available pixel width.
-  // Fist pass - check to see whether entire url_string fits.
-  int pixel_width_url_string = font.GetStringWidth(url_string);
-  if (available_pixel_width >= pixel_width_url_string)
-    return url_string;
-
-  // Get the path substring, including query and reference.
-  size_t path_start_index = parsed.path.begin;
-  size_t path_len = parsed.path.len;
-  std::wstring url_path_query_etc = url_string.substr(path_start_index);
-  std::wstring url_path = url_string.substr(path_start_index, path_len);
-
-  // Return general elided text if url minus the query fits.
-  std::wstring url_minus_query = url_string.substr(0, path_start_index +
-      path_len);
-  if (available_pixel_width >= font.GetStringWidth(url_minus_query))
-    return ElideText(url_string, font, available_pixel_width);
-
-  // Get Host.
-  std::wstring url_host = UTF8ToWide(url.host());
-
-  // Get domain and registry information from the URL.
-  std::wstring url_domain = UTF8ToWide(
-      net::RegistryControlledDomainService::GetDomainAndRegistry(url));
-  if (url_domain.empty())
-    url_domain = url_host;
-
-  // Add port if required.
-  if (!url.port().empty()) {
-    url_host += L":" + UTF8ToWide(url.port());
-    url_domain += L":" + UTF8ToWide(url.port());
-  }
-
-  // Get sub domain.
-  std::wstring url_subdomain;
-  size_t domain_start_index = url_host.find(url_domain);
-  if (domain_start_index > 0)
-    url_subdomain = url_host.substr(0, domain_start_index);
-  if ((url_subdomain == L"www." || url_subdomain.empty() ||
-      url.SchemeIsFile())) {
-    url_subdomain.clear();
-  }
-
-  // If this is a file type, the path is now defined as everything after ":".
-  // For example, "C:/aa/aa/bb", the path is "/aa/bb/cc". Interesting, the
-  // domain is now C: - this is a nice hack for eliding to work pleasantly.
-  if (url.SchemeIsFile()) {
-    // Split the path string using ":"
-    std::vector<std::wstring> file_path_split;
-    SplitString(url_path, L':', &file_path_split);
-    if (file_path_split.size() > 1) {  // File is of type "file:///C:/.."
-      url_host.clear();
-      url_domain.clear();
-      url_subdomain.clear();
-
-      url_host = url_domain = file_path_split.at(0).substr(1) + L":";
-      url_path_query_etc = url_path = file_path_split.at(1);
-    }
-  }
-
-  // Second Pass - remove scheme - the rest fits.
-  int pixel_width_url_host = font.GetStringWidth(url_host);
-  int pixel_width_url_path = font.GetStringWidth(url_path_query_etc);
-  if (available_pixel_width >=
-      pixel_width_url_host + pixel_width_url_path)
-    return url_host + url_path_query_etc;
-
-  // Third Pass: Subdomain, domain and entire path fits.
-  int pixel_width_url_domain = font.GetStringWidth(url_domain);
-  int pixel_width_url_subdomain = font.GetStringWidth(url_subdomain);
-  if (available_pixel_width >=
-      pixel_width_url_subdomain + pixel_width_url_domain +
-      pixel_width_url_path)
-    return url_subdomain + url_domain + url_path_query_etc;
-
-  // Query element.
-  std::wstring url_query;
-  const int pixel_width_dots_trailer = font.GetStringWidth(kEllipsis);
-  if (parsed.query.is_nonempty()) {
-    url_query = std::wstring(L"?") + url_string.substr(parsed.query.begin);
-    if (available_pixel_width >= (pixel_width_url_subdomain +
-        pixel_width_url_domain + pixel_width_url_path -
-        font.GetStringWidth(url_query))) {
-      return ElideText(url_subdomain + url_domain + url_path_query_etc, font,
-                       available_pixel_width);
-    }
-  }
-
-  // Parse url_path using '/'.
-  std::vector<std::wstring> url_path_elements;
-  SplitString(url_path, L'/', &url_path_elements);
-
-  // Get filename - note that for a path ending with /
-  // such as www.google.com/intl/ads/, the file name is ads/.
-  int url_path_number_of_elements = static_cast<int> (url_path_elements.
-                                                      size());
-  std::wstring url_filename;
-  if ((url_path_elements.at(url_path_number_of_elements - 1)).length() > 0) {
-    url_filename = *(url_path_elements.end()-1);
-  } else if (url_path_number_of_elements > 1) {  // Path ends with a '/'.
-    url_filename = url_path_elements.at(url_path_number_of_elements - 2) +
-        L'/';
-    url_path_number_of_elements--;
-  }
-
-  const int kMaxNumberOfUrlPathElementsAllowed = 1024;
-  if (url_path_number_of_elements <= 1 ||
-      url_path_number_of_elements > kMaxNumberOfUrlPathElementsAllowed) {
-    // No path to elide, or too long of a path (could overflow in loop below)
-    // Just elide this as a text string.
-    return ElideText(url_subdomain + url_domain + url_path_query_etc, font,
-                     available_pixel_width);
-  }
-
-  // Start eliding the path and replacing elements by "../".
-  std::wstring an_ellipsis_and_a_slash(kEllipsis);
-  an_ellipsis_and_a_slash += L'/';
-  int pixel_width_url_filename = font.GetStringWidth(url_filename);
-  int pixel_width_dot_dot_slash = font.GetStringWidth(an_ellipsis_and_a_slash);
-  int pixel_width_slash = font.GetStringWidth(L"/");
-  int pixel_width_url_path_elements[kMaxNumberOfUrlPathElementsAllowed];
-  for (int i = 0; i < url_path_number_of_elements; ++i) {
-    pixel_width_url_path_elements[i] =
-       font.GetStringWidth(url_path_elements.at(i));
-  }
-
-  // Check with both subdomain and domain.
-  std::wstring elided_path;
-  int pixel_width_elided_path;
-  for (int i = url_path_number_of_elements - 1; i >= 1; --i) {
-    // Add the initial elements of the path.
-    elided_path.clear();
-    pixel_width_elided_path = 0;
-    for (int j = 0; j < i; ++j) {
-      elided_path += url_path_elements.at(j) + L'/';
-      pixel_width_elided_path += pixel_width_url_path_elements[j] +
-          pixel_width_slash;
-    }
-
-    // Add url_file_name.
-    if (i == (url_path_number_of_elements - 1)) {
-      elided_path += url_filename;
-      pixel_width_elided_path += pixel_width_url_filename;
-    } else {
-      elided_path += an_ellipsis_and_a_slash + url_filename;
-      pixel_width_elided_path += pixel_width_dot_dot_slash +
-          pixel_width_url_filename;
-    }
-
-    if (available_pixel_width >=
-        pixel_width_url_subdomain + pixel_width_url_domain +
-        pixel_width_elided_path) {
-      return ElideText(url_subdomain + url_domain + elided_path + url_query,
-                       font, available_pixel_width);
-    }
-  }
-
-  // Check with only domain.
-  // If a subdomain is present, add an ellipsis before domain.
-  // This is added only if the subdomain pixel width is larger than
-  // the pixel width of kEllipsis. Otherwise, subdomain remains,
-  // which means that this case has been resolved earlier.
-  std::wstring url_elided_domain = url_subdomain + url_domain;
-  int pixel_width_url_elided_domain = pixel_width_url_domain;
-  if (pixel_width_url_subdomain > pixel_width_dots_trailer) {
-    if (!url_subdomain.empty()) {
-      url_elided_domain = kEllipsis + url_domain;
-      pixel_width_url_elided_domain += pixel_width_dots_trailer;
-    } else {
-      url_elided_domain = url_domain;
-    }
-
-    for (int i = url_path_number_of_elements - 1; i >= 1; --i) {
-      // Add the initial elements of the path.
-      elided_path.clear();
-      pixel_width_elided_path = 0;
-      for (int j = 0; j < i; ++j) {
-        elided_path += url_path_elements.at(j) + L'/';
-        pixel_width_elided_path += pixel_width_url_path_elements[j] +
-            pixel_width_slash;
-      }
-
-      // Add url_file_name.
-      if (i == (url_path_number_of_elements - 1)) {
-        elided_path += url_filename;
-        pixel_width_elided_path += pixel_width_url_filename;
-      } else {
-        elided_path += an_ellipsis_and_a_slash + url_filename;
-        pixel_width_elided_path += pixel_width_dot_dot_slash +
-            pixel_width_url_filename;
-      }
-
-      if (available_pixel_width >=
-          pixel_width_url_elided_domain + pixel_width_elided_path) {
-        return ElideText(url_elided_domain + elided_path + url_query, font,
-                         available_pixel_width);
-      }
-    }
-  }
-
-  // Return elided domain/../filename anyway.
-  std::wstring final_elided_url_string(url_elided_domain);
-  if ((available_pixel_width - font.GetStringWidth(url_elided_domain)) >
-      pixel_width_dot_dot_slash + pixel_width_dots_trailer +
-      font.GetStringWidth(L"UV"))  // A hack to prevent trailing "../...".
-    final_elided_url_string += elided_path;
-  else
-    final_elided_url_string += url_path;
-
-  return ElideText(final_elided_url_string, font, available_pixel_width);
-}
-
-std::wstring ElideFilename(const FilePath& filename,
-                           const gfx::Font& font,
-                           int available_pixel_width) {
-  int full_width = font.GetStringWidth(filename.ToWStringHack());
-  if (full_width <= available_pixel_width) {
-    std::wstring elided_name = filename.ToWStringHack();
-    return l10n_util::GetDisplayStringInLTRDirectionality(&elided_name);
-  }
-
-#if defined(OS_WIN)
-  std::wstring extension = filename.Extension();
-#elif defined(OS_POSIX)
-  std::wstring extension = base::SysNativeMBToWide(filename.Extension());
-#endif
-  std::wstring rootname =
-      filename.BaseName().RemoveExtension().ToWStringHack();
-
-  if (rootname.empty() || extension.empty()) {
-    std::wstring elided_name = ElideText(filename.ToWStringHack(), font,
-                                         available_pixel_width);
-    return l10n_util::GetDisplayStringInLTRDirectionality(&elided_name);
-  }
-
-  int ext_width = font.GetStringWidth(extension);
-  int root_width = font.GetStringWidth(rootname);
-
-  // We may have trimmed the path.
-  if (root_width + ext_width <= available_pixel_width) {
-    std::wstring elided_name = rootname + extension;
-    return l10n_util::GetDisplayStringInLTRDirectionality(&elided_name);
-  }
-
-  int available_root_width = available_pixel_width - ext_width;
-  std::wstring elided_name = ElideText(rootname, font, available_root_width);
-  elided_name += extension;
-  return l10n_util::GetDisplayStringInLTRDirectionality(&elided_name);
-}
-
-// This function adds an ellipsis at the end of the text if the text
-// does not fit the given pixel width.
-std::wstring ElideText(const std::wstring& text,
-                       const gfx::Font& font,
-                       int available_pixel_width) {
-  if (text.empty())
-    return text;
-
-  int current_text_pixel_width = font.GetStringWidth(text);
-
-  // Pango will return 0 width for absurdly long strings. Cut the string in
-  // half and try again.
-  // This is caused by an int overflow in Pango (specifically, in
-  // pango_glyph_string_extents_range). It's actually more subtle than just
-  // returning 0, since on super absurdly long strings, the int can wrap and
-  // return positive numbers again. Detecting that is probably not worth it
-  // (eliding way too much from a ridiculous string is probably still
-  // ridiculous), but we should check other widths for bogus values as well.
-  if (current_text_pixel_width <= 0 && !text.empty()) {
-    return ElideText(text.substr(0, text.length() / 2), font,
-                     available_pixel_width);
-  }
-
-  if (current_text_pixel_width <= available_pixel_width)
-    return text;
-
-  if (font.GetStringWidth(kEllipsis) > available_pixel_width)
-    return std::wstring();
-
-  // Use binary search to compute the elided text.
-  size_t lo = 0;
-  size_t hi = text.length() - 1;
-  size_t guess = hi / 2;
-  while (lo < hi) {
-    // We check the length of the whole desired string at once to ensure we
-    // handle kerning/ligatures/etc. correctly.
-    std::wstring guess_str = text.substr(0, guess) + kEllipsis;
-    int guess_length = font.GetStringWidth(guess_str);
-    // Check again that we didn't hit a Pango width overflow. If so, cut the
-    // current string in half and start over.
-    if (guess_length <= 0) {
-      return ElideText(guess_str.substr(0, guess_str.length() / 2), font,
-                       available_pixel_width);
-    }
-    if (guess_length > available_pixel_width) {
-      if (hi == guess)
-        break;
-      hi = guess;
-    } else {
-      if (lo == guess)
-        break;
-      lo = guess;
-    }
-    guess = (lo + hi) / 2;
-  }
-
-  return text.substr(0, lo) + kEllipsis;
-}
-
-SortedDisplayURL::SortedDisplayURL(const GURL& url,
-                                   const std::wstring& languages) {
-  std::wstring host;
-  net::AppendFormattedHost(url, languages, &host, NULL, NULL);
-  sort_host_ = WideToUTF16Hack(host);
-  string16 host_minus_www = WideToUTF16Hack(net::StripWWW(host));
-  url_parse::Parsed parsed;
-  display_url_ = WideToUTF16Hack(net::FormatUrl(url, languages,
-      true, UnescapeRule::SPACES, &parsed, &prefix_end_, NULL));
-  if (sort_host_.length() > host_minus_www.length()) {
-    prefix_end_ += sort_host_.length() - host_minus_www.length();
-    sort_host_.swap(host_minus_www);
-  }
-}
-
-int SortedDisplayURL::Compare(const SortedDisplayURL& other,
-                              icu::Collator* collator) const {
-  // Compare on hosts first. The host won't contain 'www.'.
-  UErrorCode compare_status = U_ZERO_ERROR;
-  UCollationResult host_compare_result = collator->compare(
-      static_cast<const UChar*>(sort_host_.c_str()),
-      static_cast<int>(sort_host_.length()),
-      static_cast<const UChar*>(other.sort_host_.c_str()),
-      static_cast<int>(other.sort_host_.length()),
-      compare_status);
-  DCHECK(U_SUCCESS(compare_status));
-  if (host_compare_result != 0)
-    return host_compare_result;
-
-  // Hosts match, compare on the portion of the url after the host.
-  string16 path = this->AfterHost();
-  string16 o_path = other.AfterHost();
-  compare_status = U_ZERO_ERROR;
-  UCollationResult path_compare_result = collator->compare(
-      static_cast<const UChar*>(path.c_str()),
-      static_cast<int>(path.length()),
-      static_cast<const UChar*>(o_path.c_str()),
-      static_cast<int>(o_path.length()),
-      compare_status);
-  DCHECK(U_SUCCESS(compare_status));
-  if (path_compare_result != 0)
-    return path_compare_result;
-
-  // Hosts and paths match, compare on the complete url. This'll push the www.
-  // ones to the end.
-  compare_status = U_ZERO_ERROR;
-  UCollationResult display_url_compare_result = collator->compare(
-      static_cast<const UChar*>(display_url_.c_str()),
-      static_cast<int>(display_url_.length()),
-      static_cast<const UChar*>(other.display_url_.c_str()),
-      static_cast<int>(other.display_url_.length()),
-      compare_status);
-  DCHECK(U_SUCCESS(compare_status));
-  return display_url_compare_result;
-}
-
-string16 SortedDisplayURL::AfterHost() const {
-  size_t slash_index = display_url_.find(sort_host_, prefix_end_);
-  if (slash_index == string16::npos) {
-    NOTREACHED();
-    return string16();
-  }
-  return display_url_.substr(slash_index + sort_host_.length());
-}
-
-}  // namespace gfx.
diff --git a/app/gfx/text_elider.h b/app/gfx/text_elider.h
deleted file mode 100644
index aa33c29..0000000
--- a/app/gfx/text_elider.h
+++ /dev/null
@@ -1,87 +0,0 @@
-// Copyright (c) 2006-2008 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.
-
-#ifndef APP_GFX_TEXT_ELIDER_H_
-#define APP_GFX_TEXT_ELIDER_H_
-
-#include <unicode/coll.h>
-#include <unicode/uchar.h>
-
-#include "app/gfx/font.h"
-#include "base/basictypes.h"
-#include "base/string16.h"
-
-class FilePath;
-class GURL;
-
-// TODO(port): this file should deal in string16s rather than wstrings.
-namespace gfx {
-
-// This function takes a GURL object and elides it. It returns a string
-// which composed of parts from subdomain, domain, path, filename and query.
-// A "..." is added automatically at the end if the elided string is bigger
-// than the available pixel width. For available pixel width = 0, empty
-// string is returned. |languages| is a comma separted list of ISO 639
-// language codes and is used to determine what characters are understood
-// by a user. It should come from |prefs::kAcceptLanguages|.
-//
-// Note: in RTL locales, if the URL returned by this function is going to be
-// displayed in the UI, then it is likely that the string needs to be marked
-// as an LTR string (using l10n_util::WrapStringWithLTRFormatting()) so that it
-// is displayed properly in an RTL context. Please refer to
-// http://crbug.com/6487 for more information.
-std::wstring ElideUrl(const GURL& url,
-                      const gfx::Font& font,
-                      int available_pixel_width,
-                      const std::wstring& languages);
-
-std::wstring ElideText(const std::wstring& text,
-                       const gfx::Font& font,
-                       int available_pixel_width);
-
-// Elide a filename to fit a given pixel width, with an emphasis on not hiding
-// the extension unless we have to. If filename contains a path, the path will
-// be removed if filename doesn't fit into available_pixel_width. The elided
-// filename is forced to have LTR directionality, which means that in RTL UI
-// the elided filename is wrapped with LRE (Left-To-Right Embedding) mark and
-// PDF (Pop Directional Formatting) mark.
-std::wstring ElideFilename(const FilePath& filename,
-                           const gfx::Font& font,
-                           int available_pixel_width);
-
-// SortedDisplayURL maintains a string from a URL suitable for display to the
-// use. SortedDisplayURL also provides a function used for comparing two
-// SortedDisplayURLs for use in visually ordering the SortedDisplayURLs.
-//
-// SortedDisplayURL is relatively cheap and supports value semantics.
-class SortedDisplayURL {
- public:
-  SortedDisplayURL(const GURL& url, const std::wstring& languages);
-  SortedDisplayURL() {}
-
-  // Compares this SortedDisplayURL to |url| using |collator|. Returns a value
-  // < 0, = 1 or > 0 as to whether this url is less then, equal to or greater
-  // than the supplied url.
-  int Compare(const SortedDisplayURL& other, icu::Collator* collator) const;
-
-  // Returns the display string for the URL.
-  const string16& display_url() const { return display_url_; }
-
- private:
-  // Returns everything after the host. This is used by Compare if the hosts
-  // match.
-  string16 AfterHost() const;
-
-  // Host name minus 'www.'. Used by Compare.
-  string16 sort_host_;
-
-  // End of the prefix (spec and separator) in display_url_.
-  size_t prefix_end_;
-
-  string16 display_url_;
-};
-
-} // namespace gfx.
-
-#endif  // APP_GFX_TEXT_ELIDER_H_
diff --git a/app/gfx/text_elider_unittest.cc b/app/gfx/text_elider_unittest.cc
deleted file mode 100644
index 385d92d..0000000
--- a/app/gfx/text_elider_unittest.cc
+++ /dev/null
@@ -1,270 +0,0 @@
-// Copyright (c) 2006-2008 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 "app/gfx/font.h"
-#include "app/gfx/text_elider.h"
-#include "app/l10n_util.h"
-#include "base/file_path.h"
-#include "base/string_util.h"
-#include "googleurl/src/gurl.h"
-#include "testing/gtest/include/gtest/gtest.h"
-
-namespace {
-
-const wchar_t kEllipsis[] = L"\x2026";
-
-struct Testcase {
-  const std::string input;
-  const std::wstring output;
-};
-
-struct FileTestcase {
-  const FilePath::StringType input;
-  const std::wstring output;
-};
-
-struct WideTestcase {
-  const std::wstring input;
-  const std::wstring output;
-};
-
-struct TestData {
-  const std::string a;
-  const std::string b;
-  const int compare_result;
-};
-
-void RunTest(Testcase* testcases, size_t num_testcases) {
-  static const gfx::Font font;
-  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.
-    EXPECT_EQ(testcases[i].output,
-              ElideUrl(url, font, font.GetStringWidth(testcases[i].output),
-                       std::wstring()));
-  }
-}
-
-}  // namespace
-
-// Test eliding of commonplace URLs.
-TEST(TextEliderTest, TestGeneralEliding) {
-  const std::wstring kEllipsisStr(kEllipsis);
-  Testcase testcases[] = {
-    {"http://www.google.com/intl/en/ads/",
-     L"http://www.google.com/intl/en/ads/"},
-    {"http://www.google.com/intl/en/ads/", L"www.google.com/intl/en/ads/"},
-// TODO(port): make this test case work on mac.
-#if !defined(OS_MACOSX)
-    {"http://www.google.com/intl/en/ads/",
-     L"google.com/intl/" + kEllipsisStr + L"/ads/"},
-#endif
-    {"http://www.google.com/intl/en/ads/",
-     L"google.com/" + kEllipsisStr + L"/ads/"},
-    {"http://www.google.com/intl/en/ads/", L"google.com/" + kEllipsisStr},
-    {"http://www.google.com/intl/en/ads/", L"goog" + kEllipsisStr},
-    {"https://subdomain.foo.com/bar/filename.html",
-     L"subdomain.foo.com/bar/filename.html"},
-    {"https://subdomain.foo.com/bar/filename.html",
-     L"subdomain.foo.com/" + kEllipsisStr + L"/filename.html"},
-    {"http://subdomain.foo.com/bar/filename.html",
-     kEllipsisStr + L"foo.com/" + kEllipsisStr + L"/filename.html"},
-    {"http://www.google.com/intl/en/ads/?aLongQueryWhichIsNotRequired",
-     L"http://www.google.com/intl/en/ads/?aLongQ" + kEllipsisStr},
-  };
-
-  RunTest(testcases, arraysize(testcases));
-}
-
-// Test eliding of empty strings, URLs with ports, passwords, queries, etc.
-TEST(TextEliderTest, TestMoreEliding) {
-  const std::wstring kEllipsisStr(kEllipsis);
-  Testcase testcases[] = {
-    {"http://www.google.com/foo?bar", L"http://www.google.com/foo?bar"},
-    {"http://xyz.google.com/foo?bar", L"xyz.google.com/foo?" + kEllipsisStr},
-    {"http://xyz.google.com/foo?bar", L"xyz.google.com/foo" + kEllipsisStr},
-    {"http://xyz.google.com/foo?bar", L"xyz.google.com/fo" + kEllipsisStr},
-    {"http://a.b.com/pathname/c?d", L"a.b.com/" + kEllipsisStr + L"/c?d"},
-    {"", L""},
-    {"http://foo.bar..example.com...hello/test/filename.html",
-     L"foo.bar..example.com...hello/" + kEllipsisStr + L"/filename.html"},
-    {"http://foo.bar../", L"http://foo.bar../"},
-    {"http://xn--1lq90i.cn/foo", L"http://\x5317\x4eac.cn/foo"},
-    {"http://me:mypass@secrethost.com:99/foo?bar#baz",
-     L"http://secrethost.com:99/foo?bar#baz"},
-    {"http://me:mypass@ss%xxfdsf.com/foo", L"http://ss%25xxfdsf.com/foo"},
-    {"mailto:elgoato@elgoato.com", L"mailto:elgoato@elgoato.com"},
-    {"javascript:click(0)", L"javascript:click(0)"},
-    {"https://chess.eecs.berkeley.edu:4430/login/arbitfilename",
-     L"chess.eecs.berkeley.edu:4430/login/arbitfilename"},
-    {"https://chess.eecs.berkeley.edu:4430/login/arbitfilename",
-     kEllipsisStr + L"berkeley.edu:4430/" + kEllipsisStr + L"/arbitfilename"},
-
-    // Unescaping.
-    {"http://www/%E4%BD%A0%E5%A5%BD?q=%E4%BD%A0%E5%A5%BD#\xe4\xbd\xa0",
-     L"http://www/\x4f60\x597d?q=\x4f60\x597d#\x4f60"},
-
-    // 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",
-     L"http://www/%E4%A0%E5%A5%BD?q=\x4f60\x597d#\x4f60"},
-  };
-
-  RunTest(testcases, arraysize(testcases));
-}
-
-// Test eliding of file: URLs.
-TEST(TextEliderTest, TestFileURLEliding) {
-  const std::wstring kEllipsisStr(kEllipsis);
-  Testcase testcases[] = {
-    {"file:///C:/path1/path2/path3/filename",
-     L"file:///C:/path1/path2/path3/filename"},
-    {"file:///C:/path1/path2/path3/filename",
-     L"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",
-     L"C:/path1/path2/" + kEllipsisStr + L"/filename"},
-    {"file:///C:path1/path2/path3/filename",
-     L"C:/path1/" + kEllipsisStr + L"/filename"},
-    {"file:///C:path1/path2/path3/filename",
-     L"C:/" + kEllipsisStr + L"/filename"},
-#endif
-    {"file://filer/foo/bar/file", L"filer/foo/bar/file"},
-    {"file://filer/foo/bar/file", L"filer/foo/" + kEllipsisStr + L"/file"},
-    {"file://filer/foo/bar/file", L"filer/" + kEllipsisStr + L"/file"},
-  };
-
-  RunTest(testcases, arraysize(testcases));
-}
-
-TEST(TextEliderTest, TestFilenameEliding) {
-  const std::wstring kEllipsisStr(kEllipsis);
-  const FilePath::StringType kPathSeparator =
-      FilePath::StringType().append(1, FilePath::kSeparators[0]);
-
-  FileTestcase testcases[] = {
-    {FILE_PATH_LITERAL(""), L""},
-    {FILE_PATH_LITERAL("."), L"."},
-    {FILE_PATH_LITERAL("filename.exe"), L"filename.exe"},
-    {FILE_PATH_LITERAL(".longext"), L".longext"},
-    {FILE_PATH_LITERAL("pie"), L"pie"},
-    {FILE_PATH_LITERAL("c:") + kPathSeparator + FILE_PATH_LITERAL("path") +
-      kPathSeparator + FILE_PATH_LITERAL("filename.pie"),
-      L"filename.pie"},
-    {FILE_PATH_LITERAL("c:") + kPathSeparator + FILE_PATH_LITERAL("path") +
-      kPathSeparator + FILE_PATH_LITERAL("longfilename.pie"),
-      L"long" + kEllipsisStr + L".pie"},
-    {FILE_PATH_LITERAL("http://path.com/filename.pie"), L"filename.pie"},
-    {FILE_PATH_LITERAL("http://path.com/longfilename.pie"),
-      L"long" + kEllipsisStr + L".pie"},
-    {FILE_PATH_LITERAL("piesmashingtacularpants"), L"pie" + kEllipsisStr},
-    {FILE_PATH_LITERAL(".piesmashingtacularpants"), L".pie" + kEllipsisStr},
-    {FILE_PATH_LITERAL("cheese."), L"cheese."},
-    {FILE_PATH_LITERAL("file name.longext"),
-      L"file" + kEllipsisStr + L".longext"},
-    {FILE_PATH_LITERAL("fil ename.longext"),
-      L"fil " + kEllipsisStr + L".longext"},
-    {FILE_PATH_LITERAL("filename.longext"),
-      L"file" + kEllipsisStr + L".longext"},
-    {FILE_PATH_LITERAL("filename.middleext.longext"),
-      L"filename.mid" + kEllipsisStr + L".longext"}
-  };
-
-  static const gfx::Font font;
-  for (size_t i = 0; i < arraysize(testcases); ++i) {
-    FilePath filepath(testcases[i].input);
-    std::wstring expected = testcases[i].output;
-    if (l10n_util::GetTextDirection() == l10n_util::RIGHT_TO_LEFT)
-      l10n_util::WrapStringWithLTRFormatting(&expected);
-    EXPECT_EQ(expected, ElideFilename(filepath,
-        font,
-        font.GetStringWidth(testcases[i].output)));
-  }
-}
-
-TEST(TextEliderTest, ElideTextLongStrings) {
-  const std::wstring kEllipsisStr(kEllipsis);
-  std::wstring data_scheme(L"data:text/plain,");
-
-  std::wstring ten_a(10, L'a');
-  std::wstring hundred_a(100, L'a');
-  std::wstring thousand_a(1000, L'a');
-  std::wstring ten_thousand_a(10000, L'a');
-  std::wstring hundred_thousand_a(100000, L'a');
-  std::wstring million_a(1000000, L'a');
-
-  WideTestcase testcases[] = {
-     {data_scheme + ten_a,
-      data_scheme + ten_a},
-     {data_scheme + hundred_a,
-      data_scheme + hundred_a},
-     {data_scheme + thousand_a,
-      data_scheme + std::wstring(156, L'a') + kEllipsisStr},
-     {data_scheme + ten_thousand_a,
-      data_scheme + std::wstring(156, L'a') + kEllipsisStr},
-     {data_scheme + hundred_thousand_a,
-      data_scheme + std::wstring(156, L'a') + kEllipsisStr},
-     {data_scheme + million_a,
-      data_scheme + std::wstring(156, L'a') + kEllipsisStr},
-  };
-
-  const gfx::Font font;
-  int ellipsis_width = font.GetStringWidth(kEllipsisStr);
-  for (size_t i = 0; i < arraysize(testcases); ++i) {
-    // Compare sizes rather than actual contents because if the test fails,
-    // output is rather long.
-    EXPECT_EQ(testcases[i].output.size(),
-              ElideText(testcases[i].input, font,
-                        font.GetStringWidth(testcases[i].output)).size());
-    EXPECT_EQ(kEllipsisStr,
-              ElideText(testcases[i].input, font, ellipsis_width));
-  }
-}
-
-// Verifies display_url is set correctly.
-TEST(TextEliderTest, SortedDisplayURL) {
-  gfx::SortedDisplayURL d_url(GURL("http://www.google.com/"), std::wstring());
-  EXPECT_EQ("http://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) {
-    gfx::SortedDisplayURL url1(GURL(tests[i].a), std::wstring());
-    gfx::SortedDisplayURL url2(GURL(tests[i].b), std::wstring());
-    EXPECT_EQ(tests[i].compare_result, url1.Compare(url2, collator.get()));
-    EXPECT_EQ(-tests[i].compare_result, url2.Compare(url1, collator.get()));
-  }
-}