Replace string16 with base::string16.

chrome/browser/autocomplete/search_provider.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.
 //
 // This file contains the Search autocomplete provider.  This provider is
 // responsible for all autocomplete entries that start with "Search <engine>
 // for ...", including searching for the current input string, search
 // history, and search suggestions.  An instance of it gets created and
 // managed by the autocomplete controller.
 
@@ skipping 67 matching lines @@
   // |input| and |is_keyword| are necessary for various other details, like
   // whether we should allow inline autocompletion and what the transition type
   // should be.  |accepted_suggestion| and |omnibox_start_margin| are used along
   // with |input_text| to generate Assisted Query Stats.
   // |append_extra_query_params| should be set if |template_url| is the default
   // search engine, so the destination URL will contain any
   // command-line-specified query params.
   static AutocompleteMatch CreateSearchSuggestion(
       AutocompleteProvider* autocomplete_provider,
       const AutocompleteInput& input,
-      const string16& input_text,
+      const base::string16& input_text,
       int relevance,
       AutocompleteMatch::Type type,
       bool is_keyword,
-      const string16& match_contents,
-      const string16& annotation,
+      const base::string16& match_contents,
+      const base::string16& annotation,
       const TemplateURL* template_url,
-      const string16& query_string,
+      const base::string16& query_string,
       const std::string& suggest_query_params,
       int accepted_suggestion,
       int omnibox_start_margin,
       bool append_extra_query_params);
 
   // Returns whether the SearchProvider previously flagged |match| as a query
   // that should be prefetched.
   static bool ShouldPrefetch(const AutocompleteMatch& match);
 
   // Extracts the suggest response metadata which SearchProvider previously
