Coalesce more hardcoded schemes to using predefined constants.

chrome/browser/net/url_fixer_upper.cc

 // Copyright (c) 2006-2008 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 <algorithm>
 
 #include "chrome/browser/net/url_fixer_upper.h"
 
 #include "base/file_util.h"
 #include "base/logging.h"
 #include "base/string_util.h"
 #include "chrome/common/gfx/text_elider.h"
+#include "chrome/common/url_constants.h"
 #include "googleurl/src/gurl.h"
 #include "googleurl/src/url_canon.h"
 #include "googleurl/src/url_file.h"
 #include "googleurl/src/url_parse.h"
 #include "googleurl/src/url_util.h"
 #include "net/base/escape.h"
 #include "net/base/net_util.h"
 #include "net/base/registry_controlled_domain.h"
 
 using namespace std;
@@ skipping 273 matching lines @@
         // We need to fix up the segmentation for "www:123/".  For this case, we
         // will add an HTTP scheme later and make the URL parser happy.
         // TODO(pkasting): Maybe we should try to use GURL's parser for this?
         HasPort(text, parts->scheme)))
       parts->scheme.reset();
   }
 
   // When we couldn't find a scheme in the input, we need to pick one.  Normally
   // we choose http, but if the URL starts with "ftp.", we match other browsers
   // and choose ftp.
-  if (!parts->scheme.is_valid())
-    scheme.assign(StartsWithASCII(text, "ftp.", false) ? "ftp" : "http");
+  if (!parts->scheme.is_valid()) {
+    scheme.assign(StartsWithASCII(text, "ftp.", false) ?
+        chrome::kFtpScheme : chrome::kHttpScheme);
+  }
 
   // Cannonicalize the scheme.
   StringToLowerASCII(&scheme);
 
   // Not segmenting file schemes or nonstandard schemes.
-  if ((scheme == "file") ||
+  if ((scheme == chrome::kFileScheme) ||
       !url_util::IsStandard(scheme.c_str(), static_cast<int>(scheme.length()),
       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;
   }
@@ skipping 146 matching lines @@
 }
 wstring URLFixerUpper::FixupURL(const wstring& text,
                  const wstring& desired_tld) {
   return UTF8ToWide(FixupURL(WideToUTF8(text), WideToUTF8(desired_tld)));
 }
 wstring URLFixerUpper::FixupRelativeFile(const wstring& base_dir,
                           const wstring& text) {
   return UTF8ToWide(FixupRelativeFile(FilePath::FromWStringHack(base_dir),
                                       FilePath::FromWStringHack(text)));
 }