chrome/browser/ui/elide_url.cc

   1 // Copyright 2014 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "chrome/browser/ui/elide_url.h"
   6
   7 #include "base/logging.h"
   8 #include "base/strings/string_split.h"
   9 #include "base/strings/utf_string_conversions.h"
  10 #include "net/base/escape.h"
  11 #include "net/base/net_util.h"
  12 #include "net/base/registry_controlled_domains/registry_controlled_domain.h"
  13 #include "ui/gfx/text_elider.h"
  14 #include "ui/gfx/text_utils.h"
  15 #include "url/gurl.h"
  16 #include "url/url_constants.h"
  17
  18 using base::UTF8ToUTF16;
  19 using gfx::ElideText;
  20 using gfx::GetStringWidthF;
  21 using gfx::kEllipsisUTF16;
  22 using gfx::kForwardSlash;
  23
  24 namespace {
  25
  26 const base::char16 kDot = '.';
  27
  28 // Build a path from the first |num_components| elements in |path_elements|.
  29 // Prepends |path_prefix|, appends |filename|, inserts ellipsis if appropriate.
  30 base::string16 BuildPathFromComponents(
  31     const base::string16& path_prefix,
  32     const std::vector<base::string16>& path_elements,
  33     const base::string16& filename,
  34     size_t num_components) {
  35   // Add the initial elements of the path.
  36   base::string16 path = path_prefix;
  37
  38   // Build path from first |num_components| elements.
  39   for (size_t j = 0; j < num_components; ++j)
  40     path += path_elements[j] + kForwardSlash;
  41
  42   // Add |filename|, ellipsis if necessary.
  43   if (num_components != (path_elements.size() - 1))
  44     path += base::string16(kEllipsisUTF16) + kForwardSlash;
  45   path += filename;
  46
  47   return path;
  48 }
  49
  50 // Takes a prefix (Domain, or Domain+subdomain) and a collection of path
  51 // components and elides if possible. Returns a string containing the longest
  52 // possible elided path, or an empty string if elision is not possible.
  53 base::string16 ElideComponentizedPath(
  54     const base::string16& url_path_prefix,
  55     const std::vector<base::string16>& url_path_elements,
  56     const base::string16& url_filename,
  57     const base::string16& url_query,
  58     const gfx::FontList& font_list,
  59     float available_pixel_width) {
  60   const size_t url_path_number_of_elements = url_path_elements.size();
  61
  62   CHECK(url_path_number_of_elements);
  63   for (size_t i = url_path_number_of_elements - 1; i > 0; --i) {
  64     base::string16 elided_path = BuildPathFromComponents(url_path_prefix,
  65         url_path_elements, url_filename, i);
  66     if (available_pixel_width >= GetStringWidthF(elided_path, font_list))
  67       return ElideText(elided_path + url_query, font_list,
  68                        available_pixel_width, gfx::ELIDE_TAIL);
  69   }
  70
  71   return base::string16();
  72 }
  73
  74 // Splits the hostname in the |url| into sub-strings for the full hostname,
  75 // the domain (TLD+1), and the subdomain (everything leading the domain).
  76 void SplitHost(const GURL& url,
  77                base::string16* url_host,
  78                base::string16* url_domain,
  79                base::string16* url_subdomain) {
  80   // Get Host.
  81   *url_host = UTF8ToUTF16(url.host());
  82
  83   // Get domain and registry information from the URL.
  84   *url_domain = UTF8ToUTF16(
  85       net::registry_controlled_domains::GetDomainAndRegistry(
  86           url, net::registry_controlled_domains::EXCLUDE_PRIVATE_REGISTRIES));
  87   if (url_domain->empty())
  88     *url_domain = *url_host;
  89
  90   // Add port if required.
  91   if (!url.port().empty()) {
  92     *url_host += UTF8ToUTF16(":" + url.port());
  93     *url_domain += UTF8ToUTF16(":" + url.port());
  94   }
  95
  96   // Get sub domain.
  97   const size_t domain_start_index = url_host->find(*url_domain);
  98   base::string16 kWwwPrefix = UTF8ToUTF16("www.");
  99   if (domain_start_index != base::string16::npos)
 100     *url_subdomain = url_host->substr(0, domain_start_index);
 101   if ((*url_subdomain == kWwwPrefix || url_subdomain->empty() ||
 102       url.SchemeIsFile())) {
 103     url_subdomain->clear();
 104   }
 105 }
 106
 107 }  // namespace
 108
 109 // TODO(pkasting): http://crbug.com/77883 This whole function gets
 110 // kerning/ligatures/etc. issues potentially wrong by assuming that the width of
 111 // a rendered string is always the sum of the widths of its substrings.  Also I
 112 // suspect it could be made simpler.
 113 base::string16 ElideUrl(const GURL& url,
 114                         const gfx::FontList& font_list,
 115                         float available_pixel_width,
 116                         const std::string& languages) {
 117   // Get a formatted string and corresponding parsing of the url.
 118   url::Parsed parsed;
 119   const base::string16 url_string =
 120       net::FormatUrl(url, languages, net::kFormatUrlOmitAll,
 121                      net::UnescapeRule::SPACES, &parsed, NULL, NULL);
 122   if (available_pixel_width <= 0)
 123     return url_string;
 124
 125   // If non-standard, return plain eliding.
 126   if (!url.IsStandard())
 127     return ElideText(url_string, font_list, available_pixel_width,
 128                      gfx::ELIDE_TAIL);
 129
 130   // Now start eliding url_string to fit within available pixel width.
 131   // Fist pass - check to see whether entire url_string fits.
 132   const float pixel_width_url_string = GetStringWidthF(url_string, font_list);
 133   if (available_pixel_width >= pixel_width_url_string)
 134     return url_string;
 135
 136   // Get the path substring, including query and reference.
 137   const size_t path_start_index = parsed.path.begin;
 138   const size_t path_len = parsed.path.len;
 139   base::string16 url_path_query_etc = url_string.substr(path_start_index);
 140   base::string16 url_path = url_string.substr(path_start_index, path_len);
 141
 142   // Return general elided text if url minus the query fits.
 143   const base::string16 url_minus_query =
 144       url_string.substr(0, path_start_index + path_len);
 145   if (available_pixel_width >= GetStringWidthF(url_minus_query, font_list))
 146     return ElideText(url_string, font_list, available_pixel_width,
 147                      gfx::ELIDE_TAIL);
 148
 149   base::string16 url_host;
 150   base::string16 url_domain;
 151   base::string16 url_subdomain;
 152   SplitHost(url, &url_host, &url_domain, &url_subdomain);
 153
 154   // If this is a file type, the path is now defined as everything after ":".
 155   // For example, "C:/aa/aa/bb", the path is "/aa/bb/cc". Interesting, the
 156   // domain is now C: - this is a nice hack for eliding to work pleasantly.
 157   if (url.SchemeIsFile()) {
 158     // Split the path string using ":"
 159     const base::string16 kColon(1, ':');
 160     std::vector<base::string16> file_path_split = base::SplitString(
 161         url_path, kColon, base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL);
 162     if (file_path_split.size() > 1) {  // File is of type "file:///C:/.."
 163       url_host.clear();
 164       url_domain.clear();
 165       url_subdomain.clear();
 166
 167       url_host = url_domain = file_path_split.at(0).substr(1) + kColon;
 168       url_path_query_etc = url_path = file_path_split.at(1);
 169     }
 170   }
 171
 172   // Second Pass - remove scheme - the rest fits.
 173   const float pixel_width_url_host = GetStringWidthF(url_host, font_list);
 174   const float pixel_width_url_path = GetStringWidthF(url_path_query_etc,
 175                                                      font_list);
 176   if (available_pixel_width >=
 177       pixel_width_url_host + pixel_width_url_path)
 178     return url_host + url_path_query_etc;
 179
 180   // Third Pass: Subdomain, domain and entire path fits.
 181   const float pixel_width_url_domain = GetStringWidthF(url_domain, font_list);
 182   const float pixel_width_url_subdomain =
 183       GetStringWidthF(url_subdomain, font_list);
 184   if (available_pixel_width >=
 185       pixel_width_url_subdomain + pixel_width_url_domain +
 186       pixel_width_url_path)
 187     return url_subdomain + url_domain + url_path_query_etc;
 188
 189   // Query element.
 190   base::string16 url_query;
 191   const float kPixelWidthDotsTrailer = GetStringWidthF(
 192       base::string16(kEllipsisUTF16), font_list);
 193   if (parsed.query.is_nonempty()) {
 194     url_query = UTF8ToUTF16("?") + url_string.substr(parsed.query.begin);
 195     if (available_pixel_width >=
 196         (pixel_width_url_subdomain + pixel_width_url_domain +
 197          pixel_width_url_path - GetStringWidthF(url_query, font_list))) {
 198       return ElideText(url_subdomain + url_domain + url_path_query_etc,
 199                        font_list, available_pixel_width, gfx::ELIDE_TAIL);
 200     }
 201   }
 202
 203   // Parse url_path using '/'.
 204   std::vector<base::string16> url_path_elements = base::SplitString(
 205       url_path, base::string16(1, kForwardSlash),
 206       base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL);
 207
 208   // Get filename - note that for a path ending with /
 209   // such as www.google.com/intl/ads/, the file name is ads/.
 210   base::string16 url_filename(
 211       url_path_elements.empty() ? base::string16() : url_path_elements.back());
 212   size_t url_path_number_of_elements = url_path_elements.size();
 213   if (url_filename.empty() && (url_path_number_of_elements > 1)) {
 214     // Path ends with a '/'.
 215     --url_path_number_of_elements;
 216     url_filename = url_path_elements[url_path_number_of_elements - 1] +
 217         kForwardSlash;
 218   }
 219
 220   const size_t kMaxNumberOfUrlPathElementsAllowed = 1024;
 221   if (url_path_number_of_elements <= 1 ||
 222       url_path_number_of_elements > kMaxNumberOfUrlPathElementsAllowed) {
 223     // No path to elide, or too long of a path (could overflow in loop below)
 224     // Just elide this as a text string.
 225     return ElideText(url_subdomain + url_domain + url_path_query_etc, font_list,
 226                      available_pixel_width, gfx::ELIDE_TAIL);
 227   }
 228
 229   // Start eliding the path and replacing elements by ".../".
 230   const base::string16 kEllipsisAndSlash =
 231       base::string16(kEllipsisUTF16) + kForwardSlash;
 232   const float pixel_width_ellipsis_slash =
 233       GetStringWidthF(kEllipsisAndSlash, font_list);
 234
 235   // Check with both subdomain and domain.
 236   base::string16 elided_path =
 237       ElideComponentizedPath(url_subdomain + url_domain, url_path_elements,
 238                              url_filename, url_query, font_list,
 239                              available_pixel_width);
 240   if (!elided_path.empty())
 241     return elided_path;
 242
 243   // Check with only domain.
 244   // If a subdomain is present, add an ellipsis before domain.
 245   // This is added only if the subdomain pixel width is larger than
 246   // the pixel width of kEllipsis. Otherwise, subdomain remains,
 247   // which means that this case has been resolved earlier.
 248   base::string16 url_elided_domain = url_subdomain + url_domain;
 249   if (pixel_width_url_subdomain > kPixelWidthDotsTrailer) {
 250     if (!url_subdomain.empty())
 251       url_elided_domain = kEllipsisAndSlash[0] + url_domain;
 252     else
 253       url_elided_domain = url_domain;
 254
 255     elided_path = ElideComponentizedPath(url_elided_domain, url_path_elements,
 256                                          url_filename, url_query, font_list,
 257                                          available_pixel_width);
 258
 259     if (!elided_path.empty())
 260       return elided_path;
 261   }
 262
 263   // Return elided domain/.../filename anyway.
 264   base::string16 final_elided_url_string(url_elided_domain);
 265   const float url_elided_domain_width = GetStringWidthF(url_elided_domain,
 266                                                         font_list);
 267
 268   // A hack to prevent trailing ".../...".
 269   if ((available_pixel_width - url_elided_domain_width) >
 270       pixel_width_ellipsis_slash + kPixelWidthDotsTrailer +
 271       GetStringWidthF(base::ASCIIToUTF16("UV"), font_list)) {
 272     final_elided_url_string += BuildPathFromComponents(base::string16(),
 273         url_path_elements, url_filename, 1);
 274   } else {
 275     final_elided_url_string += url_path;
 276   }
 277
 278   return ElideText(final_elided_url_string, font_list, available_pixel_width,
 279                    gfx::ELIDE_TAIL);
 280 }
 281
 282 base::string16 ElideHost(const GURL& url,
 283                          const gfx::FontList& font_list,
 284                          float available_pixel_width) {
 285   base::string16 url_host;
 286   base::string16 url_domain;
 287   base::string16 url_subdomain;
 288   SplitHost(url, &url_host, &url_domain, &url_subdomain);
 289
 290   const float pixel_width_url_host = GetStringWidthF(url_host, font_list);
 291   if (available_pixel_width >= pixel_width_url_host)
 292     return url_host;
 293
 294   if (url_subdomain.empty())
 295     return url_domain;
 296
 297   const float pixel_width_url_domain = GetStringWidthF(url_domain, font_list);
 298   float subdomain_width = available_pixel_width - pixel_width_url_domain;
 299   if (subdomain_width <= 0)
 300     return base::string16(kEllipsisUTF16) + kDot + url_domain;
 301
 302   const base::string16 elided_subdomain = ElideText(
 303       url_subdomain, font_list, subdomain_width, gfx::ELIDE_HEAD);
 304   return elided_subdomain + url_domain;
 305 }
 306
 307 base::string16 FormatUrlForSecurityDisplay(const GURL& url,
 308                                            const std::string& languages) {
 309   if (!url.is_valid() || url.is_empty() || !url.IsStandard())
 310     return net::FormatUrl(url, languages);
 311
 312   const base::string16 colon(base::ASCIIToUTF16(":"));
 313   const base::string16 scheme_separator(
 314       base::ASCIIToUTF16(url::kStandardSchemeSeparator));
 315
 316   if (url.SchemeIsFile()) {
 317     return base::ASCIIToUTF16(url::kFileScheme) + scheme_separator +
 318            base::UTF8ToUTF16(url.path());
 319   }
 320
 321   if (url.SchemeIsFileSystem()) {
 322     const GURL* inner_url = url.inner_url();
 323     if (inner_url->SchemeIsFile()) {
 324       return base::ASCIIToUTF16(url::kFileSystemScheme) + colon +
 325              FormatUrlForSecurityDisplay(*inner_url, languages) +
 326              base::UTF8ToUTF16(url.path());
 327     }
 328     return base::ASCIIToUTF16(url::kFileSystemScheme) + colon +
 329            FormatUrlForSecurityDisplay(*inner_url, languages);
 330   }
 331
 332   const GURL origin = url.GetOrigin();
 333   const std::string& scheme = origin.scheme();
 334   const std::string& host = origin.host();
 335
 336   base::string16 result = base::UTF8ToUTF16(scheme);
 337   result += scheme_separator;
 338   result += base::UTF8ToUTF16(host);
 339
 340   const int port = origin.IntPort();
 341   const int default_port = url::DefaultPortForScheme(origin.scheme().c_str(),
 342                                                      origin.scheme().length());
 343   if (port != url::PORT_UNSPECIFIED && port != default_port)
 344     result += colon + base::UTF8ToUTF16(origin.port());
 345
 346   return result;
 347 }