Strips http from omnibox (and a couple of other places)

net/base/net_util.cc

-// Copyright (c) 2009 The Chromium Authors. All rights reserved.
+// Copyright (c) 2010 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 <algorithm>
 #include <map>
 #include <unicode/ucnv.h>
 #include <unicode/uidna.h>
 #include <unicode/ulocdata.h>
@@ skipping 688 matching lines @@
     // Failed, revert back to original string.
     out->resize(original_length);
   }
 
   // We get here with no IDN or on error, in which case we just append the
   // literal input.
   out->append(comp, comp_len);
   return false;
 }
 
+// If |component| is valid, its begin is incremented by |delta|.
+void AdjustComponent(int delta, url_parse::Component* component) {
+  if (!component->is_valid())
+    return;
+
+  DCHECK(delta >= 0 || component->begin >= -delta);
+  component->begin += delta;
+}
+
+// Adjusts all the components of |parsed| by |delta|, except for the scheme.
+void AdjustComponents(int delta, url_parse::Parsed* parsed) {
+  AdjustComponent(delta, &(parsed->username));
+  AdjustComponent(delta, &(parsed->password));
+  AdjustComponent(delta, &(parsed->host));
+  AdjustComponent(delta, &(parsed->port));
+  AdjustComponent(delta, &(parsed->path));
+  AdjustComponent(delta, &(parsed->query));
+  AdjustComponent(delta, &(parsed->ref));
+}
+
 // Helper for FormatUrl().
 std::wstring FormatViewSourceUrl(const GURL& url,
                                  const std::wstring& languages,
-                                 bool omit_username_password,
+                                 net::FormatUrlTypes format_types,
                                  UnescapeRule::Type unescape_rules,
                                  url_parse::Parsed* new_parsed,
                                  size_t* prefix_end,
                                  size_t* offset_for_adjustment) {
   DCHECK(new_parsed);
   const wchar_t* const kWideViewSource = L"view-source:";
   const size_t kViewSourceLengthPlus1 = 12;
 
   GURL real_url(url.possibly_invalid_spec().substr(kViewSourceLengthPlus1));
   size_t temp_offset = (*offset_for_adjustment == std::wstring::npos) ?
       std::wstring::npos : (*offset_for_adjustment - kViewSourceLengthPlus1);
   size_t* temp_offset_ptr = (*offset_for_adjustment < kViewSourceLengthPlus1) ?
       NULL : &temp_offset;
   std::wstring result = net::FormatUrl(real_url, languages,
-      omit_username_password, unescape_rules, new_parsed, prefix_end,
-      temp_offset_ptr);
+      format_types, unescape_rules, new_parsed, prefix_end, temp_offset_ptr);
   result.insert(0, kWideViewSource);
 
   // Adjust position values.
   if (new_parsed->scheme.is_nonempty()) {
     // Assume "view-source:real-scheme" as a scheme.
     new_parsed->scheme.len += kViewSourceLengthPlus1;
   } else {
     new_parsed->scheme.begin = 0;
     new_parsed->scheme.len = kViewSourceLengthPlus1 - 1;
   }
