| OLD | NEW |
|---|
| (Empty) |
| 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 } | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 1233313005:
Move elide_url to its own component (Closed)
Base URL: https://chromium.googlesource.com/chromium/src.git@master