@@ skipping 38 matching lines @@
   // . The default provider. This corresponds to the user's default search
   //   engine. This is always used, except for the rare case of no default
   //   engine.
   // . The keyword provider. This is used if the user has typed in a keyword.
   class Providers {
    public:
     explicit Providers(TemplateURLService* template_url_service);
 
     // Returns true if the specified providers match the two providers cached
     // by this class.
-    bool equal(const string16& default_provider,
-               const string16& keyword_provider) const {
+    bool equal(const base::string16& default_provider,
+               const base::string16& keyword_provider) const {
       return (default_provider == default_provider_) &&
           (keyword_provider == keyword_provider_);
     }
 
     // Resets the cached providers.
-    void set(const string16& default_provider,
-             const string16& keyword_provider) {
+    void set(const base::string16& default_provider,
+             const base::string16& keyword_provider) {
       default_provider_ = default_provider;
       keyword_provider_ = keyword_provider;
     }
 
     TemplateURLService* template_url_service() { return template_url_service_; }
-    const string16& default_provider() const { return default_provider_; }
-    const string16& keyword_provider() const { return keyword_provider_; }
+    const base::string16& default_provider() const { return default_provider_; }
+    const base::string16& keyword_provider() const { return keyword_provider_; }
 
     // NOTE: These may return NULL even if the provider members are nonempty!
     const TemplateURL* GetDefaultProviderURL() const;
     const TemplateURL* GetKeywordProviderURL() const;
 
     // Returns true if there is a valid keyword provider.
     bool has_keyword_provider() const { return !keyword_provider_.empty(); }
 
    private:
     TemplateURLService* template_url_service_;
 
     // Cached across the life of a query so we behave consistently even if the
     // user changes their default while the query is running.
-    string16 default_provider_;
-    string16 keyword_provider_;
+    base::string16 default_provider_;
+    base::string16 keyword_provider_;
 
     DISALLOW_COPY_AND_ASSIGN(Providers);
   };
 
   // The Result classes are intermediate representations of AutocompleteMatches,
   // simply containing relevance-ranked search and navigation suggestions.
   // They may be cached to provide some synchronous matches while requests for
   // new suggestions from updated input are in flight.
   // TODO(msw) Extend these classes to generate their corresponding matches and
   //           other requisite data, in order to consolidate and simplify the
@@ skipping 10 matching lines @@
     int relevance() const { return relevance_; }
     void set_relevance(int relevance) { relevance_ = relevance; }
 
     bool relevance_from_server() const { return relevance_from_server_; }
     void set_relevance_from_server(bool relevance_from_server) {
       relevance_from_server_ = relevance_from_server;
     }
 
     // Returns if this result is inlineable against the current input |input|.
     // Non-inlineable results are stale.
-    virtual bool IsInlineable(const string16& input) const = 0;
+    virtual bool IsInlineable(const base::string16& input) const = 0;
 
     // Returns the default relevance value for this result (which may
     // be left over from a previous omnibox input) given the current
     // input and whether the current input caused a keyword provider
     // to be active.
     virtual int CalculateRelevance(const AutocompleteInput& input,
                                    bool keyword_provider_requested) const = 0;
 
    protected:
     // True if the result came from the keyword provider.
     bool from_keyword_provider_;
 
     // The relevance score.
     int relevance_;
 
    private:
     // Whether this result's relevance score was fully or partly calculated
     // based on server information, and thus is assumed to be more accurate.
     // This is ultimately used in
     // SearchProvider::ConvertResultsToAutocompleteMatches(), see comments
     // there.
     bool relevance_from_server_;
   };
 
   class SuggestResult : public Result {
    public:
-    SuggestResult(const string16& suggestion,
-                  const string16& match_contents,
-                  const string16& annotation,
+    SuggestResult(const base::string16& suggestion,
+                  const base::string16& match_contents,
+                  const base::string16& annotation,
                   const std::string& suggest_query_params,
                   const std::string& deletion_url,
                   bool from_keyword_provider,
                   int relevance,
                   bool relevance_from_server,
                   bool should_prefetch);
     virtual ~SuggestResult();
 
-    const string16& suggestion() const { return suggestion_; }
-    const string16& match_contents() const { return match_contents_; }
-    const string16& annotation() const { return annotation_; }
+    const base::string16& suggestion() const { return suggestion_; }
+    const base::string16& match_contents() const { return match_contents_; }
+    const base::string16& annotation() const { return annotation_; }
     const std::string& suggest_query_params() const {
       return suggest_query_params_;
     }
     const std::string& deletion_url() const { return deletion_url_; }
     bool should_prefetch() const { return should_prefetch_; }
 
     // Result:
-    virtual bool IsInlineable(const string16& input) const OVERRIDE;
+    virtual bool IsInlineable(const base::string16& input) const OVERRIDE;
     virtual int CalculateRelevance(
         const AutocompleteInput& input,
         bool keyword_provider_requested) const OVERRIDE;
 
    private:
     // The search terms to be used for this suggestion.
-    string16 suggestion_;
+    base::string16 suggestion_;
 
     // The contents to be displayed in the autocomplete match.
-    string16 match_contents_;
+    base::string16 match_contents_;
 
     // Optional annotation for the |match_contents_| for disambiguation.
     // This may be displayed in the autocomplete match contents, but is defined
     // separately to facilitate different formatting.
-    string16 annotation_;
+    base::string16 annotation_;
 
     // Optional additional parameters to be added to the search URL.
     std::string suggest_query_params_;
 
     // Optional deletion URL provided with suggestions. Fetching this URL
     // should result in some reasonable deletion behaviour on the server,
     // e.g. deleting this term out of a user's server-side search history.
     std::string deletion_url_;
 
     // Should this result be prefetched?
     bool should_prefetch_;
   };
 
   class NavigationResult : public Result {
    public:
     // |provider| is necessary to use StringForURLDisplay() in order to
     // compute |formatted_url_|.
     NavigationResult(const AutocompleteProvider& provider,
                      const GURL& url,
-                     const string16& description,
+                     const base::string16& description,
                      bool from_keyword_provider,
                      int relevance,
                      bool relevance_from_server);
     virtual ~NavigationResult();
 
     const GURL& url() const { return url_; }
-    const string16& description() const { return description_; }
-    const string16& formatted_url() const { return formatted_url_; }
+    const base::string16& description() const { return description_; }
+    const base::string16& formatted_url() const { return formatted_url_; }
 
     // Result:
-    virtual bool IsInlineable(const string16& input) const OVERRIDE;
+    virtual bool IsInlineable(const base::string16& input) const OVERRIDE;
     virtual int CalculateRelevance(
         const AutocompleteInput& input,
         bool keyword_provider_requested) const OVERRIDE;
 
    private:
     // The suggested url for navigation.
     GURL url_;
 
     // The properly formatted ("fixed up") URL string with equivalent meaning
     // to the one in |url_|.
-    string16 formatted_url_;
+    base::string16 formatted_url_;
 
     // The suggested navigational result description; generally the site name.
-    string16 description_;
+    base::string16 description_;
   };
 
   class CompareScoredResults;
 
   typedef std::vector<SuggestResult> SuggestResults;
   typedef std::vector<NavigationResult> NavigationResults;
   typedef std::vector<history::KeywordSearchTermVisit> HistoryResults;
   typedef std::pair<string16, std::string> MatchKey;
   typedef std::map<MatchKey, AutocompleteMatch> MatchMap;
   typedef ScopedVector<SuggestionDeletionHandler> SuggestionDeletionHandlers;
@@ skipping 28 matching lines @@
 
     // The JSON metadata associated with this server response.
     std::string metadata;
 
    private:
     DISALLOW_COPY_AND_ASSIGN(Results);
   };
 
   // Removes non-inlineable results until either the top result can inline
   // autocomplete the current input or verbatim outscores the top result.
-  static void RemoveStaleResults(const string16& input,
+  static void RemoveStaleResults(const base::string16& input,
                                  int verbatim_relevance,
                                  SuggestResults* suggest_results,
                                  NavigationResults* navigation_results);
 
   // Calculates the relevance score for the keyword verbatim result (if the
   // input matches one of the profile's keyword).
   static int CalculateRelevanceForKeywordVerbatim(AutocompleteInput::Type type,
                                                   bool prefer_keyword);
 
   // AutocompleteProvider:
@@ skipping 103 matching lines @@
   // whether the results correspond to the keyword provider or default provider.
   void AddHistoryResultsToMap(const HistoryResults& results,
                               bool is_keyword,
                               int did_not_accept_suggestion,
                               MatchMap* map);
 
   // Calculates relevance scores for all |results|.
   SuggestResults ScoreHistoryResults(const HistoryResults& results,
                                      bool base_prevent_inline_autocomplete,
                                      bool input_multiple_words,
-                                     const string16& input_text,
+                                     const base::string16& input_text,
                                      bool is_keyword);
 
   // Adds matches for |results| to |map|.
   void AddSuggestResultsToMap(const SuggestResults& results,
                               const std::string& metadata,
                               MatchMap* map);
 
   // Gets the relevance score for the verbatim result.  This value may be
   // provided by the suggest server or calculated locally; if
   // |relevance_from_server| is non-NULL, it will be set to indicate which of
@@ skipping 26 matching lines @@
   // scores.  When using the aggressive method, scores may exceed 1300
   // unless |prevent_search_history_inlining| is set.
   int CalculateRelevanceForHistory(const base::Time& time,
                                    bool is_keyword,
                                    bool use_aggressive_method,
                                    bool prevent_search_history_inlining) const;
 
   // Creates an AutocompleteMatch for "Search <engine> for |query_string|" with
   // the supplied relevance.  Adds this match to |map|; if such a match already
   // exists, whichever one has lower relevance is eliminated.
-  void AddMatchToMap(const string16& input_text,
+  void AddMatchToMap(const base::string16& input_text,
                      int relevance,
                      bool relevance_from_server,
                      bool should_prefetch,
                      const std::string& metadata,
                      AutocompleteMatch::Type type,
                      bool is_keyword,
-                     const string16& match_contents,
-                     const string16& annotation,
-                     const string16& query_string,
+                     const base::string16& match_contents,
+                     const base::string16& annotation,
+                     const base::string16& query_string,
                      int accepted_suggestion,
                      const std::string& suggest_query_params,
                      const std::string& deletion_url,
                      MatchMap* map);
 
   // Returns an AutocompleteMatch for a navigational suggestion.
   AutocompleteMatch NavigationToMatch(const NavigationResult& navigation);
 
   // Resets the scores of all |keyword_navigation_results_| matches to
   // be below that of the top keyword query match (the verbatim match
@@ skipping 113 matching lines @@
   // If true, search history query suggestions will score low enough that
   // they will not be inlined.
   bool prevent_search_history_inlining_;
 
   GURL current_page_url_;
 
   DISALLOW_COPY_AND_ASSIGN(SearchProvider);
 };
 
 #endif  // CHROME_BROWSER_AUTOCOMPLETE_SEARCH_PROVIDER_H_