Replace string16 with base::string16.

chrome/browser/autocomplete/history_url_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/history_url_provider.h"
 
 #include <algorithm>
 
 #include "base/basictypes.h"
 #include "base/bind.h"
@@ skipping 68 matching lines @@
   else
     matches->push_back(match);
 
   return true;
 }
 
 // Given the user's |input| and a |match| created from it, reduce the match's
 // URL to just a host.  If this host still matches the user input, return it.
 // Returns the empty string on failure.
 GURL ConvertToHostOnly(const history::HistoryMatch& match,
-                       const string16& input) {
+                       const base::string16& input) {
   // See if we should try to do host-only suggestions for this URL. Nonstandard
   // schemes means there's no authority section, so suggesting the host name
   // is useless. File URLs are standard, but host suggestion is not useful for
   // them either.
   const GURL& url = match.url_info.url();
   if (!url.is_valid() || !url.IsStandard() || url.SchemeIsFile())
     return GURL();
 
   // Transform to a host-only match.  Bail if the host no longer matches the
   // user input (e.g. because the user typed more than just a host).
   GURL host = url.GetWithEmptyPath();
   if ((host.spec().length() < (match.input_location + input.length())))
     return GURL();  // User typing is longer than this host suggestion.
 
-  const string16 spec = UTF8ToUTF16(host.spec());
+  const base::string16 spec = UTF8ToUTF16(host.spec());
   if (spec.compare(match.input_location, input.length(), input))
     return GURL();  // User typing is no longer a prefix.
 
   return host;
 }
 
 // Acts like the > operator for URLInfo classes.
 bool CompareHistoryMatch(const history::HistoryMatch& a,
                          const history::HistoryMatch& b) {
   // A promoted match is better than non-promoted.
@@ skipping 82 matching lines @@
 // member strings, then returning those strings when its own getters are called.
 // This will typically be constructed on the UI thread from
 // UIThreadSearchTermsData but is subsequently safe to use on any thread.
 class SearchTermsDataSnapshot : public SearchTermsData {
  public:
   explicit SearchTermsDataSnapshot(const SearchTermsData& search_terms_data);
   virtual ~SearchTermsDataSnapshot();
 
   virtual std::string GoogleBaseURLValue() const OVERRIDE;
   virtual std::string GetApplicationLocale() const OVERRIDE;
-  virtual string16 GetRlzParameterValue() const OVERRIDE;
+  virtual base::string16 GetRlzParameterValue() const OVERRIDE;
   virtual std::string GetSearchClient() const OVERRIDE;
   virtual std::string ForceInstantResultsParam(
       bool for_prerender) const OVERRIDE;
   virtual std::string InstantExtendedEnabledParam() const OVERRIDE;
   virtual std::string NTPIsThemedParam() const OVERRIDE;
 
  private:
   std::string google_base_url_value_;
   std::string application_locale_;
-  string16 rlz_parameter_value_;
+  base::string16 rlz_parameter_value_;
   std::string search_client_;
   std::string force_instant_results_param_;
   std::string instant_extended_enabled_param_;
   std::string ntp_is_themed_param_;
 
   DISALLOW_COPY_AND_ASSIGN(SearchTermsDataSnapshot);
 };
 
 SearchTermsDataSnapshot::SearchTermsDataSnapshot(
     const SearchTermsData& search_terms_data)
@@ skipping 11 matching lines @@
 }
 
 std::string SearchTermsDataSnapshot::GoogleBaseURLValue() const {
   return google_base_url_value_;
 }
 
 std::string SearchTermsDataSnapshot::GetApplicationLocale() const {
   return application_locale_;
 }
 
