Move StartsWith[ASCII] to base namespace.

chrome/browser/autocomplete/shortcuts_provider.cc

 // Copyright (c) 2012 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/shortcuts_provider.h"
 
 #include <algorithm>
 #include <cmath>
 #include <map>
 #include <vector>
@@ skipping 128 matching lines @@
   int max_relevance;
   if (!OmniboxFieldTrial::ShortcutsScoringMaxRelevance(
       input.current_page_classification(), &max_relevance))
     max_relevance = kShortcutsProviderDefaultMaxRelevance;
   TemplateURLService* template_url_service =
       TemplateURLServiceFactory::GetForProfile(profile_);
   const base::string16 fixed_up_input(FixupUserInput(input).second);
   for (ShortcutsBackend::ShortcutMap::const_iterator it =
            FindFirstMatch(term_string, backend.get());
        it != backend->shortcuts_map().end() &&
-           StartsWith(it->first, term_string, true); ++it) {
+           base::StartsWith(it->first, term_string, true);
+       ++it) {
     // Don't return shortcuts with zero relevance.
     int relevance = CalculateScore(term_string, it->second, max_relevance);
     if (relevance) {
       matches_.push_back(ShortcutToACMatch(it->second, relevance, input,
                                            fixed_up_input));
       matches_.back().ComputeStrippedDestinationURL(template_url_service);
     }
   }
   // Remove duplicates.  Duplicates don't need to be preserved in the matches
   // because they are only used for deletions, and shortcuts deletes matches
@@ skipping 49 matching lines @@
   // Set |inline_autocompletion| and |allowed_to_be_default_match| if possible.
   // If the match is a search query this is easy: simply check whether the
   // user text is a prefix of the query.  If the match is a navigation, we
   // assume the fill_into_edit looks something like a URL, so we use
   // URLPrefix::GetInlineAutocompleteOffset() to try and strip off any prefixes
   // that the user might not think would change the meaning, but would
   // otherwise prevent inline autocompletion.  This allows, for example, the
   // input of "foo.c" to autocomplete to "foo.com" for a fill_into_edit of
   // "http://foo.com".
   if (AutocompleteMatch::IsSearchType(match.type)) {
-    if (StartsWith(match.fill_into_edit, input.text(), false)) {
+    if (base::StartsWith(match.fill_into_edit, input.text(), false)) {
       match.inline_autocompletion =
           match.fill_into_edit.substr(input.text().length());
       match.allowed_to_be_default_match =
           !input.prevent_inline_autocomplete() ||
           match.inline_autocompletion.empty();
     }
   } else {
     const size_t inline_autocomplete_offset =
         URLPrefix::GetInlineAutocompleteOffset(
             input.text(), fixed_up_input_text, true, match.fill_into_edit);
@@ skipping 67 matching lines @@
   // if |text| is empty assures we'll return the (correct) empty vector rather
   // than a vector with a single (0, NONE) match.
   if (text.empty())
     return original_class;
 
   // First check whether |text| begins with |find_text| and mark that whole
   // section as a match if so.
   base::string16 text_lowercase(base::i18n::ToLower(text));
   ACMatchClassifications match_class;
   size_t last_position = 0;
-  if (StartsWith(text_lowercase, find_text, true)) {
+  if (base::StartsWith(text_lowercase, find_text, true)) {
     match_class.push_back(
         ACMatchClassification(0, ACMatchClassification::MATCH));
     last_position = find_text.length();
     // If |text_lowercase| is actually equal to |find_text|, we don't need to
     // (and in fact shouldn't) put a trailing NONE classification after the end
     // of the string.
     if (last_position < text_lowercase.length()) {
       match_class.push_back(
           ACMatchClassification(last_position, ACMatchClassification::NONE));
     }
@@ skipping 43 matching lines @@
 
 ShortcutsBackend::ShortcutMap::const_iterator
     ShortcutsProvider::FindFirstMatch(const base::string16& keyword,
                                       ShortcutsBackend* backend) {
   DCHECK(backend);
   ShortcutsBackend::ShortcutMap::const_iterator it =
       backend->shortcuts_map().lower_bound(keyword);
   // Lower bound not necessarily matches the keyword, check for item pointed by
   // the lower bound iterator to at least start with keyword.
   return ((it == backend->shortcuts_map().end()) ||
-    StartsWith(it->first, keyword, true)) ? it :
-    backend->shortcuts_map().end();
+          base::StartsWith(it->first, keyword, true))
+             ? it
+             : backend->shortcuts_map().end();
 }
 
 int ShortcutsProvider::CalculateScore(
     const base::string16& terms,
     const ShortcutsDatabase::Shortcut& shortcut,
     int max_relevance) {
   DCHECK(!terms.empty());
   DCHECK_LE(terms.length(), shortcut.text.length());
 
   // The initial score is based on how much of the shortcut the user has typed.
@@ skipping 18 matching lines @@
   // (1.0 / each 5 additional hits), up to a maximum of 5x as long.
   const double kMaxDecaySpeedDivisor = 5.0;
   const double kNumUsesPerDecaySpeedDivisorIncrement = 5.0;
   double decay_divisor = std::min(kMaxDecaySpeedDivisor,
       (shortcut.number_of_hits + kNumUsesPerDecaySpeedDivisorIncrement - 1) /
       kNumUsesPerDecaySpeedDivisorIncrement);
 
   return static_cast<int>((base_score / exp(decay_exponent / decay_divisor)) +
       0.5);
 }