Remove wstring from TemplateURL and friends....

chrome/browser/search_engines/template_url.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_H_
 #define CHROME_BROWSER_SEARCH_ENGINES_TEMPLATE_URL_H_
 #pragma once
 
 #include <string>
 #include <vector>
 
@@ skipping 53 matching lines @@
 
   // Returns a string that is the result of replacing the search terms in
   // the url with the specified value.
   //
   // If this TemplateURLRef does not support replacement (SupportsReplacement
   // returns false), an empty string is returned.
   //
   // The TemplateURL is used to determine the input encoding for the term.
   std::string ReplaceSearchTerms(
       const TemplateURL& host,
-      const std::wstring& terms,
+      const string16& terms,
       int accepted_suggestion,
-      const std::wstring& original_query_for_suggestion) const;
+      const string16& original_query_for_suggestion) const;
 
   // Just like ReplaceSearchTerms except that it takes SearchTermsData to supply
   // the data for some search terms. Most of the time ReplaceSearchTerms should
   // be called.
   std::string ReplaceSearchTermsUsingTermsData(
       const TemplateURL& host,
-      const std::wstring& terms,
+      const string16& terms,
       int accepted_suggestion,
-      const std::wstring& original_query_for_suggestion,
+      const string16& original_query_for_suggestion,
       const SearchTermsData& search_terms_data) const;
 
   // Returns the raw URL. None of the parameters will have been replaced.
   const std::string& url() const { return url_; }
 
   // Returns the index number of the first search result.
   int index_offset() const { return index_offset_; }
 
   // Returns the page number of the first search results.
   int page_offset() const { return page_offset_; }
 
   // Returns true if the TemplateURLRef is valid. An invalid TemplateURLRef is
   // one that contains unknown terms, or invalid characters.
   bool IsValid() const;
 
   // Like IsValid but usable on threads other than the UI thread.
   bool IsValidUsingTermsData(const SearchTermsData& search_terms_data) const;
 
   // Returns a string representation of this TemplateURLRef suitable for
   // display. The display format is the same as the format used by Firefox.
-  std::wstring DisplayURL() const;
+  string16 DisplayURL() const;
 
   // Converts a string as returned by DisplayURL back into a string as
   // understood by TemplateURLRef.
-  static std::string DisplayURLToURLRef(const std::wstring& display_url);
+  static std::string DisplayURLToURLRef(const string16& display_url);
 
   // If this TemplateURLRef is valid and contains one search term, this returns
   // the host/path of the URL, otherwise this returns an empty string.
   const std::string& GetHost() const;
   const std::string& GetPath() const;
 
   // If this TemplateURLRef is valid and contains one search term, this returns
   // the key of the search term, otherwise this returns an empty string.
   const std::string& GetSearchTermKey() const;
 
   // Converts the specified term in the encoding of the host TemplateURL to a
