Don't show scheme in permission prompts if it is HTTPS

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_split.h"
@@ skipping 88 matching lines @@
   // Get sub domain.
   const size_t domain_start_index = url_host->find(*url_domain);
   base::string16 kWwwPrefix = base::UTF8ToUTF16("www.");
   if (domain_start_index != base::string16::npos)
     *url_subdomain = url_host->substr(0, domain_start_index);
   if ((*url_subdomain == kWwwPrefix || url_subdomain->empty() ||
        url.SchemeIsFile())) {
     url_subdomain->clear();
   }
 }
-
 #endif  // !defined(OS_ANDROID)
 
-base::string16 FormatUrlForSecurityDisplayInternal(const GURL& url,
-                                                   bool omit_scheme) {
-  if (!url.is_valid() || url.is_empty() || !url.IsStandard())
-    return url_formatter::FormatUrl(url);
+bool ShouldShowScheme(const GURL& url,
+                      const url_formatter::SchemeDisplay scheme_display) {
+  switch (scheme_display) {
+    case url_formatter::SchemeDisplay::SHOW:
+      return true;
 
-  const base::string16 colon(base::ASCIIToUTF16(":"));
-  const base::string16 scheme_separator(
-      base::ASCIIToUTF16(url::kStandardSchemeSeparator));
+    case url_formatter::SchemeDisplay::OMIT_HTTP_AND_HTTPS:
+      return !url.SchemeIs(url::kHttpsScheme) &&
+             !url.SchemeIs(url::kHttpScheme);
 
-  if (url.SchemeIsFile()) {
-    return base::ASCIIToUTF16(url::kFileScheme) + scheme_separator +
-           base::UTF8ToUTF16(url.path());
+    case url_formatter::SchemeDisplay::OMIT_CRYPTOGRAPHIC:
+      return !url.SchemeIsCryptographic();
   }
 
-  if (url.SchemeIsFileSystem()) {
-    const GURL* inner_url = url.inner_url();
-    if (inner_url->SchemeIsFile()) {
-      return base::ASCIIToUTF16(url::kFileSystemScheme) + colon +
-             FormatUrlForSecurityDisplayInternal(*inner_url, false) +
-             base::UTF8ToUTF16(url.path());
-    }
-    return base::ASCIIToUTF16(url::kFileSystemScheme) + colon +
-           FormatUrlForSecurityDisplayInternal(*inner_url, false);
-  }
-
-  const GURL origin = url.GetOrigin();
-  const std::string& scheme = origin.scheme();
-  const std::string& host = origin.host();
-
-  base::string16 result;
-  if (!omit_scheme || !url.SchemeIsHTTPOrHTTPS())
-    result = base::UTF8ToUTF16(scheme) + scheme_separator;
-  result += base::UTF8ToUTF16(host);
-
-  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;
+  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
@@ skipping 186 matching lines @@
   float subdomain_width = available_pixel_width - pixel_width_url_domain;
   if (subdomain_width <= 0)
     return base::string16(gfx::kEllipsisUTF16) + kDot + url_domain;
 
   return gfx::ElideText(url_host, font_list, available_pixel_width,
                         gfx::ELIDE_HEAD);
 }
 
 #endif  // !defined(OS_ANDROID)
 
-base::string16 FormatUrlForSecurityDisplay(const GURL& url) {
-  return FormatUrlForSecurityDisplayInternal(url, false);
-}
+base::string16 FormatUrlForSecurityDisplay(const GURL& url,
+                                           const SchemeDisplay scheme_display) {
+  if (!url.is_valid() || url.is_empty() || !url.IsStandard())
+    return url_formatter::FormatUrl(url);
 
-base::string16 FormatUrlForSecurityDisplayOmitScheme(const GURL& url) {
-  return FormatUrlForSecurityDisplayInternal(url, true);
+  const base::string16 colon(base::ASCIIToUTF16(":"));
+  const base::string16 scheme_separator(
+      base::ASCIIToUTF16(url::kStandardSchemeSeparator));
+
+  if (url.SchemeIsFile()) {
+    return base::ASCIIToUTF16(url::kFileScheme) + scheme_separator +
+           base::UTF8ToUTF16(url.path());
+  }
+
+  if (url.SchemeIsFileSystem()) {
+    const GURL* inner_url = url.inner_url();
+    if (inner_url->SchemeIsFile()) {
+      return base::ASCIIToUTF16(url::kFileSystemScheme) + colon +
+             FormatUrlForSecurityDisplay(*inner_url) +
+             base::UTF8ToUTF16(url.path());
+    }
+    return base::ASCIIToUTF16(url::kFileSystemScheme) + colon +
+           FormatUrlForSecurityDisplay(*inner_url);
+  }
+
+  const GURL origin = url.GetOrigin();
+  const std::string& scheme = origin.scheme();
+  const std::string& host = origin.host();
+
+  base::string16 result;
+  if (ShouldShowScheme(url, scheme_display))
+    result = base::UTF8ToUTF16(scheme) + scheme_separator;
+  result += base::UTF8ToUTF16(host);
+
+  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;
 }
 
 }  // namespace url_formatter