elide_url.cc 17 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461
  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. #include "components/url_formatter/elide_url.h"
  5. #include <stddef.h>
  6. #include "base/check_op.h"
  7. #include "base/i18n/rtl.h"
  8. #include "base/strings/escape.h"
  9. #include "base/strings/strcat.h"
  10. #include "base/strings/string_number_conversions.h"
  11. #include "base/strings/string_piece.h"
  12. #include "base/strings/string_split.h"
  13. #include "base/strings/utf_string_conversions.h"
  14. #include "build/build_config.h"
  15. #include "components/url_formatter/url_formatter.h"
  16. #include "net/base/registry_controlled_domains/registry_controlled_domain.h"
  17. #include "ui/gfx/text_constants.h"
  18. #include "ui/gfx/text_elider.h"
  19. #include "ui/gfx/text_utils.h"
  20. #include "url/gurl.h"
  21. #include "url/origin.h"
  22. #include "url/url_constants.h"
  23. namespace {
  24. #if !BUILDFLAG(IS_ANDROID)
  25. const char16_t kDot = '.';
  26. // Build a path from the first |num_components| elements in |path_elements|.
  27. // Prepends |path_prefix|, appends |filename|, inserts ellipsis if appropriate.
  28. std::u16string BuildPathFromComponents(
  29. const std::u16string& path_prefix,
  30. const std::vector<std::u16string>& path_elements,
  31. const std::u16string& filename,
  32. size_t num_components) {
  33. DCHECK_LE(num_components, path_elements.size());
  34. // Add the initial elements of the path.
  35. std::u16string path = path_prefix;
  36. // Build path from first |num_components| elements.
  37. for (size_t j = 0; j < num_components; ++j)
  38. path += path_elements[j] + gfx::kForwardSlash;
  39. // Add |filename|, ellipsis if necessary.
  40. if (num_components != (path_elements.size() - 1))
  41. path += std::u16string(gfx::kEllipsisUTF16) + gfx::kForwardSlash;
  42. path += filename;
  43. return path;
  44. }
  45. // Takes a prefix (Domain, or Domain+subdomain) and a collection of path
  46. // components and elides if possible. Returns a string containing the longest
  47. // possible elided path, or an empty string if elision is not possible.
  48. std::u16string ElideComponentizedPath(
  49. const std::u16string& url_path_prefix,
  50. const std::vector<std::u16string>& url_path_elements,
  51. const std::u16string& url_filename,
  52. const std::u16string& url_query,
  53. const gfx::FontList& font_list,
  54. float available_pixel_width) {
  55. CHECK(!url_path_elements.empty());
  56. // Find the longest set of leading path components that fits in
  57. // |available_pixel_width|. Since BuildPathFromComponents() is O(n), using a
  58. // binary search here makes the overall complexity O(n lg n), which is
  59. // meaningful since there may be thousands of components in extreme cases.
  60. std::u16string elided_path_at_min_index;
  61. size_t min_index = 0;
  62. for (size_t max_index = url_path_elements.size();
  63. min_index != max_index - 1;) {
  64. const size_t cutting_index = (min_index + max_index) / 2;
  65. const std::u16string elided_path = BuildPathFromComponents(
  66. url_path_prefix, url_path_elements, url_filename, cutting_index);
  67. if (gfx::GetStringWidthF(elided_path, font_list) <= available_pixel_width) {
  68. min_index = cutting_index;
  69. elided_path_at_min_index = elided_path;
  70. } else {
  71. max_index = cutting_index;
  72. }
  73. }
  74. // If the cutting point is at the beginning and nothing gets elided, return
  75. // failure even if the whole text could fit. TODO(https://crbug.com/1074034).
  76. if (min_index == 0)
  77. return std::u16string();
  78. // Elide starting at |min_index|.
  79. return gfx::ElideText(elided_path_at_min_index + url_query, font_list,
  80. available_pixel_width, gfx::ELIDE_TAIL);
  81. }
  82. #endif // !BUILDFLAG(IS_ANDROID)
  83. bool ShouldShowScheme(base::StringPiece scheme,
  84. const url_formatter::SchemeDisplay scheme_display) {
  85. switch (scheme_display) {
  86. case url_formatter::SchemeDisplay::SHOW:
  87. return true;
  88. case url_formatter::SchemeDisplay::OMIT_HTTP_AND_HTTPS:
  89. return scheme != url::kHttpsScheme && scheme != url::kHttpScheme;
  90. case url_formatter::SchemeDisplay::OMIT_CRYPTOGRAPHIC:
  91. return scheme != url::kHttpsScheme && scheme != url::kWssScheme;
  92. }
  93. return true;
  94. }
  95. // TODO(jshin): Come up with a way to show Bidi URLs 'safely' (e.g. wrap up
  96. // the entire url with {LSI, PDI} and individual domain labels with {FSI, PDI}).
  97. // See http://crbug.com/650760 . For now, fall back to punycode if there's a
  98. // strong RTL character.
  99. std::u16string HostForDisplay(base::StringPiece host_in_puny) {
  100. std::u16string host = url_formatter::IDNToUnicode(host_in_puny);
  101. return base::i18n::StringContainsStrongRTLChars(host) ?
  102. base::ASCIIToUTF16(host_in_puny) : host;
  103. }
  104. } // namespace
  105. namespace url_formatter {
  106. #if !BUILDFLAG(IS_ANDROID)
  107. // TODO(pkasting): http://crbug.com/77883 This whole function gets
  108. // kerning/ligatures/etc. issues potentially wrong by assuming that the width of
  109. // a rendered string is always the sum of the widths of its substrings. Also I
  110. // suspect it could be made simpler.
  111. std::u16string ElideUrl(const GURL& url,
  112. const gfx::FontList& font_list,
  113. float available_pixel_width) {
  114. // Get a formatted string and corresponding parsing of the url.
  115. url::Parsed parsed;
  116. const std::u16string url_string = url_formatter::FormatUrl(
  117. url, url_formatter::kFormatUrlOmitDefaults, base::UnescapeRule::SPACES,
  118. &parsed, nullptr, nullptr);
  119. if (available_pixel_width <= 0)
  120. return url_string;
  121. if (!url.IsStandard()) {
  122. return gfx::ElideText(url_string, font_list, available_pixel_width,
  123. gfx::ELIDE_TAIL);
  124. }
  125. // Now start eliding url_string to fit within available pixel width.
  126. // Fist pass - check to see whether entire url_string fits.
  127. const float pixel_width_url_string =
  128. gfx::GetStringWidthF(url_string, font_list);
  129. if (available_pixel_width >= pixel_width_url_string)
  130. return url_string;
  131. // Get the path substring, including query and reference.
  132. const size_t path_start_index = parsed.path.begin;
  133. const size_t path_len = parsed.path.len;
  134. std::u16string url_path_query_etc;
  135. std::u16string url_path;
  136. if (parsed.path.is_valid()) {
  137. url_path_query_etc = url_string.substr(path_start_index);
  138. url_path = url_string.substr(path_start_index, path_len);
  139. }
  140. // Return general elided text if url minus the query fits.
  141. const std::u16string url_minus_query =
  142. url_string.substr(0, path_start_index + path_len);
  143. if (available_pixel_width >=
  144. gfx::GetStringWidthF(url_minus_query, font_list)) {
  145. return gfx::ElideText(url_string, font_list, available_pixel_width,
  146. gfx::ELIDE_TAIL);
  147. }
  148. std::u16string url_host;
  149. std::u16string url_domain;
  150. std::u16string url_subdomain;
  151. url_formatter::SplitHost(url, &url_host, &url_domain, &url_subdomain);
  152. // If this is a file type, the path is now defined as everything after ":".
  153. // For example, "C:/aa/aa/bb", the path is "/aa/bb/cc". Interesting, the
  154. // domain is now C: - this is a nice hack for eliding to work pleasantly.
  155. if (url.SchemeIsFile()) {
  156. // Split the path string using ":"
  157. constexpr base::StringPiece16 kColon(u":", 1);
  158. std::vector<std::u16string> file_path_split = base::SplitString(
  159. url_path, kColon, base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL);
  160. if (file_path_split.size() > 1) { // File is of type "file:///C:/.."
  161. url_host.clear();
  162. url_domain.clear();
  163. url_subdomain.clear();
  164. url_host = url_domain =
  165. base::StrCat({file_path_split.at(0).substr(1), kColon});
  166. url_path_query_etc = url_path = file_path_split.at(1);
  167. }
  168. }
  169. // Second Pass - remove scheme - the rest fits.
  170. const float pixel_width_url_host = gfx::GetStringWidthF(url_host, font_list);
  171. const float pixel_width_url_path =
  172. gfx::GetStringWidthF(url_path_query_etc, font_list);
  173. if (available_pixel_width >= pixel_width_url_host + pixel_width_url_path)
  174. return url_host + url_path_query_etc;
  175. // Third Pass: Subdomain, domain and entire path fits.
  176. const float pixel_width_url_domain =
  177. gfx::GetStringWidthF(url_domain, font_list);
  178. const float pixel_width_url_subdomain =
  179. gfx::GetStringWidthF(url_subdomain, font_list);
  180. if (available_pixel_width >=
  181. pixel_width_url_subdomain + pixel_width_url_domain + pixel_width_url_path)
  182. return url_subdomain + url_domain + url_path_query_etc;
  183. // Query element.
  184. std::u16string url_query;
  185. const float kPixelWidthDotsTrailer =
  186. gfx::GetStringWidthF(std::u16string(gfx::kEllipsisUTF16), font_list);
  187. if (parsed.query.is_nonempty()) {
  188. url_query = u"?" + url_string.substr(parsed.query.begin);
  189. if (available_pixel_width >=
  190. (pixel_width_url_subdomain + pixel_width_url_domain +
  191. pixel_width_url_path - gfx::GetStringWidthF(url_query, font_list))) {
  192. return gfx::ElideText(url_subdomain + url_domain + url_path_query_etc,
  193. font_list, available_pixel_width, gfx::ELIDE_TAIL);
  194. }
  195. }
  196. // Parse url_path using '/'.
  197. std::vector<std::u16string> url_path_elements =
  198. base::SplitString(url_path, std::u16string(1, gfx::kForwardSlash),
  199. base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL);
  200. // Get filename - note that for a path ending with /
  201. // such as www.google.com/intl/ads/, the file name is ads/.
  202. std::u16string url_filename(
  203. url_path_elements.empty() ? std::u16string() : url_path_elements.back());
  204. size_t url_path_number_of_elements = url_path_elements.size();
  205. if (url_filename.empty() && (url_path_number_of_elements > 1)) {
  206. // Path ends with a '/'.
  207. --url_path_number_of_elements;
  208. url_filename =
  209. url_path_elements[url_path_number_of_elements - 1] + gfx::kForwardSlash;
  210. }
  211. // Start eliding the path and replacing elements by ".../".
  212. const std::u16string kEllipsisAndSlash =
  213. std::u16string(gfx::kEllipsisUTF16) + gfx::kForwardSlash;
  214. const float pixel_width_ellipsis_slash =
  215. gfx::GetStringWidthF(kEllipsisAndSlash, font_list);
  216. // Check with both subdomain and domain.
  217. if (url_path_number_of_elements > 0) {
  218. std::u16string elided_path = ElideComponentizedPath(
  219. url_subdomain + url_domain, url_path_elements, url_filename, url_query,
  220. font_list, available_pixel_width);
  221. if (!elided_path.empty())
  222. return elided_path;
  223. }
  224. // Check with only domain.
  225. // If a subdomain is present, add an ellipsis before domain.
  226. // This is added only if the subdomain pixel width is larger than
  227. // the pixel width of kEllipsis. Otherwise, subdomain remains,
  228. // which means that this case has been resolved earlier.
  229. std::u16string url_elided_domain = url_subdomain + url_domain;
  230. if (pixel_width_url_subdomain > kPixelWidthDotsTrailer) {
  231. if (!url_subdomain.empty())
  232. url_elided_domain = kEllipsisAndSlash[0] + url_domain;
  233. else
  234. url_elided_domain = url_domain;
  235. if (url_path_number_of_elements > 0) {
  236. std::u16string elided_path = ElideComponentizedPath(
  237. url_elided_domain, url_path_elements, url_filename, url_query,
  238. font_list, available_pixel_width);
  239. if (!elided_path.empty())
  240. return elided_path;
  241. }
  242. }
  243. // Return elided domain/.../filename anyway.
  244. std::u16string final_elided_url_string(url_elided_domain);
  245. const float url_elided_domain_width =
  246. gfx::GetStringWidthF(url_elided_domain, font_list);
  247. // A hack to prevent trailing ".../...".
  248. if (url_path_number_of_elements > 0 &&
  249. url_elided_domain_width + pixel_width_ellipsis_slash +
  250. kPixelWidthDotsTrailer + gfx::GetStringWidthF(u"UV", font_list) <
  251. available_pixel_width) {
  252. final_elided_url_string += BuildPathFromComponents(
  253. std::u16string(), url_path_elements, url_filename, 1);
  254. } else {
  255. final_elided_url_string += url_path;
  256. }
  257. return gfx::ElideText(final_elided_url_string, font_list,
  258. available_pixel_width, gfx::ELIDE_TAIL);
  259. }
  260. std::u16string ElideHost(const GURL& url,
  261. const gfx::FontList& font_list,
  262. float available_pixel_width) {
  263. std::u16string url_host;
  264. std::u16string url_domain;
  265. std::u16string url_subdomain;
  266. url_formatter::SplitHost(url, &url_host, &url_domain, &url_subdomain);
  267. const float pixel_width_url_host = gfx::GetStringWidthF(url_host, font_list);
  268. if (available_pixel_width >= pixel_width_url_host)
  269. return url_host;
  270. if (url_subdomain.empty())
  271. return url_domain;
  272. const float pixel_width_url_domain =
  273. gfx::GetStringWidthF(url_domain, font_list);
  274. float subdomain_width = available_pixel_width - pixel_width_url_domain;
  275. if (subdomain_width <= 0)
  276. return std::u16string(gfx::kEllipsisUTF16) + kDot + url_domain;
  277. return gfx::ElideText(url_host, font_list, available_pixel_width,
  278. gfx::ELIDE_HEAD);
  279. }
  280. #endif // !BUILDFLAG(IS_ANDROID)
  281. std::u16string FormatUrlForSecurityDisplay(const GURL& url,
  282. const SchemeDisplay scheme_display) {
  283. if (!url.is_valid() || url.is_empty() || !url.IsStandard())
  284. return url_formatter::FormatUrl(url);
  285. constexpr base::StringPiece16 colon(u":");
  286. if (url.SchemeIsFile()) {
  287. return base::StrCat({url::kFileScheme16, url::kStandardSchemeSeparator16,
  288. base::UTF8ToUTF16(url.path())});
  289. }
  290. if (url.SchemeIsFileSystem()) {
  291. const GURL* inner_url = url.inner_url();
  292. if (inner_url->SchemeIsFile()) {
  293. return base::StrCat({url::kFileSystemScheme16, colon,
  294. FormatUrlForSecurityDisplay(*inner_url),
  295. base::UTF8ToUTF16(url.path())});
  296. }
  297. return base::StrCat({url::kFileSystemScheme16, colon,
  298. FormatUrlForSecurityDisplay(*inner_url)});
  299. }
  300. const GURL origin = url.DeprecatedGetOriginAsURL();
  301. base::StringPiece scheme = origin.scheme_piece();
  302. base::StringPiece host = origin.host_piece();
  303. std::u16string result;
  304. if (ShouldShowScheme(scheme, scheme_display)) {
  305. result = base::StrCat(
  306. {base::UTF8ToUTF16(scheme), url::kStandardSchemeSeparator16});
  307. }
  308. result += HostForDisplay(host);
  309. const int port = origin.IntPort();
  310. const int default_port = url::DefaultPortForScheme(
  311. scheme.data(), static_cast<int>(scheme.length()));
  312. if (port != url::PORT_UNSPECIFIED && port != default_port)
  313. result += base::StrCat({colon, base::UTF8ToUTF16(origin.port_piece())});
  314. return result;
  315. }
  316. std::u16string FormatOriginForSecurityDisplay(
  317. const url::Origin& origin,
  318. const SchemeDisplay scheme_display) {
  319. base::StringPiece scheme = origin.scheme();
  320. base::StringPiece host = origin.host();
  321. if (scheme.empty() && host.empty())
  322. return std::u16string();
  323. constexpr base::StringPiece16 colon(u":");
  324. std::u16string result;
  325. if (ShouldShowScheme(scheme, scheme_display)) {
  326. result = base::StrCat(
  327. {base::UTF8ToUTF16(scheme), url::kStandardSchemeSeparator16});
  328. }
  329. result += HostForDisplay(host);
  330. int port = static_cast<int>(origin.port());
  331. const int default_port = url::DefaultPortForScheme(
  332. scheme.data(), static_cast<int>(scheme.length()));
  333. if (port != 0 && port != default_port)
  334. result += base::StrCat({colon, base::NumberToString16(origin.port())});
  335. return result;
  336. }
  337. std::u16string FormatUrlForDisplayOmitSchemePathAndTrivialSubdomains(
  338. const GURL& url) {
  339. return url_formatter::FormatUrl(
  340. url,
  341. url_formatter::kFormatUrlOmitDefaults |
  342. url_formatter::kFormatUrlTrimAfterHost |
  343. url_formatter::kFormatUrlOmitHTTPS |
  344. url_formatter::kFormatUrlOmitTrivialSubdomains,
  345. base::UnescapeRule::SPACES, nullptr, nullptr, nullptr);
  346. }
  347. #if BUILDFLAG(IS_IOS)
  348. std::u16string
  349. FormatUrlForDisplayOmitSchemePathTrivialSubdomainsAndMobilePrefix(
  350. const GURL& url) {
  351. return url_formatter::FormatUrl(
  352. url,
  353. url_formatter::kFormatUrlOmitDefaults |
  354. url_formatter::kFormatUrlTrimAfterHost |
  355. url_formatter::kFormatUrlOmitHTTPS |
  356. url_formatter::kFormatUrlOmitTrivialSubdomains |
  357. url_formatter::kFormatUrlOmitMobilePrefix,
  358. base::UnescapeRule::SPACES, nullptr, nullptr, nullptr);
  359. }
  360. #endif
  361. void SplitHost(const GURL& url,
  362. std::u16string* url_host,
  363. std::u16string* url_domain,
  364. std::u16string* url_subdomain) {
  365. // GURL stores IDN hostnames in punycode. Convert back to Unicode for
  366. // display to the user. (IDNToUnicode() will only perform this conversion
  367. // if it's safe to display this host/domain in Unicode.)
  368. *url_host = url_formatter::IDNToUnicode(url.host());
  369. // Get domain and registry information from the URL.
  370. std::string domain_puny =
  371. net::registry_controlled_domains::GetDomainAndRegistry(
  372. url, net::registry_controlled_domains::EXCLUDE_PRIVATE_REGISTRIES);
  373. *url_domain = domain_puny.empty() ? *url_host
  374. : url_formatter::IDNToUnicode(domain_puny);
  375. // Add port if required.
  376. if (!url.port().empty()) {
  377. *url_host += base::UTF8ToUTF16(":" + url.port());
  378. *url_domain += base::UTF8ToUTF16(":" + url.port());
  379. }
  380. // Get sub domain if requested.
  381. if (url_subdomain) {
  382. const size_t domain_start_index = url_host->find(*url_domain);
  383. constexpr base::StringPiece16 kWwwPrefix = u"www.";
  384. if (domain_start_index != std::u16string::npos)
  385. *url_subdomain = url_host->substr(0, domain_start_index);
  386. if ((*url_subdomain == kWwwPrefix || url_subdomain->empty() ||
  387. url.SchemeIsFile())) {
  388. url_subdomain->clear();
  389. }
  390. }
  391. }
  392. } // namespace url_formatter