Create net::FormatOriginForDisplay helper function.

net/base/net_util.h

 // 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.
 
 #ifndef NET_BASE_NET_UTIL_H_
 #define NET_BASE_NET_UTIL_H_
 
 #include "build/build_config.h"
 
 #if defined(OS_WIN)
@@ skipping 40 matching lines @@
 typedef std::vector<unsigned char> IPAddressNumber;
 typedef std::vector<IPAddressNumber> IPAddressList;
 
 static const size_t kIPv4AddressSize = 4;
 static const size_t kIPv6AddressSize = 16;
 #if defined(OS_WIN)
 // Bluetooth address size. Windows Bluetooth is supported via winsock.
 static const size_t kBluetoothAddressSize = 6;
 #endif
 
-// Nothing is ommitted.
+// Nothing is omitted.
 NET_EXPORT extern const FormatUrlType kFormatUrlOmitNothing;
 
 // If set, any username and password are removed.
 NET_EXPORT extern const FormatUrlType kFormatUrlOmitUsernamePassword;
 
 // If the scheme is 'http://', it's removed.
 NET_EXPORT extern const FormatUrlType kFormatUrlOmitHTTP;
 
 // Omits the path if it is just a slash and there is no query or ref.  This is
 // meaningful for non-file "standard" URLs.
 NET_EXPORT extern const FormatUrlType kFormatUrlOmitTrailingSlashOnBareHostname;
 
-// Convenience for omitting all unecessary types.
+// Convenience for omitting all unnecessary types.
 NET_EXPORT extern const FormatUrlType kFormatUrlOmitAll;
 
+// Remove the scheme. Callers should only specify this when it is safe to do so
+// (e.g. in contexts where the origin is always secure by necessity). Not part
+// of |kFormatUrlOmitAll|.
+NET_EXPORT extern const FormatUrlType kFormatUrlOmitScheme;
+
+// Remove the port. The caller should only specify this when the port is the
+// default for the scheme. Not part of |kFormatUrlOmitAll|.
+NET_EXPORT extern const FormatUrlType kFormatUrlOmitPort;
+
 // Returns the number of explicitly allowed ports; for testing.
 NET_EXPORT_PRIVATE extern size_t GetCountOfExplicitlyAllowedPorts();
 
-// Splits an input of the form <host>[":"<port>] into its consitituent parts.
+// Splits an input of the form <host>[":"<port>] into its constituent parts.
 // Saves the result into |*host| and |*port|. If the input did not have
 // the optional port, sets |*port| to -1.
 // Returns true if the parsing was successful, false otherwise.
 // The returned host is NOT canonicalized, and may be invalid.
 //
 // IPv6 literals must be specified in a bracketed form, for instance:
 //   [::1]:90 and [::1]
 //
 // The resultant |*host| in both cases will be "::1" (not bracketed).
 NET_EXPORT bool ParseHostAndPort(
     std::string::const_iterator host_and_port_begin,
     std::string::const_iterator host_and_port_end,
     std::string* host,
     int* port);
 NET_EXPORT bool ParseHostAndPort(
     const std::string& host_and_port,
     std::string* host,
     int* port);
 
 // Returns a host:port string for the given URL.
 NET_EXPORT std::string GetHostAndPort(const GURL& url);
 
 // Returns a host[:port] string for the given URL, where the port is omitted
 // if it is the default for the URL's scheme.
 NET_EXPORT_PRIVATE std::string GetHostAndOptionalPort(const GURL& url);
 
 // Returns true if |hostname| contains a non-registerable or non-assignable
-// domain name (eg: a gTLD that has not been assigned by IANA) or an IP address
-// that falls in an IANA-reserved range.
+// domain name (e.g.: a gTLD that has not been assigned by IANA) or an IP
+// address that falls in an IANA-reserved range.
 NET_EXPORT bool IsHostnameNonUnique(const std::string& hostname);
 
 // Returns true if an IP address hostname is in a range reserved by the IANA.
 // Works with both IPv4 and IPv6 addresses, and only compares against a given
