Replace string16 with base::string16.

chrome/browser/autocomplete/autocomplete_match.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_match.h"
 
 #include "base/i18n/time_formatting.h"
 #include "base/logging.h"
 #include "base/strings/string16.h"
 #include "base/strings/string_number_conversions.h"
@@ skipping 178 matching lines @@
 bool AutocompleteMatch::DestinationsEqual(const AutocompleteMatch& elem1,
                                           const AutocompleteMatch& elem2) {
   if (elem1.stripped_destination_url.is_empty() &&
       elem2.stripped_destination_url.is_empty())
     return false;
   return elem1.stripped_destination_url == elem2.stripped_destination_url;
 }
 
 // static
 void AutocompleteMatch::ClassifyMatchInString(
-    const string16& find_text,
-    const string16& text,
+    const base::string16& find_text,
+    const base::string16& text,
     int style,
     ACMatchClassifications* classification) {
   ClassifyLocationInString(text.find(find_text), find_text.length(),
                            text.length(), style, classification);
 }
 
 // static
 void AutocompleteMatch::ClassifyLocationInString(
     size_t match_location,
     size_t match_length,
     size_t overall_length,
     int style,
     ACMatchClassifications* classification) {
   classification->clear();
 
   // Don't classify anything about an empty string
   // (AutocompleteMatch::Validate() checks this).
   if (overall_length == 0)
     return;
 
   // Mark pre-match portion of string (if any).
   if (match_location != 0) {
     classification->push_back(ACMatchClassification(0, style));
   }
 
   // Mark matching portion of string.
-  if (match_location == string16::npos) {
+  if (match_location == base::string16::npos) {
     // No match, above classification will suffice for whole string.
     return;
   }
   // Classifying an empty match makes no sense and will lead to validation
   // errors later.
   DCHECK_GT(match_length, 0U);
   classification->push_back(ACMatchClassification(match_location,
       (style | ACMatchClassification::MATCH) & ~ACMatchClassification::DIM));
 
   // Mark post-match portion of string (if any).
@@ skipping 75 matching lines @@
     int style) {
   DCHECK(classifications);
   if (classifications->empty() || classifications->back().style != style) {
     DCHECK(classifications->empty() ||
            (offset > classifications->back().offset));
     classifications->push_back(ACMatchClassification(offset, style));
   }
 }
 
 // static
-string16 AutocompleteMatch::SanitizeString(const string16& text) {
+base::string16 AutocompleteMatch::SanitizeString(const base::string16& text) {
   // NOTE: This logic is mirrored by |sanitizeString()| in
   // omnibox_custom_bindings.js.
-  string16 result;
+  base::string16 result;
   TrimWhitespace(text, TRIM_LEADING, &result);
   base::RemoveChars(result, kInvalidChars, &result);
   return result;
 }
 
 // static
 bool AutocompleteMatch::IsSearchType(Type type) {
   return type == AutocompleteMatchType::SEARCH_WHAT_YOU_TYPED ||
          type == AutocompleteMatchType::SEARCH_HISTORY ||
          type == AutocompleteMatchType::SEARCH_SUGGEST ||
          type == AutocompleteMatchType::SEARCH_OTHER_ENGINE;
 }
 
 void AutocompleteMatch::ComputeStrippedDestinationURL(Profile* profile) {
   stripped_destination_url = destination_url;
   if (!stripped_destination_url.is_valid())
     return;
 
   // If the destination URL looks like it was generated from a TemplateURL,
   // remove all substitutions other than the search terms.  This allows us
   // to eliminate cases like past search URLs from history that differ only
   // by some obscure query param from each other or from the search/keyword
   // provider matches.
   TemplateURL* template_url = GetTemplateURL(profile, true);
   if (template_url != NULL && template_url->SupportsReplacement()) {
-    string16 search_terms;
+    base::string16 search_terms;
     if (template_url->ExtractSearchTermsFromURL(stripped_destination_url,
                                                 &search_terms)) {
       stripped_destination_url =
           GURL(template_url->url_ref().ReplaceSearchTerms(
               TemplateURLRef::SearchTermsArgs(search_terms)));
     }
   }
 
   // |replacements| keeps all the substitions we're going to make to
   // from {destination_url} to {stripped_destination_url}.  |need_replacement|
@@ skipping 19 matching lines @@
         url_parse::Component(0, strlen(content::kHttpScheme)));
     needs_replacement = true;
   }
 
   if (needs_replacement)
     stripped_destination_url = stripped_destination_url.ReplaceComponents(
         replacements);
 }
 
 void AutocompleteMatch::GetKeywordUIState(Profile* profile,
-                                          string16* keyword,
+                                          base::string16* keyword,
                                           bool* is_keyword_hint) const {
   *is_keyword_hint = associated_keyword.get() != NULL;
   keyword->assign(*is_keyword_hint ? associated_keyword->keyword :
       GetSubstitutingExplicitlyInvokedKeyword(profile));
 }
 
-string16 AutocompleteMatch::GetSubstitutingExplicitlyInvokedKeyword(
+base::string16 AutocompleteMatch::GetSubstitutingExplicitlyInvokedKeyword(
     Profile* profile) const {
   if (transition != content::PAGE_TRANSITION_KEYWORD)
-    return string16();
+    return base::string16();
   const TemplateURL* t_url = GetTemplateURL(profile, false);
-  return (t_url && t_url->SupportsReplacement()) ? keyword : string16();
+  return (t_url && t_url->SupportsReplacement()) ? keyword : base::string16();
 }
 
 TemplateURL* AutocompleteMatch::GetTemplateURL(
     Profile* profile, bool allow_fallback_to_destination_host) const {
   DCHECK(profile);
   TemplateURLService* template_url_service =
       TemplateURLServiceFactory::GetForProfile(profile);
   if (template_url_service == NULL)
     return NULL;
   TemplateURL* template_url = keyword.empty() ? NULL :
@@ skipping 39 matching lines @@
       is_keyword_verbatim_match;
 }
 
 #ifndef NDEBUG
 void AutocompleteMatch::Validate() const {
   ValidateClassifications(contents, contents_class);
   ValidateClassifications(description, description_class);
 }
 
 void AutocompleteMatch::ValidateClassifications(
-    const string16& text,
+    const base::string16& text,
     const ACMatchClassifications& classifications) const {
   if (text.empty()) {
     DCHECK(classifications.empty());
     return;
   }
 
   // The classifications should always cover the whole string.
   DCHECK(!classifications.empty()) << "No classification for \"" << text << '"';
   DCHECK_EQ(0U, classifications[0].offset)
       << "Classification misses beginning for \"" << text << '"';
@@ skipping 10 matching lines @@
         << " is unsorted in relation to last offset of " << last_offset
         << ". Provider: " << provider_name << ".";
     DCHECK_LT(i->offset, text.length())
         << " Classification of [" << i->offset << "," << text.length()
         << "] is out of bounds for \"" << text << "\". Provider: "
         << provider_name << ".";
     last_offset = i->offset;
   }
 }
 #endif