-  if (new_parsed->username.is_nonempty())
-    new_parsed->username.begin += kViewSourceLengthPlus1;
-  if (new_parsed->password.is_nonempty())
-    new_parsed->password.begin += kViewSourceLengthPlus1;
-  if (new_parsed->host.is_nonempty())
-    new_parsed->host.begin += kViewSourceLengthPlus1;
-  if (new_parsed->port.is_nonempty())
-    new_parsed->port.begin += kViewSourceLengthPlus1;
-  if (new_parsed->path.is_nonempty())
-    new_parsed->path.begin += kViewSourceLengthPlus1;
-  if (new_parsed->query.is_nonempty())
-    new_parsed->query.begin += kViewSourceLengthPlus1;
-  if (new_parsed->ref.is_nonempty())
-    new_parsed->ref.begin += kViewSourceLengthPlus1;
+  AdjustComponents(kViewSourceLengthPlus1, new_parsed);
   if (prefix_end)
     *prefix_end += kViewSourceLengthPlus1;
   if (temp_offset_ptr) {
     *offset_for_adjustment = (temp_offset == std::wstring::npos) ?
         std::wstring::npos : (temp_offset + kViewSourceLengthPlus1);
   }
   return result;
 }
 
 }  // namespace
 
 namespace net {
 
+const FormatUrlType kFormatUrlOmitNothing          = 0;
+const FormatUrlType kFormatUrlOmitUsernamePassword = 1 << 0;
+const FormatUrlType kFormatUrlOmitHTTP             = 1 << 1;
+const FormatUrlType kFormatUrlOmitAll = kFormatUrlOmitUsernamePassword |
+                                        kFormatUrlOmitHTTP;
+
 std::set<int> explicitly_allowed_ports;
 
 // Appends the substring |in_component| inside of the URL |spec| to |output|,
 // and the resulting range will be filled into |out_component|. |unescape_rules|
 // defines how to clean the URL for human readability.  |offset_for_adjustment|
 // is an offset into |output| which will be adjusted based on how it maps to the
 // component being converted; if it is less than output->length(), it will be
 // untouched, and if it is greater than output->length() + in_component.len it
 // will be shortened by the difference in lengths between the input and output
 // components.  Otherwise it points into the component being converted, and is
@@ skipping 588 matching lines @@
     } else if (offset_past_current_output != std::wstring::npos) {
       *offset_for_adjustment += out_component->len - in_component.len;
     }
   } else {
     out_component->reset();
   }
 }
 
 std::wstring FormatUrl(const GURL& url,
                        const std::wstring& languages,
-                       bool omit_username_password,
+                       FormatUrlTypes format_types,
                        UnescapeRule::Type unescape_rules,
                        url_parse::Parsed* new_parsed,
                        size_t* prefix_end,
                        size_t* offset_for_adjustment) {
   url_parse::Parsed parsed_temp;
   if (!new_parsed)
     new_parsed = &parsed_temp;
   size_t offset_temp = std::wstring::npos;
   if (!offset_for_adjustment)
     offset_for_adjustment = &offset_temp;
 
   std::wstring url_string;
 
   // Check for empty URLs or 0 available text width.
   if (url.is_empty()) {
     if (prefix_end)
       *prefix_end = 0;
     *offset_for_adjustment = std::wstring::npos;
     return url_string;
   }
 
   // Special handling for view-source:.  Don't use chrome::kViewSourceScheme
   // because this library shouldn't depend on chrome.
   const char* const kViewSource = "view-source";
   const char* const kViewSourceTwice = "view-source:view-source:";
   // Rejects view-source:view-source:... to avoid deep recursive call.
   if (url.SchemeIs(kViewSource) &&
       !StartsWithASCII(url.possibly_invalid_spec(), kViewSourceTwice, false)) {
-    return FormatViewSourceUrl(url, languages, omit_username_password,
+    return FormatViewSourceUrl(url, languages, format_types,
         unescape_rules, new_parsed, prefix_end, offset_for_adjustment);
   }
 
   // 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_parse::Parsed& parsed = url.parsed_for_possibly_invalid_spec();
   if (*offset_for_adjustment >= spec.length())
     *offset_for_adjustment = std::wstring::npos;
 
   // Copy everything before the username (the scheme and the separators.)
   // These are ASCII.
   std::copy(spec.begin(),
       spec.begin() + parsed.CountCharactersBefore(url_parse::Parsed::USERNAME,
                                                   true),
       std::back_inserter(url_string));
+
+  const wchar_t* const kHTTP = L"http://";
+  const size_t kHTTPSize = std::wstring(kHTTP).size();
+  bool omit_http = ((format_types & kFormatUrlOmitHTTP) != 0 &&
+                    url_string == kHTTP);
+
   new_parsed->scheme = parsed.scheme;
 
-  if (omit_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();
     if ((*offset_for_adjustment != std::wstring::npos) &&
         (parsed.username.is_nonempty() || parsed.password.is_nonempty())) {
       if (parsed.username.is_nonempty() && parsed.password.is_nonempty()) {
         // The seeming off-by-one and off-by-two in these first two lines are to
         // account for the ':' after the username and '@' after the password.
@@ skipping 79 matching lines @@
     } else if (offset_past_current_output != std::wstring::npos) {
       // We clamped the offset near the beginning of this function to ensure it
       // was within the input URL.  If we reach here, the input was something
       // invalid and non-parseable such that the offset was past any component
       // we could figure out.  In this case it won't be represented in the
       // output string, so reset it.
       *offset_for_adjustment = std::wstring::npos;
     }
   }
 
+  // If we need to strip out http do it after the fact. This way we don't need
+  // to worry about how offset_for_adjustment is interpreted.
+  if (omit_http && !url_string.compare(0, kHTTPSize, kHTTP)) {
+    url_string = url_string.substr(kHTTPSize);
+    if (*offset_for_adjustment != std::wstring::npos) {
+      if (*offset_for_adjustment < kHTTPSize)
+        *offset_for_adjustment = std::wstring::npos;
+      else
+        *offset_for_adjustment -= kHTTPSize;
+    }
+    if (prefix_end)
+      *prefix_end -= kHTTPSize;
+
+    // Adjust new_parsed.
+    DCHECK(new_parsed->scheme.is_valid());
+    int delta = -(new_parsed->scheme.len + 3);  // +3 for ://.
+    new_parsed->scheme.reset();
+    AdjustComponents(delta, new_parsed);
+  }
+
   return url_string;
 }
 
 GURL SimplifyUrlForRequest(const GURL& url) {
   DCHECK(url.is_valid());
   GURL::Replacements replacements;
   replacements.ClearUsername();
   replacements.ClearPassword();
   replacements.ClearRef();
   return url.ReplaceComponents(replacements);
@@ skipping 144 matching lines @@
 
   IPv6SupportResults(IPV6_GLOBAL_ADDRESS_MISSING);
   return false;
 #else
   NOTIMPLEMENTED();
   return true;
 #endif  // defined(various platforms)
 }
 
 }  // namespace net