Replace string16 with base::string16.

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 116 matching lines @@
   initialized_ = true;
 }
 
 void ShortcutsProvider::GetMatches(const AutocompleteInput& input) {
   scoped_refptr<history::ShortcutsBackend> backend =
       ShortcutsBackendFactory::GetForProfileIfExists(profile_);
   if (!backend.get())
     return;
   // Get the URLs from the shortcuts database with keys that partially or
   // completely match the search term.
-  string16 term_string(base::i18n::ToLower(input.text()));
+  base::string16 term_string(base::i18n::ToLower(input.text()));
   DCHECK(!term_string.empty());
 
   int max_relevance;
   if (!OmniboxFieldTrial::ShortcutsScoringMaxRelevance(
       input.current_page_classification(), &max_relevance))
     max_relevance = AutocompleteResult::kLowestDefaultScore - 1;
 
   for (history::ShortcutsBackend::ShortcutMap::const_iterator it =
            FindFirstMatch(term_string, backend.get());
        it != backend->shortcuts_map().end() &&
@@ skipping 28 matching lines @@
       max_relevance = std::min(max_relevance, it->relevance);
       it->relevance = max_relevance;
       if (max_relevance > 1)
         --max_relevance;
     }
   }
 }
 
 AutocompleteMatch ShortcutsProvider::ShortcutToACMatch(
     int relevance,
-    const string16& term_string,
+    const base::string16& term_string,
     const history::ShortcutsBackend::Shortcut& shortcut) {
   DCHECK(!term_string.empty());
   AutocompleteMatch match(shortcut.match_core.ToMatch());
   match.provider = this;
   match.relevance = relevance;
   match.deletable = true;
   DCHECK(match.destination_url.is_valid());
   match.RecordAdditionalInfo("number of hits", shortcut.number_of_hits);
   match.RecordAdditionalInfo("last access time", shortcut.last_access_time);
   match.RecordAdditionalInfo("original input text", UTF16ToUTF8(shortcut.text));
 
   // Try to mark pieces of the contents and description as matches if they
   // appear in |term_string|.
   WordMap terms_map(CreateWordMapForString(term_string));
   if (!terms_map.empty()) {
     match.contents_class = ClassifyAllMatchesInString(term_string, terms_map,
         match.contents, match.contents_class);
     match.description_class = ClassifyAllMatchesInString(term_string, terms_map,
         match.description, match.description_class);
   }
   return match;
 }
 
 // static
 ShortcutsProvider::WordMap ShortcutsProvider::CreateWordMapForString(
-    const string16& text) {
+    const base::string16& text) {
   // First, convert |text| to a vector of the unique words in it.
   WordMap word_map;
   base::i18n::BreakIterator word_iter(text,
                                       base::i18n::BreakIterator::BREAK_WORD);
   if (!word_iter.Init())
     return word_map;
   std::vector<string16> words;
   while (word_iter.Advance()) {
     if (word_iter.IsWord())
       words.push_back(word_iter.GetString());
@@ skipping 10 matching lines @@
   // existing implementations that found that it was already true everywhere.)
   std::reverse(words.begin(), words.end());
   for (std::vector<string16>::const_iterator i(words.begin()); i != words.end();
        ++i)
     word_map.insert(std::make_pair((*i)[0], *i));
   return word_map;
 }
 
 // static
 ACMatchClassifications ShortcutsProvider::ClassifyAllMatchesInString(
-    const string16& find_text,
+    const base::string16& find_text,
     const WordMap& find_words,
-    const string16& text,
+    const base::string16& text,
     const ACMatchClassifications& original_class) {
   DCHECK(!find_text.empty());
   DCHECK(!find_words.empty());
 
   // The code below assumes |text| is nonempty and therefore the resulting
   // classification vector should always be nonempty as well.  Returning early
   // 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.
-  string16 text_lowercase(base::i18n::ToLower(text));
+  base::string16 text_lowercase(base::i18n::ToLower(text));
   ACMatchClassifications match_class;
   size_t last_position = 0;
   if (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()) {
@@ skipping 13 matching lines @@
   // of |text_lowercase| beginning with |last_position|.  Accept the first
   // matching word found (which should be the longest possible match at this
   // location, given the construction of |find_words|) and add a MATCH region to
   // |match_class|, moving |last_position| to be after the matching word.  If we
   // found no matching words, move to the next character and repeat.
   while (last_position < text_lowercase.length()) {
     std::pair<WordMap::const_iterator, WordMap::const_iterator> range(
         find_words.equal_range(text_lowercase[last_position]));
     size_t next_character = last_position + 1;
     for (WordMap::const_iterator i(range.first); i != range.second; ++i) {
-      const string16& word = i->second;
+      const base::string16& word = i->second;
       size_t word_end = last_position + word.length();
       if ((word_end <= text_lowercase.length()) &&
           !text_lowercase.compare(last_position, word.length(), word)) {
         // Collapse adjacent ranges into one.
         if (match_class.back().offset == last_position)
           match_class.pop_back();
 
         AutocompleteMatch::AddLastClassificationIfNecessary(&match_class,
             last_position, ACMatchClassification::MATCH);
         if (word_end < text_lowercase.length()) {
           match_class.push_back(
               ACMatchClassification(word_end, ACMatchClassification::NONE));
         }
         last_position = word_end;
         break;
       }
     }
     last_position = std::max(last_position, next_character);
   }
 
   return AutocompleteMatch::MergeClassifications(original_class, match_class);
 }
 
 history::ShortcutsBackend::ShortcutMap::const_iterator
-    ShortcutsProvider::FindFirstMatch(const string16& keyword,
+    ShortcutsProvider::FindFirstMatch(const base::string16& keyword,
                                       history::ShortcutsBackend* backend) {
   DCHECK(backend);
   history::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();
 }
 
 int ShortcutsProvider::CalculateScore(
-    const string16& terms,
+    const base::string16& terms,
     const history::ShortcutsBackend::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.
   // Using the square root of the typed fraction boosts the base score rapidly
   // as characters are typed, compared with simply using the typed fraction
   // directly. This makes sense since the first characters typed are much more
   // important for determining how likely it is a user wants a particular
@@ skipping 14 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);
 }