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 56 matching lines @@
 // 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.
 NET_EXPORT extern const FormatUrlType kFormatUrlOmitAll;
 
+// Remove the scheme.  The caller should only specify kFormatUrlOmitScheme
+// after verifying that it is secure to do so. Not part of kFormatUrlOmitAll.
+NET_EXPORT extern const FormatUrlType kFormatUrlOmitScheme;
+
+// Remove the port.  The caller should only specify kFormatUrlOmitPort
+// after verifying that it is secure to do so. Not part of kFormatUrlOmitAll.

[Ryan Sleevi, 2014/09/02 19:26:17]

This is... vaguely worded.

When is it ever secure to omit the port? Only when the port is a default port,
correct?

+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.
 // 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. If <host> is
 // an IPv6 literal address, the returned host includes the square brackets.
 NET_EXPORT bool ParseHostAndPort(
@@ skipping 171 matching lines @@
 NET_EXPORT_PRIVATE bool IsPortAllowedByFtp(int port);
 
 // Check if banned |port| has been overriden by an entry in
 // |explicitly_allowed_ports_|.
 NET_EXPORT_PRIVATE bool IsPortAllowedByOverride(int port);
 
 // Set socket to non-blocking mode
 NET_EXPORT int SetNonBlocking(int fd);
 
 // Formats the host in |url| and appends it to |output|.  The host formatter
 // takes the same accept languages component as ElideURL().

[Ryan Sleevi, 2014/09/02 19:26:17]

So, this is an example of the layering.

ElideURL was actually moved up to //chrome/browser/ui as the canonical place for
it (it used to be here in //net)

 NET_EXPORT void AppendFormattedHost(const GURL& url,
                                     const std::string& languages,
                                     base::string16* output);
 
 // Creates a string representation of |url|. The IDN host name may be in Unicode
 // if |languages| accepts the Unicode representation. |format_type| is a bitmask
 // of FormatUrlTypes, see it for details. |unescape_rules| defines how to clean
 // the URL for human readability. You will generally want |UnescapeRule::SPACES|
 // for display to the user if you can handle spaces, or |UnescapeRule::NORMAL|
 // if not. If the path part and the query part seem to be encoded in %-encoded
@@ skipping 52 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 for display
+// in security UI: infobars, permission strings, etc. Use this instead of

[Ryan Sleevi, 2014/09/02 19:26:17]

So, to re-iterate the layering, //net has no idea about (infobars, permission
strings, etc). It's a conceptual separation in //net (that occasionally gets
punctured, and then I whine about it until someone fixes it or tries to do more
of the same, and then I whine until either they fix it or they call me on my
whining and I fix it)

Strictly from a code layout and layering point, what code potentially calls into
this? Is it //content? //chrome? //components? I would rather explore that, and
understand how the high level code would/is going to use this, and then figure
out the right layer.

Ideal world, this would live in //chrome/browser/ui, and just call FormatUrl
with some set of flags.

[felt, 2014/09/15 05:42:30]

Here are some files that should be refactored to call this proposed new method:
//chrome/browser/pepper_broker_infobar_delegate.cc
//chrome/browser/ui/app_modal_dialogs/javascript_dialog_manager.cc
//chrome/browser/ui/views/website_settings/permissions_bubble_view.cc
//chrome/browser/content_settings/permission_infobar_delegate.cc

And possibly also these:
//components/nacl/browser/nacl_process_host.cc
//content/browser/frame_host/navigation_entry_impl.cc

For the first few, c/b/ui seems appropriate, but that wouldn't work for the
//components and //content code. WDYT?

[felt, 2014/09/15 22:47:55]

Sleevi: what about putting this on gurl.h?

+// FormatUrl() for strings in a security UI context. Do not use this for URLs
+// which will be parsed or sent to other applications.
+// - The path is dropped for standard schemes, excepting file and filesystem.
+// - Standard ports are removed for http and https.
+// - By default, the scheme is only displayed for non-secure origins. This can

[Michael van Ouwerkerk, 2014/09/02 13:10:47]

Why is https omitted by default? Haven't we been teaching users for years to
specifically look for https to check it's safe?

+//   be overridden with |always_show_scheme|.
+NET_EXPORT base::string16 FormatOriginForDisplay(
+    const GURL& origin, const std::string& languages, bool always_show_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 180 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_