-  // wide string.
-  std::wstring SearchTermToWide(const TemplateURL& host,
+  // string16.
+  string16 SearchTermToString16(const TemplateURL& host,
                                 const std::string& term) const;
 
   // Returns true if this TemplateURLRef has a replacement term of
   // {google:baseURL} or {google:baseSuggestURL}.
   bool HasGoogleBaseURLs() const;
 
   // Returns true if both refs are NULL or have the same values.
   static bool SameUrlRefs(const TemplateURLRef* ref1,
                           const TemplateURLRef* ref2);
 
@@ skipping 117 matching lines @@
 
 // Describes the relevant portions of a single OSD document.
 class TemplateURL {
  public:
   // Describes a single image reference. Each TemplateURL may have
   // any number (including 0) of ImageRefs.
   //
   // If a TemplateURL has no images, the favicon for the generated URL
   // should be used.
   struct ImageRef {
-    ImageRef(const std::wstring& type, int width, int height)
+    ImageRef(const std::string& type, int width, int height)
         : type(type), width(width), height(height) {
     }
 
-    ImageRef(const std::wstring& type, int width, int height, const GURL& url)
+    ImageRef(const std::string& type, int width, int height, const GURL& url)
       : type(type), width(width), height(height), url(url) {
     }
 
     // Mime type for the image.
     // ICO image will have the format: image/x-icon or image/vnd.microsoft.icon
-    std::wstring type;
+    std::string type;
 
     // Size of the image
     int width;
     int height;
 
     // URL of the image.
     GURL url;
   };
 
   // Generates a favicon URL from the specified url.
   static GURL GenerateFaviconURL(const GURL& url);
 
   // Returns true if |turl| is non-null and has a search URL that supports
   // replacement.
   static bool SupportsReplacement(const TemplateURL* turl);
 
   // Like SupportsReplacement but usable on threads other than the UI thread.
   static bool SupportsReplacementUsingTermsData(
       const TemplateURL* turl,
       const SearchTermsData& search_terms_data);
 
   TemplateURL();
   ~TemplateURL();
 
   // A short description of the template. This is the name we show to the user
   // in various places that use keywords. For example, the location bar shows
   // this when the user selects the keyword.
-  void set_short_name(const std::wstring& short_name) {
+  void set_short_name(const string16& short_name) {
     short_name_ = short_name;
   }
-  const std::wstring& short_name() const { return short_name_; }
+  string16 short_name() const { return short_name_; }
 
   // An accessor for the short_name, but adjusted so it can be appropriately
   // displayed even if it is LTR and the UI is RTL.
-  std::wstring AdjustedShortNameForLocaleDirection() const;
+  string16 AdjustedShortNameForLocaleDirection() const;
 
   // A description of the template; this may be empty.
-  void set_description(const std::wstring& description) {
+  void set_description(const string16& description) {
     description_ = description;
   }
-  const std::wstring& description() const { return description_; }
+  string16 description() const { return description_; }
 
   // URL providing JSON results. This is typically used to provide suggestions
   // as your type. If NULL, this url does not support suggestions.
   // Be sure and check the resulting TemplateURLRef for SupportsReplacement
   // before using.
   void SetSuggestionsURL(const std::string& suggestions_url,
                          int index_offset,
                          int page_offset);
   const TemplateURLRef* suggestions_url() const {
     return suggestions_url_.url().empty() ? NULL : &suggestions_url_;
@@ skipping 19 matching lines @@
     return instant_url_.url().empty() ? NULL : &instant_url_;
   }
 
   // URL to the OSD file this came from. May be empty.
   void set_originating_url(const GURL& url) {
     originating_url_ = url;
   }
   const GURL& originating_url() const { return originating_url_; }
 
   // The shortcut for this template url. May be empty.
-  void set_keyword(const std::wstring& keyword);
-  const std::wstring& keyword() const;
+  void set_keyword(const string16& keyword);
+  string16 keyword() const;
 
   // Whether to autogenerate a keyword from the url() in GetKeyword().  Most
   // consumers should not need this.
   // NOTE: Calling set_keyword() turns this back off.  Manual and automatic
   // keywords are mutually exclusive.
   void set_autogenerate_keyword(bool autogenerate_keyword) {
     autogenerate_keyword_ = autogenerate_keyword;
     if (autogenerate_keyword_) {
       keyword_.clear();
       keyword_generated_ = false;
@@ skipping 38 matching lines @@
 
   // Convenience methods for getting/setting an ImageRef that points to a
   // favicon. A TemplateURL need not have an ImageRef for a favicon. In such
   // a situation GetFavIconURL returns an invalid url.
   //
   // If url is empty and there is an image ref for a favicon, it is removed.
   void SetFavIconURL(const GURL& url);
   GURL GetFavIconURL() const;
 
   // Set of languages supported. This may be empty.
-  void add_language(const std::wstring& language) {
+  void add_language(const string16& language) {
     languages_.push_back(language);
   }
-  const std::vector<std::wstring>& languages() const { return languages_; }
+  std::vector<string16> languages() const { return languages_; }
 
   // Date this keyword was created.
   //
   // NOTE: this may be 0, which indicates the keyword was created before we
   // started tracking creation time.
   void set_date_created(base::Time time) { date_created_ = time; }
   base::Time date_created() const { return date_created_; }
 
   // True if this TemplateURL was automatically created by the administrator via
   // group policy.
@@ skipping 53 matching lines @@
   friend class TemplateURLModel;
   friend class WebDatabaseTest;
   friend class WebDatabase;
 
   // Invalidates cached values on this object and its child TemplateURLRefs.
   void InvalidateCachedValues() const;
 
   // Unique identifier, used when archived to the database.
   void set_id(TemplateURLID id) { id_ = id;}
 
-  std::wstring short_name_;
-  std::wstring description_;
+  string16 short_name_;
+  string16 description_;
   TemplateURLRef suggestions_url_;
   TemplateURLRef url_;
   TemplateURLRef instant_url_;
   GURL originating_url_;
-  mutable std::wstring keyword_;
+  mutable string16 keyword_;
   bool autogenerate_keyword_;  // If this is set, |keyword_| holds the cached
                                // generated keyword if available.
   mutable bool keyword_generated_;  // True if the keyword was generated. This
                                     // is used to avoid multiple attempts if
                                     // generating a keyword failed.
   bool show_in_default_list_;
   bool safe_for_autoreplace_;
   std::vector<ImageRef> image_refs_;
-  std::vector<std::wstring> languages_;
+  std::vector<string16> languages_;
   // List of supported input encodings.
   std::vector<std::string> input_encodings_;
   TemplateURLID id_;
   base::Time date_created_;
   bool created_by_policy_;
   int usage_count_;
   SearchEngineType search_engine_type_;
   int logo_id_;
   int prepopulate_id_;
 
   // TODO(sky): Add date last parsed OSD file.
 };
 
 #endif  // CHROME_BROWSER_SEARCH_ENGINES_TEMPLATE_URL_H_