Create net::FormatOriginForDisplay helper function.

net/base/net_util_icu.cc

 // Copyright (c) 2012 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 "net/base/net_util.h"
 
 #include <map>
 #include <vector>
 
 #include "base/i18n/time_formatting.h"
@@ skipping 558 matching lines @@
     output_component->reset();
   }
 }
 
 }  // namespace
 
 const FormatUrlType kFormatUrlOmitNothing                     = 0;
 const FormatUrlType kFormatUrlOmitUsernamePassword            = 1 << 0;
 const FormatUrlType kFormatUrlOmitHTTP                        = 1 << 1;
 const FormatUrlType kFormatUrlOmitTrailingSlashOnBareHostname = 1 << 2;
+const FormatUrlType kFormatUrlOmitScheme = 1 << 3;
+const FormatUrlType kFormatUrlOmitPort = 1 << 4;
 const FormatUrlType kFormatUrlOmitAll = kFormatUrlOmitUsernamePassword |
     kFormatUrlOmitHTTP | kFormatUrlOmitTrailingSlashOnBareHostname;
 
 base::string16 IDNToUnicode(const std::string& host,
                             const std::string& languages) {
   return IDNToUnicodeWithAdjustments(host, languages, NULL);
 }
 
 std::string GetDirectoryListingEntry(const base::string16& name,
                                      const std::string& raw_bytes,
@@ skipping 92 matching lines @@
                                unescape_rules, new_parsed, prefix_end,
                                adjustments);
   }
 
   // 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.
+  // Scheme removal occurs at the end.
   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_fixer::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) &&
-      EqualsASCII(url_string, kHTTP) &&
-      !StartsWithASCII(url.host(), kFTP, true);
   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 29 matching lines @@
       url_string.push_back('@');
   }
   if (prefix_end)
     *prefix_end = static_cast<size_t>(url_string.length());
 
   // Host.
   AppendFormattedComponent(spec, parsed.host, HostComponentTransform(languages),
                            &url_string, &new_parsed->host, adjustments);
 
   // Port.
