Replace string16 with base::string16.

chrome/browser/autocomplete/autocomplete_match.h

 // 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.
 
 #ifndef CHROME_BROWSER_AUTOCOMPLETE_AUTOCOMPLETE_MATCH_H_
 #define CHROME_BROWSER_AUTOCOMPLETE_AUTOCOMPLETE_MATCH_H_
 
 #include <map>
 #include <string>
 #include <vector>
@@ skipping 99 matching lines @@
   // destinations are expected for non-navigable matches.
   static bool DestinationSortFunc(const AutocompleteMatch& elem1,
                                   const AutocompleteMatch& elem2);
   static bool DestinationsEqual(const AutocompleteMatch& elem1,
                                 const AutocompleteMatch& elem2);
 
   // Helper functions for classes creating matches:
   // Fills in the classifications for |text|, using |style| as the base style
   // and marking the first instance of |find_text| as a match.  (This match
   // will also not be dimmed, if |style| has DIM set.)
-  static void ClassifyMatchInString(const string16& find_text,
-                                    const string16& text,
+  static void ClassifyMatchInString(const base::string16& find_text,
+                                    const base::string16& text,
                                     int style,
                                     ACMatchClassifications* classifications);
 
   // Similar to ClassifyMatchInString(), but for cases where the range to mark
   // as matching is already known (avoids calling find()).  This can be helpful
   // when find() would be misleading (e.g. you want to mark the second match in
   // a string instead of the first).
   static void ClassifyLocationInString(size_t match_location,
                                        size_t match_length,
                                        size_t overall_length,
@@ skipping 17 matching lines @@
   // different from the last existing classification.  |offset| must be larger
   // than the offset of the last classification in |classifications|.
   static void AddLastClassificationIfNecessary(
       ACMatchClassifications* classifications,
       size_t offset,
       int style);
 
   // Removes invalid characters from |text|. Should be called on strings coming
   // from external sources (such as extensions) before assigning to |contents|
   // or |description|.
-  static string16 SanitizeString(const string16& text);
+  static base::string16 SanitizeString(const base::string16& text);
 
   // Convenience function to check if |type| is a search (as opposed to a URL or
   // an extension).
   static bool IsSearchType(Type type);
 
   // Copies the destination_url with "www." stripped off to
   // |stripped_destination_url| and also converts https protocol to
   // http.  These two conversions are merely to allow comparisons to
   // remove likely duplicates; these URLs are not used as actual
   // destination URLs.  This method is invoked internally by the
@@ skipping 10 matching lines @@
   // and |is_keyword_hint| will be set to false.  If this match has a non-NULL
   // |associated_keyword|, i.e. we should show a "Press [tab] to search ___"
   // hint and allow the user to toggle into keyword mode, |keyword| will be set
   // to the associated keyword and |is_keyword_hint| will be set to true.  Note
   // that only one of these states can be in effect at once.  In all other
   // cases, |keyword| will be cleared, even when our member variable |keyword|
   // is non-empty -- such as with non-substituting keywords or matches that
   // represent searches using the default search engine.  See also
   // GetSubstitutingExplicitlyInvokedKeyword().
   void GetKeywordUIState(Profile* profile,
-                         string16* keyword,
+                         base::string16* keyword,
                          bool* is_keyword_hint) const;
 
   // Returns |keyword|, but only if it represents a substituting keyword that
   // the user has explicitly invoked.  If for example this match represents a
   // search with the default search engine (and the user didn't explicitly
   // invoke its keyword), this returns the empty string.  The result is that
   // this function returns a non-empty string in the same cases as when the UI
   // should show up as being "in keyword mode".
-  string16 GetSubstitutingExplicitlyInvokedKeyword(Profile* profile) const;
+  base::string16 GetSubstitutingExplicitlyInvokedKeyword(
+      Profile* profile) const;
 
   // Returns the TemplateURL associated with this match.  This may be NULL if
   // the match has no keyword OR if the keyword no longer corresponds to a valid
   // TemplateURL.  See comments on |keyword| below.
   // If |allow_fallback_to_destination_host| is true and the keyword does
   // not map to a valid TemplateURL, we'll then check for a TemplateURL that
   // corresponds to the destination_url's hostname.
   TemplateURL* GetTemplateURL(Profile* profile,
                               bool allow_fallback_to_destination_host) const;
 
@@ skipping 37 matching lines @@
   // its value is -1.  At the time of writing this comment, it is only
   // set for matches from HistoryURL and HistoryQuickProvider.
   int typed_count;
 
   // True if the user should be able to delete this match.
   bool deletable;
 
   // This string is loaded into the location bar when the item is selected
   // by pressing the arrow keys. This may be different than a URL, for example,
   // for search suggestions, this would just be the search terms.
-  string16 fill_into_edit;
+  base::string16 fill_into_edit;
 
   // The inline autocompletion to display after the user's typing in the
   // omnibox, if this match becomes the default match.  It may be empty.
-  string16 inline_autocompletion;
+  base::string16 inline_autocompletion;
 
   // If false, the omnibox should prevent this match from being the
   // default match.  Providers should set this to true only if the
   // user's input, plus any inline autocompletion on this match, would
   // lead the user to expect a navigation to this match's destination.
   // For example, with input "foo", a search for "bar" or navigation
   // to "bar.com" should not set this flag; a navigation to "foo.com"
   // should only set this flag if ".com" will be inline autocompleted;
   // and a navigation to "foo/" (an intranet host) or search for "foo"
   // should set this flag.
   bool allowed_to_be_default_match;
 
   // The URL to actually load when the autocomplete item is selected. This URL
   // should be canonical so we can compare URLs with strcmp to avoid dupes.
   // It may be empty if there is no possible navigation.
   GURL destination_url;
 
   // The destination URL with "www." stripped off for better dupe finding.
   GURL stripped_destination_url;
 
   // The main text displayed in the address bar dropdown.
-  string16 contents;
+  base::string16 contents;
   ACMatchClassifications contents_class;
 
   // Additional helper text for each entry, such as a title or description.
-  string16 description;
+  base::string16 description;
   ACMatchClassifications description_class;
 
   // The transition type to use when the user opens this match.  By default
   // this is TYPED.  Providers whose matches do not look like URLs should set
   // it to GENERATED.
   content::PageTransition transition;
 
   // True when this match is the "what you typed" match from the history
   // system.
   bool is_history_what_you_typed_match;
@@ skipping 10 matching lines @@
   // for both explicit "keyword mode" matches as well as matches for the default
   // search provider (so, any match for which we're doing substitution); it
   // doesn't imply (alone) that the UI is going to show a keyword hint or
   // keyword mode.  For that, see GetKeywordUIState() or
   // GetSubstitutingExplicitlyInvokedKeyword().
   //
   // CAUTION: The TemplateURL associated with this keyword may be deleted or
   // modified while the AutocompleteMatch is alive.  This means anyone who
   // accesses it must perform any necessary sanity checks before blindly using
   // it!
-  string16 keyword;
+  base::string16 keyword;
 
   // True if the user has starred the destination URL.
   bool starred;
 
   // True if this match is from a previous result.
   bool from_previous;
 
   // Optional search terms args.  If present,
   // AutocompleteController::UpdateAssistedQueryStats() will incorporate this
   // data with additional data it calculates and pass the completed struct to
   // TemplateURLRef::ReplaceSearchTerms() to reset the match's |destination_url|
   // after the complete set of matches in the AutocompleteResult has been chosen
   // and sorted.  Most providers will leave this as NULL, which will cause the
   // AutocompleteController to do no additional transformations.
   scoped_ptr<TemplateURLRef::SearchTermsArgs> search_terms_args;
 
   // Information dictionary into which each provider can optionally record a
   // property and associated value and which is presented in chrome://omnibox.
   AdditionalInfo additional_info;
 
 #ifndef NDEBUG
   // Does a data integrity check on this match.
   void Validate() const;
 
   // Checks one text/classifications pair for valid values.
   void ValidateClassifications(
-      const string16& text,
+      const base::string16& text,
       const ACMatchClassifications& classifications) const;
 #endif
 };
 
 typedef AutocompleteMatch::ACMatchClassification ACMatchClassification;
 typedef std::vector<ACMatchClassification> ACMatchClassifications;
 typedef std::vector<AutocompleteMatch> ACMatches;
 
 #endif  // CHROME_BROWSER_AUTOCOMPLETE_AUTOCOMPLETE_MATCH_H_