Omnibox UI Experiments: Strip trivial subdomains

components/url_formatter/url_formatter.cc

 // Copyright 2015 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 "components/url_formatter/url_formatter.h"
 
 #include <algorithm>
 #include <utility>
 #include <vector>
 
 #include "base/lazy_instance.h"
 #include "base/macros.h"
 #include "base/numerics/safe_conversions.h"
 #include "base/strings/string_piece.h"
+#include "base/strings/string_tokenizer.h"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_offset_string_conversions.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/threading/thread_local_storage.h"
 #include "components/url_formatter/idn_spoof_checker.h"
+#include "net/base/registry_controlled_domains/registry_controlled_domain.h"
 #include "third_party/icu/source/common/unicode/uidna.h"
 #include "third_party/icu/source/common/unicode/utypes.h"
 #include "url/gurl.h"
 #include "url/third_party/mozilla/url_parse.h"
 
 namespace url_formatter {
 
 namespace {
 
 base::string16 IDNToUnicodeWithAdjustments(
@@ skipping 13 matching lines @@
       const std::string& component_text,
       base::OffsetAdjuster::Adjustments* adjustments) const = 0;
 
   // NOTE: No DISALLOW_COPY_AND_ASSIGN here, since gcc < 4.3.0 requires an
   // accessible copy constructor in order to call AppendFormattedComponent()
   // with an inline temporary (see http://gcc.gnu.org/bugs/#cxx%5Frvalbind ).
 };
 
 class HostComponentTransform : public AppendComponentTransform {
  public:
-  HostComponentTransform() {}
+  HostComponentTransform(bool trim_trivial_subdomains)
+      : trim_trivial_subdomains_(trim_trivial_subdomains) {}
 
  private:
   base::string16 Execute(
       const std::string& component_text,
       base::OffsetAdjuster::Adjustments* adjustments) const override {
-    return IDNToUnicodeWithAdjustments(component_text, adjustments);
+    if (!trim_trivial_subdomains_)
+      return IDNToUnicodeWithAdjustments(component_text, adjustments);
+
+    // Exclude the registry and domain from trivial subdomain stripping.
+    // To get the adjustment offset calculations correct, we need to transform
+    // the registry and domain portion of the host as well.
+    std::string domain_and_registry =
+        net::registry_controlled_domains::GetDomainAndRegistry(
+            component_text,
+            net::registry_controlled_domains::INCLUDE_PRIVATE_REGISTRIES);
+
+    base::OffsetAdjuster::Adjustments trivial_subdomains_adjustments;
+    base::StringTokenizer tokenizer(
+        component_text.begin(),
+        component_text.end() - domain_and_registry.length(), ".");
+    tokenizer.set_options(base::StringTokenizer::RETURN_DELIMS);
+
+    std::string transformed_subdomain;
+    while (tokenizer.GetNext()) {
+      // Append delimiters and non-trivial subdomains to the new subdomain part.
+      if (tokenizer.token_is_delim() ||
+          (tokenizer.token() != "m" && tokenizer.token() != "www")) {
+        transformed_subdomain += tokenizer.token();
+        continue;
+      }
+
+      // We found a trivial subdomain, so we add an adjustment accounting for
+      // the subdomain and the following consumed delimiter.
+      size_t trivial_subdomain_begin =
+          tokenizer.token_begin() - component_text.begin();
+      trivial_subdomains_adjustments.push_back(base::OffsetAdjuster::Adjustment(
+          trivial_subdomain_begin, tokenizer.token().length() + 1, 0));
+
+      // Consume the next token, which must be a delimiter.
+      bool next_delimiter_found = tokenizer.GetNext();
+      DCHECK(next_delimiter_found);
+      DCHECK(tokenizer.token_is_delim());
+    }
+
+    base::string16 unicode_result = IDNToUnicodeWithAdjustments(
+        transformed_subdomain + domain_and_registry, adjustments);
+    base::OffsetAdjuster::MergeSequentialAdjustments(
+        trivial_subdomains_adjustments, adjustments);
+    return unicode_result;
   }
+
+  bool trim_trivial_subdomains_;
 };
 
 class NonHostComponentTransform : public AppendComponentTransform {
  public:
   explicit NonHostComponentTransform(net::UnescapeRule::Type unescape_rules)
       : unescape_rules_(unescape_rules) {}
 
  private:
   base::string16 Execute(
       const std::string& component_text,
@@ skipping 284 matching lines @@
 
 const FormatUrlType kFormatUrlOmitNothing = 0;
 const FormatUrlType kFormatUrlOmitUsernamePassword = 1 << 0;
 const FormatUrlType kFormatUrlOmitHTTP = 1 << 1;
 const FormatUrlType kFormatUrlOmitTrailingSlashOnBareHostname = 1 << 2;
 const FormatUrlType kFormatUrlOmitAll =
     kFormatUrlOmitUsernamePassword | kFormatUrlOmitHTTP |
     kFormatUrlOmitTrailingSlashOnBareHostname;
 const FormatUrlType kFormatUrlExperimentalElideAfterHost = 1 << 3;
 const FormatUrlType kFormatUrlExperimentalOmitHTTPS = 1 << 4;
+const FormatUrlType kFormatUrlExperimentalOmitTrivialSubdomains = 1 << 5;
 
 base::string16 FormatUrl(const GURL& url,
                          FormatUrlTypes format_types,
                          net::UnescapeRule::Type unescape_rules,
                          url::Parsed* new_parsed,
                          size_t* prefix_end,
                          size_t* offset_for_adjustment) {
   std::vector<size_t> offsets;
   if (offset_for_adjustment)
     offsets.push_back(*offset_for_adjustment);
@@ skipping 99 matching lines @@
     AppendFormattedComponent(spec, parsed.password,
                              NonHostComponentTransform(unescape_rules),
                              &url_string, &new_parsed->password, adjustments);
     if (parsed.username.is_valid() || parsed.password.is_valid())
       url_string.push_back('@');
   }
   if (prefix_end)
     *prefix_end = static_cast<size_t>(url_string.length());
 
   // Host.
-  AppendFormattedComponent(spec, parsed.host, HostComponentTransform(),
+  bool trim_trivial_subdomains =
+      (format_types & kFormatUrlExperimentalOmitTrivialSubdomains) != 0;
+  AppendFormattedComponent(spec, parsed.host,
+                           HostComponentTransform(trim_trivial_subdomains),
                            &url_string, &new_parsed->host, adjustments);
 
   // Port.
   if (parsed.port.is_nonempty()) {
     url_string.push_back(':');
     new_parsed->port.begin = url_string.length();
     url_string.insert(url_string.end(), spec.begin() + parsed.port.begin,
                       spec.begin() + parsed.port.end());
     new_parsed->port.len = url_string.length() - new_parsed->port.begin;
   } else {
@@ skipping 92 matching lines @@
 bool CanStripTrailingSlash(const GURL& url) {
   // Omit the path only for standard, non-file URLs with nothing but "/" after
   // the hostname.
   return url.IsStandard() && !url.SchemeIsFile() && !url.SchemeIsFileSystem() &&
          !url.has_query() && !url.has_ref() && url.path_piece() == "/";
 }
 
 void AppendFormattedHost(const GURL& url, base::string16* output) {
   AppendFormattedComponent(
       url.possibly_invalid_spec(), url.parsed_for_possibly_invalid_spec().host,
-      HostComponentTransform(), output, NULL, NULL);
+      HostComponentTransform(false), output, nullptr, nullptr);
 }
 
 base::string16 IDNToUnicode(base::StringPiece host) {
   return IDNToUnicodeWithAdjustments(host, nullptr);
 }
 
 base::string16 StripWWW(const base::string16& text) {
   const base::string16 www(base::ASCIIToUTF16("www."));
   return base::StartsWith(text, www, base::CompareCase::SENSITIVE)
       ? text.substr(www.length()) : text;
 }
 
 base::string16 StripWWWFromHost(const GURL& url) {
   DCHECK(url.is_valid());
   return StripWWW(base::ASCIIToUTF16(url.host_piece()));
 }
 
 }  // namespace url_formatter