Remove wstring from TemplateURL and friends....

chrome/browser/search_engines/template_url_fetcher.cc

-// 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.
 
 #include "build/build_config.h"
 
 #include "chrome/browser/search_engines/template_url_fetcher.h"
 
 #include "base/string_number_conversions.h"
 #include "base/utf_string_conversions.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/search_engines/template_url.h"
 #include "chrome/browser/search_engines/template_url_fetcher_callbacks.h"
 #include "chrome/browser/search_engines/template_url_model.h"
 #include "chrome/browser/search_engines/template_url_parser.h"
 #include "chrome/common/net/url_fetcher.h"
 #include "chrome/common/notification_observer.h"
 #include "chrome/common/notification_registrar.h"
 #include "chrome/common/notification_source.h"
 #include "chrome/common/notification_type.h"
 #include "net/url_request/url_request_status.h"
 
 // RequestDelegate ------------------------------------------------------------
 class TemplateURLFetcher::RequestDelegate : public URLFetcher::Delegate,
                                             public NotificationObserver {
  public:
   // Takes ownership of |callbacks|.
   RequestDelegate(TemplateURLFetcher* fetcher,
-                  const std::wstring& keyword,
+                  const string16& keyword,
                   const GURL& osdd_url,
                   const GURL& favicon_url,
                   TemplateURLFetcherCallbacks* callbacks,
                   ProviderType provider_type);
 
   // NotificationObserver:
   virtual void Observe(NotificationType type,
                        const NotificationSource& source,
                        const NotificationDetails& details);
 
   // URLFetcher::Delegate:
   // If data contains a valid OSDD, a TemplateURL is created and added to
   // the TemplateURLModel.
   virtual void OnURLFetchComplete(const URLFetcher* source,
                                   const GURL& url,
                                   const URLRequestStatus& status,
                                   int response_code,
                                   const ResponseCookies& cookies,
                                   const std::string& data);
 
   // URL of the OSDD.
-  const GURL& url() const { return osdd_url_; }
+  GURL url() const { return osdd_url_; }
 
   // Keyword to use.
-  const std::wstring keyword() const { return keyword_; }
+  string16 keyword() const { return keyword_; }
 
   // The type of search provider being fetched.
   ProviderType provider_type() const { return provider_type_; }
 
  private:
   void AddSearchProvider();
 
   URLFetcher url_fetcher_;
   TemplateURLFetcher* fetcher_;
   scoped_ptr<TemplateURL> template_url_;
-  std::wstring keyword_;
+  string16 keyword_;
   const GURL osdd_url_;
   const GURL favicon_url_;
   const ProviderType provider_type_;
   scoped_ptr<TemplateURLFetcherCallbacks> callbacks_;
 
   // Handles registering for our notifications.
   NotificationRegistrar registrar_;
 
   DISALLOW_COPY_AND_ASSIGN(RequestDelegate);
 };
 
 TemplateURLFetcher::RequestDelegate::RequestDelegate(
     TemplateURLFetcher* fetcher,
-    const std::wstring& keyword,
+    const string16& keyword,
     const GURL& osdd_url,
     const GURL& favicon_url,
     TemplateURLFetcherCallbacks* callbacks,
     ProviderType provider_type)
     : ALLOW_THIS_IN_INITIALIZER_LIST(url_fetcher_(osdd_url,
                                                   URLFetcher::GET, this)),
       fetcher_(fetcher),
       keyword_(keyword),
       osdd_url_(osdd_url),
       favicon_url_(favicon_url),
@@ skipping 63 matching lines @@
 }
 
 void TemplateURLFetcher::RequestDelegate::AddSearchProvider() {
   DCHECK(template_url_.get());
   if (provider_type_ != AUTODETECTED_PROVIDER || keyword_.empty()) {
     // Generate new keyword from URL in OSDD for none autodetected case.
     // Previous keyword was generated from URL where OSDD was placed and
     // it gives wrong result when OSDD is located on third party site that
     // has nothing in common with search engine in OSDD.
     GURL keyword_url(template_url_->url()->url());
-    std::wstring new_keyword = TemplateURLModel::GenerateKeyword(
+    string16 new_keyword = TemplateURLModel::GenerateKeyword(
         keyword_url, false);
     if (!new_keyword.empty())
       keyword_ = new_keyword;
   }
   TemplateURLModel* model = fetcher_->profile()->GetTemplateURLModel();
   const TemplateURL* existing_url;
   if (keyword_.empty() ||
       !model || !model->loaded() ||
       !model->CanReplaceKeyword(keyword_, GURL(template_url_->url()->url()),
                                 &existing_url)) {
     if (provider_type_ == AUTODETECTED_PROVIDER || !model || !model->loaded()) {
       fetcher_->RequestCompleted(this);
       // WARNING: RequestCompleted deletes us.
       return;
     }
 
     existing_url = NULL;
 
     // Try to generate a keyword automatically when we are setting the default
     // provider. The keyword isn't as important in this case.
     if (provider_type_ == EXPLICIT_DEFAULT_PROVIDER) {
       // The loop numbers are arbitrary and are simply a strong effort.
-      std::wstring new_keyword;
+      string16 new_keyword;
       for (int i = 0; i < 100; ++i) {
         // Concatenate a number at end of the keyword and try that.
         new_keyword = keyword_;
         // Try the keyword alone the first time
         if (i > 0)
-          new_keyword.append(UTF16ToWide(base::IntToString16(i)));
+          new_keyword.append(base::IntToString16(i));
         if (!model->GetTemplateURLForKeyword(new_keyword) ||
             model->CanReplaceKeyword(new_keyword,
                                      GURL(template_url_->url()->url()),
                                      &existing_url)) {
           break;
         }
         new_keyword.clear();
         existing_url = NULL;
       }
 
@@ skipping 58 matching lines @@
 // TemplateURLFetcher ---------------------------------------------------------
 
 TemplateURLFetcher::TemplateURLFetcher(Profile* profile) : profile_(profile) {
   DCHECK(profile_);
 }
 
 TemplateURLFetcher::~TemplateURLFetcher() {
 }
 
 void TemplateURLFetcher::ScheduleDownload(
-    const std::wstring& keyword,
+    const string16& keyword,
     const GURL& osdd_url,
     const GURL& favicon_url,
     TemplateURLFetcherCallbacks* callbacks,
     ProviderType provider_type) {
   DCHECK(osdd_url.is_valid());
   scoped_ptr<TemplateURLFetcherCallbacks> owned_callbacks(callbacks);
 
   // For JS added OSDD empty keyword is OK because we will generate keyword
   // later from OSDD content.
   if (provider_type == TemplateURLFetcher::AUTODETECTED_PROVIDER &&
@@ skipping 37 matching lines @@
       new RequestDelegate(this, keyword, osdd_url, favicon_url,
                           owned_callbacks.release(), provider_type));
 }
 
 void TemplateURLFetcher::RequestCompleted(RequestDelegate* request) {
   DCHECK(find(requests_->begin(), requests_->end(), request) !=
          requests_->end());
   requests_->erase(find(requests_->begin(), requests_->end(), request));
   delete request;
 }