Omnibox UI Experiments: Refactor HTTPS trimming into UrlFormatter.

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>
 
@@ skipping 343 matching lines @@
 }  // namespace
 
 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;
 
 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 55 matching lines @@
   // We handle both valid and invalid URLs (this will give us the spec
   // regardless of validity).
   const std::string& spec = url.possibly_invalid_spec();
   const url::Parsed& parsed = url.parsed_for_possibly_invalid_spec();
 
   // Scheme & separators.  These are ASCII.
   base::string16 url_string;
   url_string.insert(
       url_string.end(), spec.begin(),
       spec.begin() + parsed.CountCharactersBefore(url::Parsed::USERNAME, true));
-  const char kHTTP[] = "http://";
-  const char kFTP[] = "ftp.";
-  // url_formatter::FixupURL() treats "ftp.foo.com" as ftp://ftp.foo.com.  This
-  // means that if we trim "http://" off a URL whose host starts with "ftp." and
-  // the user inputs this into any field subject to fixup (which is basically
-  // all input fields), the meaning would be changed.  (In fact, often the
-  // formatted URL is directly pre-filled into an input field.)  For this reason
-  // we avoid stripping "http://" in this case.
-  bool omit_http =
-      (format_types & kFormatUrlOmitHTTP) &&
-      base::EqualsASCII(url_string, kHTTP) &&
-      !base::StartsWith(url.host(), kFTP, base::CompareCase::SENSITIVE);
   new_parsed->scheme = parsed.scheme;
 
   // Username & password.
   if ((format_types & kFormatUrlOmitUsernamePassword) != 0) {
     // Remove the username and password fields. We don't want to display those
     // to the user since they can be used for attacks,
     // e.g. "http://google.com:search@evil.ru/"
     new_parsed->username.reset();
     new_parsed->password.reset();
     // Update the adjustments based on removed username and/or password.
@@ skipping 90 matching lines @@
                              &url_string, &new_parsed->query, adjustments);
 
     // Ref.  This is valid, unescaped UTF-8, so we can just convert.
     if (parsed.ref.is_valid())
       url_string.push_back('#');
     AppendFormattedComponent(spec, parsed.ref,
                              NonHostComponentTransform(net::UnescapeRule::NONE),
                              &url_string, &new_parsed->ref, adjustments);
   }
 
-  // If we need to strip out http do it after the fact.
-  if (omit_http && base::StartsWith(url_string, base::ASCIIToUTF16(kHTTP),
-                                    base::CompareCase::SENSITIVE)) {
-    const size_t kHTTPSize = arraysize(kHTTP) - 1;
-    url_string = url_string.substr(kHTTPSize);
+  // url_formatter::FixupURL() treats "ftp.foo.com" as ftp://ftp.foo.com.  This
+  // means that if we trim "http://" off a URL whose host starts with "ftp." and

[Peter Kasting, 2017/06/28 23:09:59]

Nit: "http://" -> the scheme

[tommycli, 2017/06/29 00:19:43]

Done.

+  // the user inputs this into any field subject to fixup (which is basically
+  // all input fields), the meaning would be changed.  (In fact, often the
+  // formatted URL is directly pre-filled into an input field.)  For this reason
+  // we avoid stripping schemes in this case.
+  const char kFTP[] = "ftp.";
+  bool strip_scheme =
+      !base::StartsWith(url.host(), kFTP, base::CompareCase::SENSITIVE) &&
+      (((format_types & kFormatUrlOmitHTTP) &&
+        url.SchemeIs(url::kHttpScheme)) ||
+       ((format_types & kFormatUrlExperimentalOmitHTTPS) &&
+        url.SchemeIs(url::kHttpsScheme)));
+
+  // If we need to strip out schemes do it after the fact.
+  if (strip_scheme) {
+    const size_t scheme_size =
+        parsed.scheme.len + strlen(url::kStandardSchemeSeparator);
+    url_string = url_string.substr(scheme_size);

[Peter Kasting, 2017/06/28 23:09:59]

I noticed we need to compute the scheme size above already.  It seems like we
can do something like this:

  const size_t scheme_size = static_cast<size_t>(
      parsed.CountCharactersBefore(url::Parsed::USERNAME, true));
  ... use this temp above ...

    ... and use it here:
    url_string.erase(0, scheme_size);

[tommycli, 2017/06/29 00:19:43]

Done.

     // Because offsets in the |adjustments| are already calculated with respect
     // to the string with the http:// prefix in it, those offsets remain correct
     // after stripping the prefix.  The only thing necessary is to add an
     // adjustment to reflect the stripped prefix.
     adjustments->insert(adjustments->begin(),
-                        base::OffsetAdjuster::Adjustment(0, kHTTPSize, 0));
+                        base::OffsetAdjuster::Adjustment(0, scheme_size, 0));
 
     if (prefix_end)
-      *prefix_end -= kHTTPSize;
+      *prefix_end -= scheme_size;
 
     // Adjust new_parsed.
     DCHECK(new_parsed->scheme.is_valid());
     int delta = -(new_parsed->scheme.len + 3);  // +3 for ://.
     new_parsed->scheme.reset();
     AdjustAllComponentsButScheme(delta, new_parsed);
   }
 
   return url_string;
 }
@@ skipping 20 matching lines @@
   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