Remove wstring from TemplateURL and friends....

chrome/browser/search_engines/template_url_model.h

-// Copyright (c) 2010 The Chromium Authors. All rights reserved.
+// Copyright (c) 2011 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_SEARCH_ENGINES_TEMPLATE_URL_MODEL_H_
 #define CHROME_BROWSER_SEARCH_ENGINES_TEMPLATE_URL_MODEL_H_
 #pragma once
 
 #include <map>
 #include <set>
 #include <string>
@@ skipping 26 matching lines @@
 // KeywordAutocomplete.
 //
 // TemplateURLModel stores a vector of TemplateURLs. The TemplateURLs are
 // persisted to the database maintained by WebDataService. *ALL* mutations
 // to the TemplateURLs must funnel through TemplateURLModel. This allows
 // TemplateURLModel to notify listeners of changes as well as keep the
 // database in sync.
 //
 // There is a TemplateURLModel per Profile.
 //
-// TemplateURLModel does not load the vector of TemplateURLs in it's
+// TemplateURLModel does not load the vector of TemplateURLs in its
 // constructor (except for testing). Use the Load method to trigger a load.
 // When TemplateURLModel has completed loading, observers are notified via
 // OnTemplateURLModelChanged as well as the TEMPLATE_URL_MODEL_LOADED
 // notification message.
 //
 // TemplateURLModel takes ownership of any TemplateURL passed to it. If there
 // is a WebDataService, deletion is handled by WebDataService, otherwise
 // TemplateURLModel handles deletion.
 
 class TemplateURLModel : public WebDataServiceConsumer,
                          public NotificationObserver {
  public:
   typedef std::map<std::string, std::string> QueryTerms;
 
   // Struct used for initializing the data store with fake data.
   // Each initializer is mapped to a TemplateURL.
   struct Initializer {
-    const wchar_t* const keyword;
+    const char* const keyword;
     const char* const url;
-    const wchar_t* const content;
+    const char* const content;
   };
 
   explicit TemplateURLModel(Profile* profile);
   // The following is for testing.
   TemplateURLModel(const Initializer* initializers, const int count);
   virtual ~TemplateURLModel();
 
   // Generates a suitable keyword for the specified url.  Returns an empty
   // string if a keyword couldn't be generated.  If |autodetected| is true, we
   // don't generate keywords for a variety of situations where we would probably
   // not want to auto-add keywords, such as keywords for searches on pages that
   // themselves come from form submissions.
-  static std::wstring GenerateKeyword(const GURL& url, bool autodetected);
+  static string16 GenerateKeyword(const GURL& url, bool autodetected);
 
   // Removes any unnecessary characters from a user input keyword.
   // This removes the leading scheme, "www." and any trailing slash.
-  static std::wstring CleanUserInputKeyword(const std::wstring& keyword);
+  static string16 CleanUserInputKeyword(const string16& keyword);
 
   // Returns the search url for t_url.  Returns an empty GURL if t_url has no
   // url().
   static GURL GenerateSearchURL(const TemplateURL* t_url);
 
   // Just like GenerateSearchURL except that it takes SearchTermsData to supply
   // the data for some search terms. Most of the time GenerateSearchURL should
   // be called.
   static GURL GenerateSearchURLUsingTermsData(
       const TemplateURL* t_url,
       const SearchTermsData& search_terms_data);
 
   // Returns true if there is no TemplateURL that conflicts with the
   // keyword/url pair, or there is one but it can be replaced. If there is an
   // existing keyword that can be replaced and template_url_to_replace is
   // non-NULL, template_url_to_replace is set to the keyword to replace.
   //
   // url gives the url of the search query. The url is used to avoid generating
   // a TemplateURL for an existing TemplateURL that shares the same host.
-  bool CanReplaceKeyword(const std::wstring& keyword,
+  bool CanReplaceKeyword(const string16& keyword,
                          const GURL& url,
                          const TemplateURL** template_url_to_replace);
 
   // Returns (in |matches|) all keywords beginning with |prefix|, sorted
   // shortest-first. If support_replacement_only is true, only keywords that
   // support replacement are returned.
-  void FindMatchingKeywords(const std::wstring& prefix,
+  void FindMatchingKeywords(const string16& prefix,
                             bool support_replacement_only,
-                            std::vector<std::wstring>* matches) const;
+                            std::vector<string16>* matches) const;
 
   // Looks up |keyword| and returns the element it maps to.  Returns NULL if
   // the keyword was not found.
   // The caller should not try to delete the returned pointer; the data store
   // retains ownership of it.
-  const TemplateURL* GetTemplateURLForKeyword(
-    const std::wstring& keyword) const;
+  const TemplateURL* GetTemplateURLForKeyword(const string16& keyword) const;
 
   // Returns the first TemplateURL found with a URL using the specified |host|,
   // or NULL if there are no such TemplateURLs
   const TemplateURL* GetTemplateURLForHost(const std::string& host) const;
 
   // Adds a new TemplateURL to this model. TemplateURLModel will own the
   // reference, and delete it when the TemplateURL is removed.
   void Add(TemplateURL* template_url);
 
   // Removes the keyword from the model. This deletes the supplied TemplateURL.
@@ skipping 28 matching lines @@
   // by TemplateURLModel and should not be deleted.
   std::vector<const TemplateURL*> GetTemplateURLs() const;
 
   // Increment the usage count of a keyword.
   // Called when a URL is loaded that was generated from a keyword.
   void IncrementUsageCount(const TemplateURL* url);
 
   // Resets the title, keyword and search url of the specified TemplateURL.
   // The TemplateURL is marked as not replaceable.
   void ResetTemplateURL(const TemplateURL* url,
-                        const std::wstring& title,
-                        const std::wstring& keyword,
+                        const string16& title,
+                        const string16& keyword,
                         const std::string& search_url);
 
   // Return true if the given |url| can be made the default.
   bool CanMakeDefault(const TemplateURL* url);
 
   // Set the default search provider.  |url| may be null.
   // This will assert if the default search is managed; the UI should not be
   // invoking this method in that situation.
   void SetDefaultSearchProvider(const TemplateURL* url);
 
@@ skipping 22 matching lines @@
 
   // Notification that the keywords have been loaded.
   // This is invoked from WebDataService, and should not be directly
   // invoked.
   virtual void OnWebDataServiceRequestDone(WebDataService::Handle h,
                                            const WDTypedResult* result);
 
   // Returns the locale-direction-adjusted short name for the given keyword.
   // Also sets the out param to indicate whether the keyword belongs to an
   // extension.
-  std::wstring GetKeywordShortName(const std::wstring& keyword,
-                                   bool* is_extension_keyword);
+  string16 GetKeywordShortName(const string16& keyword,
+                               bool* is_extension_keyword);
 
   // NotificationObserver method. TemplateURLModel listens for three
   // notification types:
   // . NOTIFY_HISTORY_URL_VISITED: adds keyword search terms if the visit
   //   corresponds to a keyword.
   // . NOTIFY_GOOGLE_URL_UPDATED: updates mapping for any keywords containing
   //   a google base url replacement term.
   // . PREF_CHANGED: checks whether the default search engine has changed.
   virtual void Observe(NotificationType type,
                        const NotificationSource& source,
@@ skipping 12 matching lines @@
   // Registers the preferences used to save a TemplateURL to prefs.
   static void RegisterUserPrefs(PrefService* prefs);
 
  protected:
   // Cover method for the method of the same name on the HistoryService.
   // url is the one that was visited with the given search terms.
   //
   // This exists and is virtual for testing.
   virtual void SetKeywordSearchTermsForURL(const TemplateURL* t_url,
                                            const GURL& url,
-                                           const std::wstring& term);
+                                           const string16& term);
 
  private:
   FRIEND_TEST_ALL_PREFIXES(TemplateURLModelTest, BuildQueryTerms);
   FRIEND_TEST_ALL_PREFIXES(TemplateURLModelTest, TestManagedDefaultSearch);
   FRIEND_TEST_ALL_PREFIXES(TemplateURLModelTest,
                            UpdateKeywordSearchTermsForURL);
   FRIEND_TEST_ALL_PREFIXES(TemplateURLModelTest,
                            DontUpdateKeywordSearchForNonReplaceable);
   FRIEND_TEST_ALL_PREFIXES(TemplateURLModelTest, ChangeGoogleBaseValue);
   FRIEND_TEST_ALL_PREFIXES(TemplateURLModelTest, MergeDeletesUnusedProviders);
   friend class TemplateURLModelTestUtil;
 
-  typedef std::map<std::wstring, const TemplateURL*> KeywordToTemplateMap;
+  typedef std::map<string16, const TemplateURL*> KeywordToTemplateMap;
   typedef std::vector<const TemplateURL*> TemplateURLVector;
 
   // Helper functor for FindMatchingKeywords(), for finding the range of
   // keywords which begin with a prefix.
   class LessWithPrefix;
 
   void Init(const Initializer* initializers, int num_initializers);
 
   void RemoveFromMaps(const TemplateURL* template_url);
 
@@ skipping 155 matching lines @@
   // increasing integer that is initialized from the database.
   TemplateURLID next_id_;
 
   // List of extension IDs waiting for Load to have keywords registered.
   std::vector<std::string> pending_extension_ids_;
 
   DISALLOW_COPY_AND_ASSIGN(TemplateURLModel);
 };
 
 #endif  // CHROME_BROWSER_SEARCH_ENGINES_TEMPLATE_URL_MODEL_H_