Replace string16 with base::string16.

chrome/browser/autocomplete/autocomplete_controller.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/autocomplete_controller.h"
 
 #include <set>
 #include <string>
 
 #include "base/command_line.h"
@@ skipping 32 matching lines @@
 namespace {
 
 // Converts the given match to a type (and possibly subtype) based on the AQS
 // specification. For more details, see
 // http://goto.google.com/binary-clients-logging.
 void AutocompleteMatchToAssistedQuery(
     const AutocompleteMatch::Type& match, size_t* type, size_t* subtype) {
   // This type indicates a native chrome suggestion.
   *type = 69;
   // Default value, indicating no subtype.
-  *subtype = string16::npos;
+  *subtype = base::string16::npos;
 
   switch (match) {
     case AutocompleteMatchType::SEARCH_SUGGEST: {
       *type = 0;
       return;
     }
     case AutocompleteMatchType::NAVSUGGEST: {
       *type = 5;
       return;
     }
@@ skipping 41 matching lines @@
 // the existing available autocompletions string, encoding according to the
 // spec.
 void AppendAvailableAutocompletion(size_t type,
                                    size_t subtype,
                                    int count,
                                    std::string* autocompletions) {
   if (!autocompletions->empty())
     autocompletions->append("j");
   base::StringAppendF(autocompletions, "%" PRIuS, type);
   // Subtype is optional - string16::npos indicates no subtype.
-  if (subtype != string16::npos)
+  if (subtype != base::string16::npos)
     base::StringAppendF(autocompletions, "i%" PRIuS, subtype);
   if (count > 1)
     base::StringAppendF(autocompletions, "l%d", count);
 }
 
 // Returns whether the autocompletion is trivial enough that we consider it
 // an autocompletion for which the omnibox autocompletion code did not add
 // any value.
 bool IsTrivialAutocompletion(const AutocompleteMatch& match) {
   return match.type == AutocompleteMatchType::SEARCH_WHAT_YOU_TYPED ||
@@ skipping 82 matching lines @@
   result_.Reset();  // Not really necessary.
   Stop(false);
 
   for (ACProviders::iterator i(providers_.begin()); i != providers_.end(); ++i)
     (*i)->Release();
 
   providers_.clear();  // Not really necessary.
 }
 
 void AutocompleteController::Start(const AutocompleteInput& input) {
-  const string16 old_input_text(input_.text());
+  const base::string16 old_input_text(input_.text());
   const AutocompleteInput::MatchesRequested old_matches_requested =
       input_.matches_requested();
   input_ = input;
 
   // See if we can avoid rerunning autocomplete when the query hasn't changed
   // much.  When the user presses or releases the ctrl key, the desired_tld
   // changes, and when the user finishes an IME composition, inline autocomplete
   // may no longer be prevented.  In both these cases the text itself hasn't
   // changed since the last query, and some providers can do much less work (and
   // get matches back more quickly).  Taking advantage of this reduces flicker.
@@ skipping 70 matching lines @@
     result_.Reset();
     // NOTE: We pass in false since we're trying to only clear the popup, not
     // touch the edit... this is all a mess and should be cleaned up :(
     NotifyChanged(false);
   }
 }
 
 void AutocompleteController::StartZeroSuggest(
     const GURL& url,
     AutocompleteInput::PageClassification page_classification,
-    const string16& permanent_text) {
+    const base::string16& permanent_text) {
   if (zero_suggest_provider_ != NULL) {
     DCHECK(!in_start_);  // We should not be already running a query.
     in_zero_suggest_ = true;
     zero_suggest_provider_->StartZeroSuggest(
         url, page_classification, permanent_text);
   }
 }
 
 void AutocompleteController::StopZeroSuggest() {
   if (zero_suggest_provider_ != NULL) {
@@ skipping 80 matching lines @@
   match->destination_url =
       GURL(template_url->url_ref().ReplaceSearchTerms(search_terms_args));
 }
 
 void AutocompleteController::UpdateResult(
     bool regenerate_result,
     bool force_notify_default_match_changed) {
   const bool last_default_was_valid = result_.default_match() != result_.end();
   // The following three variables are only set and used if
   // |last_default_was_valid|.
-  string16 last_default_fill_into_edit, last_default_keyword,
+  base::string16 last_default_fill_into_edit, last_default_keyword,
       last_default_associated_keyword;
   if (last_default_was_valid) {
     last_default_fill_into_edit = result_.default_match()->fill_into_edit;
     last_default_keyword = result_.default_match()->keyword;
     if (result_.default_match()->associated_keyword != NULL)
       last_default_associated_keyword =
           result_.default_match()->associated_keyword->keyword;
   }
 
   if (regenerate_result)
@@ skipping 19 matching lines @@
     // This conditional needs to match the conditional in Start that invokes
     // StartExpireTimer.
     result_.CopyOldMatches(input_, last_result, profile_);
   }
 
   UpdateKeywordDescriptions(&result_);
   UpdateAssociatedKeywords(&result_);
   UpdateAssistedQueryStats(&result_);
 
   const bool default_is_valid = result_.default_match() != result_.end();
-  string16 default_associated_keyword;
+  base::string16 default_associated_keyword;
   if (default_is_valid &&
       (result_.default_match()->associated_keyword != NULL)) {
     default_associated_keyword =
         result_.default_match()->associated_keyword->keyword;
   }
   // We've gotten async results. Send notification that the default match
   // updated if fill_into_edit, associated_keyword, or keyword differ.  (The
   // second can change if we've just started Chrome and the keyword database
   // finishes loading while processing this request.  The third can change
   // if we swapped from interpreting the input as a search--which gets
@@ skipping 12 matching lines @@
     last_time_default_match_changed_ = base::TimeTicks::Now();
 
   NotifyChanged(force_notify_default_match_changed || notify_default_match);
 }
 
 void AutocompleteController::UpdateAssociatedKeywords(
     AutocompleteResult* result) {
   if (!keyword_provider_)
     return;
 
-  std::set<string16> keywords;
+  std::set<base::string16> keywords;
   for (ACMatches::iterator match(result->begin()); match != result->end();
        ++match) {
-    string16 keyword(match->GetSubstitutingExplicitlyInvokedKeyword(profile_));
+    base::string16 keyword(
+        match->GetSubstitutingExplicitlyInvokedKeyword(profile_));
     if (!keyword.empty()) {
       keywords.insert(keyword);
       continue;
     }
 
     // Only add the keyword if the match does not have a duplicate keyword with
     // a more relevant match.
     keyword = match->associated_keyword.get() ?
         match->associated_keyword->keyword :
         keyword_provider_->GetKeywordForText(match->fill_into_edit);
     if (!keyword.empty() && !keywords.count(keyword)) {
       keywords.insert(keyword);
 
       if (!match->associated_keyword.get())
         match->associated_keyword.reset(new AutocompleteMatch(
             keyword_provider_->CreateVerbatimMatch(match->fill_into_edit,
                                                    keyword, input_)));
     } else {
       match->associated_keyword.reset();
     }
   }
 }
 
 void AutocompleteController::UpdateKeywordDescriptions(
     AutocompleteResult* result) {
-  string16 last_keyword;
+  base::string16 last_keyword;
   for (AutocompleteResult::iterator i(result->begin()); i != result->end();
        ++i) {
     if ((i->provider->type() == AutocompleteProvider::TYPE_KEYWORD &&
          !i->keyword.empty()) ||
         (i->provider->type() == AutocompleteProvider::TYPE_SEARCH &&
          AutocompleteMatch::IsSearchType(i->type))) {
       i->description.clear();
       i->description_class.clear();
       DCHECK(!i->keyword.empty());
       if (i->keyword != last_keyword) {
@@ skipping 19 matching lines @@
 }
 
 void AutocompleteController::UpdateAssistedQueryStats(
     AutocompleteResult* result) {
   if (result->empty())
     return;
 
   // Build the impressions string (the AQS part after ".").
   std::string autocompletions;
   int count = 0;
-  size_t last_type = string16::npos;
-  size_t last_subtype = string16::npos;
+  size_t last_type = base::string16::npos;
+  size_t last_subtype = base::string16::npos;
   for (ACMatches::iterator match(result->begin()); match != result->end();
        ++match) {
-    size_t type = string16::npos;
-    size_t subtype = string16::npos;
+    size_t type = base::string16::npos;
+    size_t subtype = base::string16::npos;
     AutocompleteMatchToAssistedQuery(match->type, &type, &subtype);
-    if (last_type != string16::npos &&
+    if (last_type != base::string16::npos &&
         (type != last_type || subtype != last_subtype)) {
       AppendAvailableAutocompletion(
           last_type, last_subtype, count, &autocompletions);
       count = 1;
     } else {
       count++;
     }
     last_type = type;
     last_subtype = subtype;
   }
@@ skipping 62 matching lines @@
   // the disruptive effect of belated omnibox updates, updates that
   // come after the user has had to time to read the whole dropdown
   // and doesn't expect it to change.
   const int kStopTimeMS = 1500;
   stop_timer_.Start(FROM_HERE,
                     base::TimeDelta::FromMilliseconds(kStopTimeMS),
                     base::Bind(&AutocompleteController::Stop,
                                base::Unretained(this),
                                false));
 }