Add FormatOriginForSecurityDisplay which takes a const url::Origin& origin

components/url_formatter/elide_url.cc

 // Copyright 2014 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/elide_url.h"
 
 #include <stddef.h>
 
 #include "base/logging.h"
+#include "base/strings/string_number_conversions.h"
 #include "base/strings/string_split.h"
 #include "base/strings/utf_string_conversions.h"
 #include "build/build_config.h"
 #include "components/url_formatter/url_formatter.h"
 #include "net/base/escape.h"
 #include "net/base/registry_controlled_domains/registry_controlled_domain.h"
 #include "url/gurl.h"
+#include "url/origin.h"
 #include "url/url_constants.h"
 
 #if !defined(OS_ANDROID)
 #include "ui/gfx/text_elider.h"  // nogncheck
 #include "ui/gfx/text_utils.h"  // nogncheck
 #endif
 
 namespace {
 
 #if !defined(OS_ANDROID)
@@ skipping 91 matching lines @@
       return !url.SchemeIs(url::kHttpsScheme) &&
              !url.SchemeIs(url::kHttpScheme);
 
     case url_formatter::SchemeDisplay::OMIT_CRYPTOGRAPHIC:
       return !url.SchemeIsCryptographic();
   }
 
   return true;
 }
 
+bool ShouldShowScheme(const url::Origin& origin,

[palmer, 2016/05/09 19:40:48]

Rather than (essentially) duplicate this code, how about instead refactoring
|ShouldShowScheme|:

  bool ShouldShowScheme(const std::string& scheme,
                        const url_formatter::SchemeDisplay scheme_display)

and then updating the call sites for both GURLs and Origins?

[juncai, 2016/05/10 02:16:57]

Done.

+                      const url_formatter::SchemeDisplay scheme_display) {
+  const std::string& scheme = origin.scheme();
+
+  switch (scheme_display) {
+    case url_formatter::SchemeDisplay::SHOW:
+      return true;
+
+    case url_formatter::SchemeDisplay::OMIT_HTTP_AND_HTTPS:
+      return scheme != url::kHttpsScheme && scheme != url::kHttpScheme;
+
+    case url_formatter::SchemeDisplay::OMIT_CRYPTOGRAPHIC:
+      return scheme != url::kHttpsScheme && scheme != url::kWssScheme;
+  }
+
+  return true;
+}
+
 }  // namespace
 
 namespace url_formatter {
 
 #if !defined(OS_ANDROID)
 
 // TODO(pkasting): http://crbug.com/77883 This whole function gets
 // kerning/ligatures/etc. issues potentially wrong by assuming that the width of
 // a rendered string is always the sum of the widths of its substrings.  Also I
 // suspect it could be made simpler.
@@ skipping 227 matching lines @@
 
   const int port = origin.IntPort();
   const int default_port = url::DefaultPortForScheme(
       scheme.c_str(), static_cast<int>(scheme.length()));
   if (port != url::PORT_UNSPECIFIED && port != default_port)
     result += colon + base::UTF8ToUTF16(origin.port());
 
   return result;
 }
 
+base::string16 FormatUrlForSecurityDisplay(const url::Origin& origin,
+                                           const SchemeDisplay scheme_display) {
+  const base::string16 colon(base::ASCIIToUTF16(":"));
+  const base::string16 scheme_separator(
+      base::ASCIIToUTF16(url::kStandardSchemeSeparator));
+
+  const std::string& scheme = origin.scheme();
+  const std::string& host = origin.host();
+
+  base::string16 result;
+  if (ShouldShowScheme(origin, scheme_display))
+    result = base::UTF8ToUTF16(scheme) + scheme_separator;
+  result += base::UTF8ToUTF16(host);
+
+  uint16_t port = origin.port();
+  const int default_port = url::DefaultPortForScheme(
+      scheme.c_str(), static_cast<int>(scheme.length()));
+  if (port != default_port)
+    result += colon + base::UintToString16(origin.port());
+
+  return result;
+}
+
 }  // namespace url_formatter