Replace string16 with base::string16.

chrome/browser/autocomplete/zero_suggest_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/zero_suggest_provider.h"
 
 #include "base/callback.h"
 #include "base/i18n/case_conversion.h"
 #include "base/json/json_string_value_serializer.h"
 #include "base/metrics/histogram.h"
@@ skipping 129 matching lines @@
   done_ = true;
 
   ConvertResultsToAutocompleteMatches();
   if (!matches_.empty())
     listener_->OnProviderUpdate(true);
 }
 
 void ZeroSuggestProvider::StartZeroSuggest(
     const GURL& current_page_url,
     AutocompleteInput::PageClassification page_classification,
-    const string16& permanent_text) {
+    const base::string16& permanent_text) {
   Stop(true);
   field_trial_triggered_ = false;
   field_trial_triggered_in_session_ = false;
   permanent_text_ = permanent_text;
   current_query_ = current_page_url.spec();
   current_page_classification_ = page_classification;
   current_url_match_ = MatchForCurrentURL();
 
   const TemplateURL* default_provider =
      template_url_service_->GetDefaultSearchProvider();
   if (default_provider == NULL)
     return;
-  string16 prefix;
+  base::string16 prefix;
   TemplateURLRef::SearchTermsArgs search_term_args(prefix);
   search_term_args.current_page_url = current_query_;
   GURL suggest_url(default_provider->suggestions_url_ref().
                    ReplaceSearchTerms(search_term_args));
   if (!SearchProvider::CanSendURL(
           current_page_url, suggest_url,
           template_url_service_->GetDefaultSearchProvider(),
           page_classification, profile_) ||
       !OmniboxFieldTrial::InZeroSuggestFieldTrial())
     return;
@@ skipping 19 matching lines @@
 }
 
 ZeroSuggestProvider::~ZeroSuggestProvider() {
 }
 
 void ZeroSuggestProvider::FillResults(
     const Value& root_val,
     int* verbatim_relevance,
     SearchProvider::SuggestResults* suggest_results,
     SearchProvider::NavigationResults* navigation_results) {
-  string16 query;
+  base::string16 query;
   const ListValue* root_list = NULL;
   const ListValue* results = NULL;
   const ListValue* relevances = NULL;
   // The response includes the query, which should be empty for ZeroSuggest
   // responses.
   if (!root_val.GetAsList(&root_list) || !root_list->GetString(0, &query) ||
       (!query.empty()) || !root_list->GetList(1, &results))
     return;
 
   // 3rd element: Description list.
@@ skipping 21 matching lines @@
     bool triggered = false;
     extras->GetBoolean("google:fieldtrialtriggered", &triggered);
     field_trial_triggered_ |= triggered;
     field_trial_triggered_in_session_ |= triggered;
   }
 
   // Clear the previous results now that new results are available.
   suggest_results->clear();
   navigation_results->clear();
 
-  string16 result, title;
+  base::string16 result, title;
   std::string type;
   for (size_t index = 0; results->GetString(index, &result); ++index) {
     // Google search may return empty suggestions for weird input characters,
     // they make no sense at all and can cause problems in our code.
     if (result.empty())
       continue;
 
     int relevance = kDefaultZeroSuggestRelevance;
 
     // Apply valid suggested relevance scores; discard invalid lists.
     if (relevances != NULL && !relevances->GetInteger(index, &relevance))
       relevances = NULL;
     if (types && types->GetString(index, &type) && (type == "NAVIGATION")) {
       // Do not blindly trust the URL coming from the server to be valid.
       GURL url(URLFixerUpper::FixupURL(UTF16ToUTF8(result), std::string()));
       if (url.is_valid()) {
         if (descriptions != NULL)
           descriptions->GetString(index, &title);
         navigation_results->push_back(SearchProvider::NavigationResult(
             *this, url, title, false, relevance, relevances != NULL));
       }
     } else {
       suggest_results->push_back(SearchProvider::SuggestResult(
-          result, result, string16(), std::string(), std::string(), false,
+          result, result, base::string16(), std::string(), std::string(), false,
           relevance, relevances != NULL, false));
     }
   }
 }
 
 void ZeroSuggestProvider::AddSuggestResultsToMap(
     const SearchProvider::SuggestResults& results,
     const TemplateURL* template_url,
     SearchProvider::MatchMap* map) {
   for (size_t i = 0; i < results.size(); ++i) {
     AddMatchToMap(results[i].relevance(), AutocompleteMatchType::SEARCH_SUGGEST,
                   template_url, results[i].suggestion(), i, map);
   }
 }
 
 void ZeroSuggestProvider::AddMatchToMap(int relevance,
                                         AutocompleteMatch::Type type,
                                         const TemplateURL* template_url,
-                                        const string16& query_string,
+                                        const base::string16& query_string,
                                         int accepted_suggestion,
                                         SearchProvider::MatchMap* map) {
   // Pass in query_string as the input_text since we don't want any bolding.
   // TODO(samarth|melevin): use the actual omnibox margin here as well instead
   // of passing in -1.
   AutocompleteMatch match = SearchProvider::CreateSearchSuggestion(
       this, AutocompleteInput(), query_string, relevance, type, false,
-      query_string, string16(), template_url, query_string, std::string(),
+      query_string, base::string16(), template_url, query_string, std::string(),
       accepted_suggestion, -1, true);
   if (!match.destination_url.is_valid())
     return;
 
   // Try to add |match| to |map|.  If a match for |query_string| is already in
   // |map|, replace it if |match| is more relevant.
   // NOTE: Keep this ToLower() call in sync with url_database.cc.
   SearchProvider::MatchKey match_key(
       std::make_pair(base::i18n::ToLower(query_string), std::string()));
   const std::pair<SearchProvider::MatchMap::iterator, bool> i(map->insert(
@@ skipping 129 matching lines @@
   for (SearchProvider::MatchMap::const_iterator it(query_matches_map_.begin());
        it != query_matches_map_.end(); ++it)
     matches_.push_back(it->second);
 
   for (SearchProvider::NavigationResults::const_iterator it(
        navigation_results_.begin()); it != navigation_results_.end(); ++it)
     matches_.push_back(NavigationToMatch(*it));
 }
 
 AutocompleteMatch ZeroSuggestProvider::MatchForCurrentURL() {
-  AutocompleteInput input(permanent_text_, string16::npos, string16(),
+  AutocompleteInput input(permanent_text_, base::string16::npos, base::string16(),
                           GURL(current_query_), current_page_classification_,
                           false, false, true, AutocompleteInput::ALL_MATCHES);
 
   AutocompleteMatch match;
   AutocompleteClassifierFactory::GetForProfile(profile_)->Classify(
       permanent_text_, false, true, &match, NULL);
   match.is_history_what_you_typed_match = false;
   match.allowed_to_be_default_match = true;
 
   // The placeholder suggestion for the current URL has high relevance so
   // that it is in the first suggestion slot and inline autocompleted. It
   // gets dropped as soon as the user types something.
   match.relevance = verbatim_relevance_;
 
   return match;
 }