-// protocols's reserved ranges.
+// protocol's reserved ranges.
 NET_EXPORT bool IsIPAddressReserved(const IPAddressNumber& address);
 
 // Convenience struct for when you need a |struct sockaddr|.
 struct SockaddrStorage {
   SockaddrStorage() : addr_len(sizeof(addr_storage)),
                       addr(reinterpret_cast<struct sockaddr*>(&addr_storage)) {}
   SockaddrStorage(const SockaddrStorage& other);
   void operator=(const SockaddrStorage& other);
 
   struct sockaddr_storage addr_storage;
@@ skipping 207 matching lines @@
 
 // This is a convenience function for FormatUrl() with
 // format_types = kFormatUrlOmitAll and unescape = SPACES.  This is the typical
 // set of flags for "URLs to display to the user".  You should be cautious about
 // using this for URLs which will be parsed or sent to other applications.
 inline base::string16 FormatUrl(const GURL& url, const std::string& languages) {
   return FormatUrl(url, languages, kFormatUrlOmitAll, UnescapeRule::SPACES,
                    NULL, NULL, NULL);
 }
 
+// This is a convenience function for formatting a URL as an origin in a concise
+// and human-friendly way. Use this instead of |FormatUrl| when the reader needs
+// only to understand the origin (rather than the entire URL).
+//
+// - Omits the path for standard schemes, excepting file and filesystem.
+// - Omits the port if it is the default for the scheme.
+//
+// Do not use this for URLs which will be parsed or sent to other applications.
+//
+// Callers should only set |omit_scheme| to true when it is safe to do so (e.g.
+// in contexts where the origin is always secure by necessity).

[felt, 2015/05/13 22:50:14]

Should the flag actually be omit_scheme_if_secure and then only omit the scheme
if the origin is secure?

[palmer, 2015/05/14 18:18:01]

I'd like to leave that to the caller to decide, e.g.

    foo = FormatOriginForDisplay(url, ..., url.SchemeIsCryptographic());

[felt, 2015/05/14 18:22:13]

I'm guessing that callers will be using this because they are not sure how to
display URLs correctly. I find that leaving off the scheme all the time is a
common mistake. But perhaps your comment is sufficient. Maybe mention
IsOriginSecure in the comment, as such:

Callers should only set |omit_scheme| to true when it is safe to do so (e.g.
FormatOriginForDisplay(origin, langs, IsOriginSecure(origin))

+NET_EXPORT base::string16 FormatOriginForDisplay(const GURL& origin,
+                                                 const std::string& languages,
+                                                 bool omit_scheme);
+
 // Returns whether FormatUrl() would strip a trailing slash from |url|, given a
 // format flag including kFormatUrlOmitTrailingSlashOnBareHostname.
 NET_EXPORT bool CanStripTrailingSlash(const GURL& url);
 
 // Strip the portions of |url| that aren't core to the network request.
 //   - user name / password
 //   - reference section
 NET_EXPORT_PRIVATE GURL SimplifyUrlForRequest(const GURL& url);
 
 NET_EXPORT void SetExplicitlyAllowedPorts(const std::string& allowed_ports);
@@ skipping 82 matching lines @@
 // Returns true if |host| is one of the names (e.g. "localhost") or IP
 // addresses (IPv4 127.0.0.0/8 or IPv6 ::1) that indicate a loopback.
 //
 // Note that this function does not check for IP addresses other than
 // the above, although other IP addresses may point to the local
 // machine.
 NET_EXPORT_PRIVATE bool IsLocalhost(const std::string& host);
 
 NET_EXPORT_PRIVATE bool IsLocalhostTLD(const std::string& host);
 
-// Returns true if the url's host is a Google server. This should only be used
+// Returns true if the URL's host is a Google server. This should only be used
 // for histograms and shouldn't be used to affect behavior.
 NET_EXPORT_PRIVATE bool HasGoogleHost(const GURL& url);
 
 // A subset of IP address attributes which are actionable by the
 // application layer. Currently unimplemented for all hosts;
 // IP_ADDRESS_ATTRIBUTE_NONE is always returned.
 enum IPAddressAttributes {
   IP_ADDRESS_ATTRIBUTE_NONE = 0,
 
   // A temporary address is dynamic by nature and will not contain MAC
@@ skipping 127 matching lines @@
   DSCP_CS5  = 40,  // Video
   DSCP_EF   = 46,  // Voice
   DSCP_CS6  = 48,  // Voice
   DSCP_CS7  = 56,  // Control messages
   DSCP_LAST = DSCP_CS7
 };
 
 }  // namespace net
 
 #endif  // NET_BASE_NET_UTIL_H_