-string16 SearchTermsDataSnapshot::GetRlzParameterValue() const {
+base::string16 SearchTermsDataSnapshot::GetRlzParameterValue() const {
   return rlz_parameter_value_;
 }
 
 std::string SearchTermsDataSnapshot::GetSearchClient() const {
   return search_client_;
 }
 
 std::string SearchTermsDataSnapshot::ForceInstantResultsParam(
     bool for_prerender) const {
   return force_instant_results_param_;
@@ skipping 132 matching lines @@
 }
 
 void HistoryURLProvider::Stop(bool clear_cached_results) {
   done_ = true;
 
   if (params_)
     params_->cancel_flag.Set();
 }
 
 AutocompleteMatch HistoryURLProvider::SuggestExactInput(
-    const string16& text,
+    const base::string16& text,
     const GURL& destination_url,
     bool trim_http) {
   AutocompleteMatch match(this, 0, false,
                           AutocompleteMatchType::URL_WHAT_YOU_TYPED);
 
   if (destination_url.is_valid()) {
     match.destination_url = destination_url;
 
     // Trim off "http://" if the user didn't type it.
     // NOTE: We use TrimHttpPrefix() here rather than StringForURLDisplay() to
     // strip the scheme as we need to know the offset so we can adjust the
     // |match_location| below.  StringForURLDisplay() and TrimHttpPrefix() have
     // slightly different behavior as well (the latter will strip even without
     // two slashes after the scheme).
     DCHECK(!trim_http || !AutocompleteInput::HasHTTPScheme(text));
-    string16 display_string(StringForURLDisplay(destination_url, false, false));
+    base::string16 display_string(
+        StringForURLDisplay(destination_url, false, false));
     const size_t offset = trim_http ? TrimHttpPrefix(&display_string) : 0;
     match.fill_into_edit =
         AutocompleteInput::FormattedStringWithEquivalentMeaning(destination_url,
                                                                 display_string);
     match.allowed_to_be_default_match = true;
     // NOTE: Don't set match.inline_autocompletion to something non-empty here;
     // it's surprising and annoying.
 
     // Try to highlight "innermost" match location.  If we fix up "w" into
     // "www.w.com", we want to highlight the fifth character, not the first.
@@ skipping 91 matching lines @@
       // to work with.  CullRedirects() will then reduce the list to
       // the best kMaxMatches results.
       db->AutocompleteForPrefix(
           UTF16ToUTF8(i->prefix + params->input.text()),
           kMaxMatches * 2,
           (backend == NULL),
           &url_matches);
       for (history::URLRows::const_iterator j(url_matches.begin());
            j != url_matches.end(); ++j) {
         const URLPrefix* best_prefix =
-            URLPrefix::BestURLPrefix(UTF8ToUTF16(j->url().spec()), string16());
+            URLPrefix::BestURLPrefix(UTF8ToUTF16(j->url().spec()),
+                                     base::string16());
         DCHECK(best_prefix != NULL);
         history_matches.push_back(history::HistoryMatch(*j, i->prefix.length(),
             i->num_components == 0,
             i->num_components >= best_prefix->num_components));
       }
     }
   }
 
   // Create sorted list of suggestions.
   CullPoorMatches(*params, &history_matches);
@@ skipping 277 matching lines @@
 
   // If there are any other matches, then don't promote this match here, in
   // hopes the caller will be able to inline autocomplete a better suggestion.
   // DoAutocomplete() will fall back on this match if inline autocompletion
   // fails.  This matches how we react to never-visited URL inputs in the non-
   // intranet case.
   if (type == UNVISITED_INTRANET && !matches->empty())
     return false;
 
   // Put it on the front of the HistoryMatches for redirect culling.
-  CreateOrPromoteMatch(classifier.url_row(), string16::npos, false, matches,
-                       true, true);
+  CreateOrPromoteMatch(classifier.url_row(), base::string16::npos, false,
+                       matches, true, true);
   return true;
 }
 
 bool HistoryURLProvider::CanFindIntranetURL(
     history::URLDatabase* db,
     const AutocompleteInput& input) const {
   // Normally passing the first two conditions below ought to guarantee the
   // third condition, but because FixupUserInput() can run and modify the
   // input's text and parts between Parse() and here, it seems better to be
   // paranoid and check.
@@ skipping 213 matching lines @@
       std::string() : params.languages;
   const net::FormatUrlTypes format_types = net::kFormatUrlOmitAll &
       ~((params.trim_http && !history_match.match_in_scheme) ?
           0 : net::kFormatUrlOmitHTTP);
   match.fill_into_edit =
       AutocompleteInput::FormattedStringWithEquivalentMeaning(info.url(),
           net::FormatUrl(info.url(), languages, format_types,
                          net::UnescapeRule::SPACES, NULL, NULL,
                          &inline_autocomplete_offset));
   if (!params.prevent_inline_autocomplete &&
-      (inline_autocomplete_offset != string16::npos)) {
+      (inline_autocomplete_offset != base::string16::npos)) {
     DCHECK(inline_autocomplete_offset <= match.fill_into_edit.length());
     match.inline_autocompletion =
         match.fill_into_edit.substr(inline_autocomplete_offset);
   }
   // The latter part of the test effectively asks "is the inline completion
   // empty?" (i.e., is this match effectively the what-you-typed match?).
   match.allowed_to_be_default_match = !params.prevent_inline_autocomplete ||
-      ((inline_autocomplete_offset != string16::npos) &&
+      ((inline_autocomplete_offset != base::string16::npos) &&
        (inline_autocomplete_offset >= match.fill_into_edit.length()));
 
   size_t match_start = history_match.input_location;
   match.contents = net::FormatUrl(info.url(), languages,
       format_types, net::UnescapeRule::SPACES, NULL, NULL, &match_start);
-  if ((match_start != string16::npos) &&
-      (inline_autocomplete_offset != string16::npos) &&
+  if ((match_start != base::string16::npos) &&
+      (inline_autocomplete_offset != base::string16::npos) &&
       (inline_autocomplete_offset != match_start)) {
     DCHECK(inline_autocomplete_offset > match_start);
     AutocompleteMatch::ClassifyLocationInString(match_start,
         inline_autocomplete_offset - match_start, match.contents.length(),
         ACMatchClassification::URL, &match.contents_class);
   } else {
-    AutocompleteMatch::ClassifyLocationInString(string16::npos, 0,
+    AutocompleteMatch::ClassifyLocationInString(base::string16::npos, 0,
         match.contents.length(), ACMatchClassification::URL,
         &match.contents_class);
   }
   match.description = info.title();
   match.description_class =
       ClassifyDescription(params.input.text(), match.description);
   RecordAdditionalInfoFromUrlRow(info, &match);
   return match;
 }
 
 // static
 ACMatchClassifications HistoryURLProvider::ClassifyDescription(
-    const string16& input_text,
-    const string16& description) {
-  string16 clean_description = history::CleanUpTitleForMatching(description);
+    const base::string16& input_text,
+    const base::string16& description) {
+  base::string16 clean_description = history::CleanUpTitleForMatching(description);
   history::TermMatches description_matches(SortAndDeoverlapMatches(
       history::MatchTermInString(input_text, clean_description, 0)));
   history::WordStarts description_word_starts;
   history::String16VectorFromString16(
       clean_description, false, &description_word_starts);
   description_matches =
       history::ScoredHistoryMatch::FilterTermMatchesByWordStarts(
           description_matches, description_word_starts, 0);
   return SpansFromTermMatch(
       description_matches, clean_description.length(), false);
 }