Revert 88142 to fix sync_integration_tests offline.

chrome/browser/net/url_fixer_upper.cc

 // Copyright (c) 2011 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 "chrome/browser/net/url_fixer_upper.h"
 
 #include <algorithm>
 
 #if defined(OS_POSIX)
 #include "base/environment.h"
@@ skipping 388 matching lines @@
 
   // Otherwise, we need to look at things carefully.
   std::string scheme;
   if (!GetValidScheme(text, &parts->scheme, &scheme)) {
     // Couldn't determine the scheme, so just pick one.
     parts->scheme.reset();
     scheme.assign(StartsWithASCII(text, "ftp.", false) ?
         chrome::kFtpScheme : chrome::kHttpScheme);
   }
 
-  // Proceed with about and chrome schemes, but not file or nonstandard schemes.
-  if ((scheme != chrome::kAboutScheme) && (scheme != chrome::kChromeUIScheme) &&
-      ((scheme == chrome::kFileScheme) || !url_util::IsStandard(scheme.c_str(),
-           url_parse::Component(0, static_cast<int>(scheme.length())))))
+  // Not segmenting file schemes or nonstandard schemes.
+  if ((scheme == chrome::kFileScheme) ||
+      !url_util::IsStandard(scheme.c_str(),
+      url_parse::Component(0, static_cast<int>(scheme.length()))))
     return scheme;
 
   if (parts->scheme.is_valid()) {
     // Have the GURL parser do the heavy lifting for us.
     url_parse::ParseStandardURL(text.data(), static_cast<int>(text.length()),
                                 parts);
     return scheme;
   }
 
   // We need to add a scheme in order for ParseStandardURL to be happy.
   // Find the first non-whitespace character.
   std::string::const_iterator first_nonwhite = text.begin();
   while ((first_nonwhite != text.end()) && IsWhitespace(*first_nonwhite))
     ++first_nonwhite;
 
   // Construct the text to parse by inserting the scheme.
   std::string inserted_text(scheme);
-  inserted_text.append(chrome::kStandardSchemeSeparator);
+  inserted_text.append("://");
   std::string text_to_parse(text.begin(), first_nonwhite);
   text_to_parse.append(inserted_text);
   text_to_parse.append(first_nonwhite, text.end());
 
   // Have the GURL parser do the heavy lifting for us.
   url_parse::ParseStandardURL(text_to_parse.data(),
                               static_cast<int>(text_to_parse.length()),
                               parts);
 
   // Offset the results of the parse to match the original text.
@@ skipping 30 matching lines @@
       return GURL(chrome::kViewSourceScheme + std::string(":") +
           FixupURL(trimmed.substr(scheme.length() + 1),
                    desired_tld).possibly_invalid_spec());
     }
   }
 
   // We handle the file scheme separately.
   if (scheme == chrome::kFileScheme)
     return GURL(parts.scheme.is_valid() ? text : FixupPath(text));
 
-  // Parse and rebuild about: and chrome: URLs, except about:blank.
-  bool chrome_url = !LowerCaseEqualsASCII(trimmed, chrome::kAboutBlankURL) &&
-      ((scheme == chrome::kAboutScheme) || (scheme == chrome::kChromeUIScheme));
-
   // For some schemes whose layouts we understand, we rebuild it.
-  if (chrome_url || url_util::IsStandard(scheme.c_str(),
+  if (url_util::IsStandard(scheme.c_str(),
           url_parse::Component(0, static_cast<int>(scheme.length())))) {
-    // Replace the about: scheme with the chrome: scheme.
-    std::string url(chrome_url ? chrome::kChromeUIScheme : scheme);
-    url.append(chrome::kStandardSchemeSeparator);
+    std::string url(scheme);
+    url.append("://");
 
     // We need to check whether the |username| is valid because it is our
     // responsibility to append the '@' to delineate the user information from
     // the host portion of the URL.
     if (parts.username.is_valid()) {
       FixupUsername(trimmed, parts.username, &url);
       FixupPassword(trimmed, parts.password, &url);
       url.append("@");
     }
 
     FixupHost(trimmed, parts.host, parts.scheme.is_valid(), desired_tld, &url);
-    if (chrome_url && !parts.host.is_valid())
-      url.append(chrome::kChromeUIDefaultHost);
     FixupPort(trimmed, parts.port, &url);
     FixupPath(trimmed, parts.path, &url);
     FixupQuery(trimmed, parts.query, &url);
     FixupRef(trimmed, parts.ref, &url);
 
     return GURL(url);
   }
 
   // In the worst-case, we insert a scheme if the URL lacks one.
   if (!parts.scheme.is_valid()) {
     std::string fixed_scheme(scheme);
-    fixed_scheme.append(chrome::kStandardSchemeSeparator);
+    fixed_scheme.append("://");
     trimmed.insert(0, fixed_scheme);
   }
 
   return GURL(trimmed);
 }
 
 // The rules are different here than for regular fixup, since we need to handle
 // input like "hello.html" and know to look in the current directory.  Regular
 // fixup will look for cues that it is actually a file path before trying to
 // figure out what file it is.  If our logic doesn't work, we will fall back on
@@ skipping 67 matching lines @@
 
   if (part->is_valid()) {
     // Offset the location of this component.
     part->begin += offset;
 
     // This part might not have existed in the original text.
     if (part->begin < 0)
       part->reset();
   }
 }