Add fade eliding for Views Labels; related cleanup.

chrome/browser/ui/elide_url.cc

 // Copyright 2014 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 "chrome/browser/ui/elide_url.h"
 
 #include "base/logging.h"
 #include "base/strings/string_split.h"
 #include "base/strings/utf_string_conversions.h"
 #include "net/base/escape.h"
@@ skipping 46 matching lines @@
     const gfx::FontList& font_list,
     float available_pixel_width) {
   const size_t url_path_number_of_elements = url_path_elements.size();
 
   CHECK(url_path_number_of_elements);
   for (size_t i = url_path_number_of_elements - 1; i > 0; --i) {
     base::string16 elided_path = BuildPathFromComponents(url_path_prefix,
         url_path_elements, url_filename, i);
     if (available_pixel_width >= GetStringWidthF(elided_path, font_list))
       return ElideText(elided_path + url_query, font_list,
-                       available_pixel_width, gfx::ELIDE_AT_END);
+                       available_pixel_width, gfx::ELIDE_TAIL);
   }
 
   return base::string16();
 }
 
 // Splits the hostname in the |url| into sub-strings for the full hostname,
 // the domain (TLD+1), and the subdomain (everything leading the domain).
 void SplitHost(const GURL& url,
                base::string16* url_host,
                base::string16* url_domain,
@@ skipping 39 matching lines @@
   url::Parsed parsed;
   const base::string16 url_string =
       net::FormatUrl(url, languages, net::kFormatUrlOmitAll,
                      net::UnescapeRule::SPACES, &parsed, NULL, NULL);
   if (available_pixel_width <= 0)
     return url_string;
 
   // If non-standard, return plain eliding.
   if (!url.IsStandard())
     return ElideText(url_string, font_list, available_pixel_width,
-                     gfx::ELIDE_AT_END);
+                     gfx::ELIDE_TAIL);
 
   // Now start eliding url_string to fit within available pixel width.
   // Fist pass - check to see whether entire url_string fits.
   const float pixel_width_url_string = GetStringWidthF(url_string, font_list);
   if (available_pixel_width >= pixel_width_url_string)
     return url_string;
 
   // Get the path substring, including query and reference.
   const size_t path_start_index = parsed.path.begin;
   const size_t path_len = parsed.path.len;
   base::string16 url_path_query_etc = url_string.substr(path_start_index);
   base::string16 url_path = url_string.substr(path_start_index, path_len);
 
   // Return general elided text if url minus the query fits.
   const base::string16 url_minus_query =
       url_string.substr(0, path_start_index + path_len);
   if (available_pixel_width >= GetStringWidthF(url_minus_query, font_list))
     return ElideText(url_string, font_list, available_pixel_width,
-                     gfx::ELIDE_AT_END);
+                     gfx::ELIDE_TAIL);
 
   base::string16 url_host;
   base::string16 url_domain;
   base::string16 url_subdomain;
   SplitHost(url, &url_host, &url_domain, &url_subdomain);
 
   // 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()) {
@@ skipping 31 matching lines @@
   // Query element.
   base::string16 url_query;
   const float kPixelWidthDotsTrailer = GetStringWidthF(
       base::string16(kEllipsisUTF16), font_list);
   if (parsed.query.is_nonempty()) {
     url_query = UTF8ToUTF16("?") + url_string.substr(parsed.query.begin);
     if (available_pixel_width >=
         (pixel_width_url_subdomain + pixel_width_url_domain +
          pixel_width_url_path - GetStringWidthF(url_query, font_list))) {
       return ElideText(url_subdomain + url_domain + url_path_query_etc,
-                       font_list, available_pixel_width, gfx::ELIDE_AT_END);
+                       font_list, available_pixel_width, gfx::ELIDE_TAIL);
     }
   }
 
   // Parse url_path using '/'.
   std::vector<base::string16> url_path_elements;
   base::SplitString(url_path, kForwardSlash, &url_path_elements);
 
   // Get filename - note that for a path ending with /
   // such as www.google.com/intl/ads/, the file name is ads/.
   size_t url_path_number_of_elements = url_path_elements.size();
   DCHECK(url_path_number_of_elements != 0);
   base::string16 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) +
         kForwardSlash;
     url_path_number_of_elements--;
   }
   DCHECK(url_path_number_of_elements != 0);
 
   const size_t 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_list,
-                     available_pixel_width, gfx::ELIDE_AT_END);
+                     available_pixel_width, gfx::ELIDE_TAIL);
   }
 
   // Start eliding the path and replacing elements by ".../".
   const base::string16 kEllipsisAndSlash =
       base::string16(kEllipsisUTF16) + kForwardSlash;
   const float pixel_width_ellipsis_slash =
       GetStringWidthF(kEllipsisAndSlash, font_list);
 
   // Check with both subdomain and domain.
   base::string16 elided_path =
@@ skipping 32 matching lines @@
   if ((available_pixel_width - url_elided_domain_width) >
       pixel_width_ellipsis_slash + kPixelWidthDotsTrailer +
       GetStringWidthF(base::ASCIIToUTF16("UV"), font_list)) {
     final_elided_url_string += BuildPathFromComponents(base::string16(),
         url_path_elements, url_filename, 1);
   } else {
     final_elided_url_string += url_path;
   }
 
   return ElideText(final_elided_url_string, font_list, available_pixel_width,
-                   gfx::ELIDE_AT_END);
+                   gfx::ELIDE_TAIL);
 }
 
 base::string16 ElideHost(const GURL& url,
                          const gfx::FontList& font_list,
                          float available_pixel_width) {
   base::string16 url_host;
   base::string16 url_domain;
   base::string16 url_subdomain;
   SplitHost(url, &url_host, &url_domain, &url_subdomain);
 
   const float pixel_width_url_host = GetStringWidthF(url_host, font_list);
   if (available_pixel_width >= pixel_width_url_host)
     return url_host;
 
   if (url_subdomain.empty())
     return url_domain;
 
   const float pixel_width_url_domain = GetStringWidthF(url_domain, font_list);
   float subdomain_width = available_pixel_width - pixel_width_url_domain;
   if (subdomain_width <= 0)
     return base::string16(kEllipsisUTF16) + kDot + url_domain;
 
-  base::string16 elided_subdomain = ElideText(
-      url_subdomain, font_list, subdomain_width, gfx::ELIDE_AT_BEGINNING);
+  const base::string16 elided_subdomain = ElideText(
+      url_subdomain, font_list, subdomain_width, gfx::ELIDE_HEAD);
   return elided_subdomain + url_domain;
 }