Coalesce more hardcoded schemes to using predefined constants.

chrome/browser/autocomplete/history_url_provider.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 "chrome/browser/autocomplete/history_url_provider.h"
 
 #include <algorithm>
 
 #include "base/basictypes.h"
 #include "base/histogram.h"
 #include "base/message_loop.h"
 #include "base/string_util.h"
 #include "chrome/browser/history/history.h"
 #include "chrome/browser/history/history_backend.h"
 #include "chrome/browser/history/history_database.h"
 #include "chrome/browser/net/url_fixer_upper.h"
 #include "chrome/browser/profile.h"
 #include "chrome/common/gfx/text_elider.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/common/pref_service.h"
 #include "chrome/common/sqlite_utils.h"
+#include "chrome/common/url_constants.h"
 #include "googleurl/src/gurl.h"
 #include "googleurl/src/url_parse.h"
 #include "googleurl/src/url_util.h"
 #include "net/base/net_util.h"
 
 using base::Time;
 using base::TimeDelta;
 using base::TimeTicks;
 
 HistoryURLProviderParams::HistoryURLProviderParams(
@@ skipping 305 matching lines @@
   // Fixup and canonicalize user input.
   const GURL canonical_gurl(URLFixerUpper::FixupURL(WideToUTF8(input),
       std::string()));
   std::wstring output(UTF8ToWide(canonical_gurl.possibly_invalid_spec()));
   if (output.empty())
     return input;  // This probably won't happen, but there are no guarantees.
 
   // Don't prepend a scheme when the user didn't have one.  Since the fixer
   // upper only prepends the "http" scheme, that's all we need to check for.
   url_parse::Component scheme;
-  if (canonical_gurl.SchemeIs("http") &&
-      !url_util::FindAndCompareScheme(WideToUTF8(input), "http", &scheme))
+  if (canonical_gurl.SchemeIs(chrome::kHttpScheme) &&
+      !url_util::FindAndCompareScheme(WideToUTF8(input), chrome::kHttpScheme,
+                                      &scheme))
     TrimHttpPrefix(&output);
 
   // Make the number of trailing slashes on the output exactly match the input.
   // Examples of why not doing this would matter:
   // * The user types "a" and has this fixed up to "a/".  Now no other sites
   //   beginning with "a" will match.
   // * The user types "file:" and has this fixed up to "file://".  Now inline
   //   autocomplete will append too few slashes, resulting in e.g. "file:/b..."
   //   instead of "file:///b..."
   // * The user types "http:/" and has this fixed up to "http:".  Now inline
@@ skipping 14 matching lines @@
     output.append(num_input_slashes - num_output_slashes, '/');
   else if (num_output_slashes > num_input_slashes)
     output.erase(output.length() - num_output_slashes + num_input_slashes);
 
   return output;
 }
 
 // static
 size_t HistoryURLProvider::TrimHttpPrefix(std::wstring* url) {
   url_parse::Component scheme;
-  if (!url_util::FindAndCompareScheme(WideToUTF8(*url), "http", &scheme))
+  if (!url_util::FindAndCompareScheme(WideToUTF8(*url), chrome::kHttpScheme,
+                                      &scheme))
     return 0;  // Not "http".
 
   // Erase scheme plus up to two slashes.
   size_t prefix_len = scheme.end() + 1;  // "http:"
   const size_t after_slashes = std::min(url->length(),
                                         static_cast<size_t>(scheme.end() + 3));
   while ((prefix_len < after_slashes) && ((*url)[prefix_len] == L'/'))
     ++prefix_len;
   if (prefix_len == url->length())
     url->clear();
@@ skipping 192 matching lines @@
   matches_.clear();
 
   if ((input.type() != AutocompleteInput::UNKNOWN) &&
       (input.type() != AutocompleteInput::REQUESTED_URL) &&
       (input.type() != AutocompleteInput::URL))
     return;
 
   // Create a match for exactly what the user typed.  This will always be one
   // of the top two results we return.
   const bool trim_http = !url_util::FindAndCompareScheme(
-      WideToUTF8(input.text()), "http", NULL);
+      WideToUTF8(input.text()), chrome::kHttpScheme, NULL);
   SuggestExactInput(input, trim_http);
 
   // We'll need the history service to run both passes, so try to obtain it.
   HistoryService* const history_service = profile_ ?
       profile_->GetHistoryService(Profile::EXPLICIT_ACCESS) : history_service_;
   if (!history_service)
     return;
 
   // Create the data structure for the autocomplete passes.  We'll save this off
   // onto the |params_| member for later deletion below if we need to run pass
@@ skipping 221 matching lines @@
       history_match.input_location - offset, params->input.text().length(),
       match.contents.length(), ACMatchClassification::URL,
       &match.contents_class);
   match.description = info.title();
   AutocompleteMatch::ClassifyMatchInString(params->input.text(), info.title(),
                                            ACMatchClassification::NONE,
                                            &match.description_class);
 
   return match;
 }