-  if (parsed.port.is_nonempty()) {
+  if (parsed.port.is_nonempty() && !(format_types & kFormatUrlOmitPort)) {
     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 {
     new_parsed->port.reset();

[asanka, 2015/05/11 23:39:44]

The else clause now includes the 'parsed.port.is_nonempty() && (format_types &
kFormatUrlOmitPort)' condition where we remove the port. We need to push an
adjustment reflect the omission.

[palmer, 2015/05/12 22:20:53]

Done.

   }
 
   // Path & query.  Both get the same general unescape & convert treatment.
   if (!(format_types & kFormatUrlOmitTrailingSlashOnBareHostname) ||
       !CanStripTrailingSlash(url)) {
     AppendFormattedComponent(spec, parsed.path,
                              NonHostComponentTransform(unescape_rules),
                              &url_string, &new_parsed->path, adjustments);
   } else {
     if (parsed.path.len > 0) {
       adjustments->push_back(base::OffsetAdjuster::Adjustment(
           parsed.path.begin, parsed.path.len, 0));
     }
   }
   if (parsed.query.is_valid())
     url_string.push_back('?');
   AppendFormattedComponent(spec, parsed.query,
                            NonHostComponentTransform(unescape_rules),
                            &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(UnescapeRule::NONE),
                            &url_string, &new_parsed->ref, adjustments);
 
-  // If we need to strip out http do it after the fact.
-  if (omit_http && StartsWith(url_string, base::ASCIIToUTF16(kHTTP), true)) {
-    const size_t kHTTPSize = arraysize(kHTTP) - 1;
-    url_string = url_string.substr(kHTTPSize);
+  // Strip out the scheme, after the fact.
+  bool omit_all_schemes = !!(format_types & kFormatUrlOmitScheme);
+  // url_fixer::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) &&
+                   url.SchemeIs("http") &&
+                   !StartsWithASCII(url.host(), "ftp.", true);
+  if (omit_all_schemes || omit_http) {
+    const int scheme_size =
+        parsed.CountCharactersBefore(url::Parsed::USERNAME, true);
+    url_string = url_string.substr(scheme_size);
     // Because offsets in the |adjustments| are already calculated with respect
-    // to the string with the http:// prefix in it, those offsets remain correct
+    // to the string with the scheme 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 ://.
+    DCHECK_EQ(scheme_size, new_parsed->scheme.len + 3);
     new_parsed->scheme.reset();
-    AdjustAllComponentsButScheme(delta, new_parsed);
+    AdjustAllComponentsButScheme(-scheme_size, new_parsed);
   }
 
   return url_string;
 }
 
 base::string16 FormatUrl(const GURL& url,
                          const std::string& languages,
                          FormatUrlTypes format_types,
                          UnescapeRule::Type unescape_rules,
                          url::Parsed* new_parsed,
                          size_t* prefix_end,
                          size_t* offset_for_adjustment) {
   Offsets offsets;
   if (offset_for_adjustment)
     offsets.push_back(*offset_for_adjustment);
   base::string16 result = FormatUrlWithOffsets(url, languages, format_types,
       unescape_rules, new_parsed, prefix_end, &offsets);
   if (offset_for_adjustment)
     *offset_for_adjustment = offsets[0];
   return result;
 }
 
+base::string16 FormatOriginForDisplay(const GURL& url,
+                                      const std::string& languages,
+                                      bool omit_scheme) {
+  if (!url.IsStandard())
+    return FormatUrl(url, languages);
+
+  if (url.SchemeIsFile()) {
+    // TODO(palmer): Determine whether to encode this policy in GURL::GetOrigin.
+    return (omit_scheme ? base::ASCIIToUTF16("")
+                        : base::ASCIIToUTF16("file://")) +
+           base::UTF8ToUTF16(url.path());

[asanka, 2015/05/11 23:39:44]

It is (or should be) possible for url.host() to be non-empty for a file:// URL.
E.g. for file://example.com/path . The special case file:/// is referring to the
empty origin, which is considered to be an alias for the local system.

[palmer, 2015/05/12 22:20:53]

For file: URLs, the path is the origin, so that's what we display. In file:
URLs, the hostname is extraneous for origin determination purposes.

+  }
+
+  if (url.SchemeIsFileSystem()) {
+    // TODO(palmer): Determine whether to encode this policy in GURL::GetOrigin.
+    //
+    // TODO(palmer): Determine whether GURL::IsStandard should return false for

[asanka, 2015/05/11 23:39:44]

This is a good point. You should file a bug for it and add a reference here,
though technically this comment should go in gurl.h.

[palmer, 2015/05/12 22:20:53]

Done.

+    // filesystem: URLs. Per
+    // http://www.html5rocks.com/en/tutorials/file/filesystem/, they are not
+    // standard.
+    const GURL* inner_url = url.inner_url();
+    return base::ASCIIToUTF16("filesystem:") +
+           FormatOriginForDisplay(*inner_url, languages, omit_scheme);

[asanka, 2015/05/11 23:39:44]

Perhaps add a comment that this method deals correctly with filesystem URLs
whose authority is a file: URL.

"filesystem:" + FormatOriginForDisplay(url.GetOrigin(), ...) would drop the
path, which is significant for a file: URL.

[palmer, 2015/05/12 22:20:53]

Yeah, wow. Either GURL::inner_url is broken, or my expectations were wrong. I
have changed the code to cause it to return what I expect, and added tests.

+  }
+
+  GURL display_origin = url.GetOrigin();
+
+  FormatUrlTypes format_types = kFormatUrlOmitUsernamePassword |
+                                kFormatUrlOmitTrailingSlashOnBareHostname;
+  if (omit_scheme)
+    format_types |= kFormatUrlOmitScheme;
+
+  const int default_port = url::DefaultPortForScheme(
+      display_origin.scheme().c_str(), display_origin.scheme().length());
+  if (display_origin.EffectiveIntPort() == default_port)

[asanka, 2015/05/11 23:39:44]

Nit: use IntPort().

[palmer, 2015/05/12 22:20:53]

Done.

+    format_types |= kFormatUrlOmitPort;
+
+  return FormatUrl(display_origin, languages, format_types,
+                   UnescapeRule::SPACES, NULL, NULL, NULL);

[asanka, 2015/05/11 23:39:44]

NULL -> nullptr

[palmer, 2015/05/12 22:20:53]

Done.

+}
+
 }  // namespace net