| 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 std::vector<base::string16> file_path_split; | |
| 160 base::SplitString(url_path, ':', &file_path_split); | |
| 161 if (file_path_split.size() > 1) { // File is of type "file:///C:/.." | |
| 162 url_host.clear(); | |
| 163 url_domain.clear(); | |
| 164 url_subdomain.clear(); | |
| 165 | |
| 166 const base::string16 kColon = UTF8ToUTF16(":"); | |
| 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; | |
| 205 base::SplitString(url_path, kForwardSlash, &url_path_elements); | |
| 206 | |
| 207 // Get filename - note that for a path ending with / | |
| 208 // such as www.google.com/intl/ads/, the file name is ads/. | |
| 209 base::string16 url_filename( | |
| 210 url_path_elements.empty() ? base::string16() : url_path_elements.back()); | |
| 211 size_t url_path_number_of_elements = url_path_elements.size(); | |
| 212 if (url_filename.empty() && (url_path_number_of_elements > 1)) { | |
| 213 // Path ends with a '/'. | |
| 214 --url_path_number_of_elements; | |
| 215 url_filename = url_path_elements[url_path_number_of_elements - 1] + | |
| 216 kForwardSlash; | |
| 217 } | |
| 218 | |
| 219 const size_t kMaxNumberOfUrlPathElementsAllowed = 1024; | |
| 220 if (url_path_number_of_elements <= 1 || | |
| 221 url_path_number_of_elements > kMaxNumberOfUrlPathElementsAllowed) { | |
| 222 // No path to elide, or too long of a path (could overflow in loop below) | |
| 223 // Just elide this as a text string. | |
| 224 return ElideText(url_subdomain + url_domain + url_path_query_etc, font_list, | |
| 225 available_pixel_width, gfx::ELIDE_TAIL); | |
| 226 } | |
| 227 | |
| 228 // Start eliding the path and replacing elements by ".../". | |
| 229 const base::string16 kEllipsisAndSlash = | |
| 230 base::string16(kEllipsisUTF16) + kForwardSlash; | |
| 231 const float pixel_width_ellipsis_slash = | |
| 232 GetStringWidthF(kEllipsisAndSlash, font_list); | |
| 233 | |
| 234 // Check with both subdomain and domain. | |
| 235 base::string16 elided_path = | |
| 236 ElideComponentizedPath(url_subdomain + url_domain, url_path_elements, | |
| 237 url_filename, url_query, font_list, | |
| 238 available_pixel_width); | |
| 239 if (!elided_path.empty()) | |
| 240 return elided_path; | |
| 241 | |
| 242 // Check with only domain. | |
| 243 // If a subdomain is present, add an ellipsis before domain. | |
| 244 // This is added only if the subdomain pixel width is larger than | |
| 245 // the pixel width of kEllipsis. Otherwise, subdomain remains, | |
| 246 // which means that this case has been resolved earlier. | |
| 247 base::string16 url_elided_domain = url_subdomain + url_domain; | |
| 248 if (pixel_width_url_subdomain > kPixelWidthDotsTrailer) { | |
| 249 if (!url_subdomain.empty()) | |
| 250 url_elided_domain = kEllipsisAndSlash[0] + url_domain; | |
| 251 else | |
| 252 url_elided_domain = url_domain; | |
| 253 | |
| 254 elided_path = ElideComponentizedPath(url_elided_domain, url_path_elements, | |
| 255 url_filename, url_query, font_list, | |
| 256 available_pixel_width); | |
| 257 | |
| 258 if (!elided_path.empty()) | |
| 259 return elided_path; | |
| 260 } | |
| 261 | |
| 262 // Return elided domain/.../filename anyway. | |
| 263 base::string16 final_elided_url_string(url_elided_domain); | |
| 264 const float url_elided_domain_width = GetStringWidthF(url_elided_domain, | |
| 265 font_list); | |
| 266 | |
| 267 // A hack to prevent trailing ".../...". | |
| 268 if ((available_pixel_width - url_elided_domain_width) > | |
| 269 pixel_width_ellipsis_slash + kPixelWidthDotsTrailer + | |
| 270 GetStringWidthF(base::ASCIIToUTF16("UV"), font_list)) { | |
| 271 final_elided_url_string += BuildPathFromComponents(base::string16(), | |
| 272 url_path_elements, url_filename, 1); | |
| 273 } else { | |
| 274 final_elided_url_string += url_path; | |
| 275 } | |
| 276 | |
| 277 return ElideText(final_elided_url_string, font_list, available_pixel_width, | |
| 278 gfx::ELIDE_TAIL); | |
| 279 } | |
| 280 | |
| 281 base::string16 ElideHost(const GURL& url, | |
| 282 const gfx::FontList& font_list, | |
| 283 float available_pixel_width) { | |
| 284 base::string16 url_host; | |
| 285 base::string16 url_domain; | |
| 286 base::string16 url_subdomain; | |
| 287 SplitHost(url, &url_host, &url_domain, &url_subdomain); | |
| 288 | |
| 289 const float pixel_width_url_host = GetStringWidthF(url_host, font_list); | |
| 290 if (available_pixel_width >= pixel_width_url_host) | |
| 291 return url_host; | |
| 292 | |
| 293 if (url_subdomain.empty()) | |
| 294 return url_domain; | |
| 295 | |
| 296 const float pixel_width_url_domain = GetStringWidthF(url_domain, font_list); | |
| 297 float subdomain_width = available_pixel_width - pixel_width_url_domain; | |
| 298 if (subdomain_width <= 0) | |
| 299 return base::string16(kEllipsisUTF16) + kDot + url_domain; | |
| 300 | |
| 301 const base::string16 elided_subdomain = ElideText( | |
| 302 url_subdomain, font_list, subdomain_width, gfx::ELIDE_HEAD); | |
| 303 return elided_subdomain + url_domain; | |
| 304 } | |
| 305 | |
| 306 base::string16 FormatUrlForSecurityDisplay(const GURL& url, | |
| 307 const std::string& languages) { | |
| 308 if (!url.is_valid() || url.is_empty() || !url.IsStandard()) | |
| 309 return net::FormatUrl(url, languages); | |
| 310 | |
| 311 const base::string16 colon(base::ASCIIToUTF16(":")); | |
| 312 const base::string16 scheme_separator( | |
| 313 base::ASCIIToUTF16(url::kStandardSchemeSeparator)); | |
| 314 | |
| 315 if (url.SchemeIsFile()) { | |
| 316 return base::ASCIIToUTF16(url::kFileScheme) + scheme_separator + | |
| 317 base::UTF8ToUTF16(url.path()); | |
| 318 } | |
| 319 | |
| 320 if (url.SchemeIsFileSystem()) { | |
| 321 const GURL* inner_url = url.inner_url(); | |
| 322 if (inner_url->SchemeIsFile()) { | |
| 323 return base::ASCIIToUTF16(url::kFileSystemScheme) + colon + | |
| 324 FormatUrlForSecurityDisplay(*inner_url, languages) + | |
| 325 base::UTF8ToUTF16(url.path()); | |
| 326 } | |
| 327 return base::ASCIIToUTF16(url::kFileSystemScheme) + colon + | |
| 328 FormatUrlForSecurityDisplay(*inner_url, languages); | |
| 329 } | |
| 330 | |
| 331 const GURL origin = url.GetOrigin(); | |
| 332 const std::string& scheme = origin.scheme(); | |
| 333 const std::string& host = origin.host(); | |
| 334 | |
| 335 base::string16 result = base::UTF8ToUTF16(scheme); | |
| 336 result += scheme_separator; | |
| 337 result += base::UTF8ToUTF16(host); | |
| 338 | |
| 339 const int port = origin.IntPort(); | |
| 340 const int default_port = url::DefaultPortForScheme(origin.scheme().c_str(), | |
| 341 origin.scheme().length()); | |
| 342 if (port != url::PORT_UNSPECIFIED && port != default_port) | |
| 343 result += colon + base::UTF8ToUTF16(origin.port()); | |
| 344 | |
| 345 return result; | |
| 346 } | |
| 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