Create a content::UrlFetcher interface that lives in content/public/common and convert users to i...

chrome/service/cloud_print/cloud_print_proxy_backend.cc

 // 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 "chrome/service/cloud_print/cloud_print_proxy_backend.h"
 
 #include <map>
 #include <vector>
 
 #include "base/file_util.h"
@@ skipping 64 matching lines @@
                                      const std::string& proxy_id);
 
   // Called on the CloudPrintProxyBackend core_thread_ to perform
   // shutdown.
   void DoShutdown();
   void DoRegisterSelectedPrinters(
       const printing::PrinterList& printer_list);
 
   // CloudPrintURLFetcher::Delegate implementation.
   virtual CloudPrintURLFetcher::ResponseAction HandleJSONData(
-      const URLFetcher* source,
+      const content::URLFetcher* source,
       const GURL& url,
       DictionaryValue* json_data,
       bool succeeded);
 
   virtual void OnRequestAuthError();
 
   // cloud_print::PrintServerWatcherDelegate implementation
   virtual void OnPrinterAdded();
   // PrinterJobHandler::Delegate implementation
   virtual void OnPrinterJobHandlerShutdown(PrinterJobHandler* job_handler,
@@ skipping 15 matching lines @@
                                    int expires_in_seconds);
   virtual void OnRefreshTokenResponse(const std::string& access_token,
                                       int expires_in_seconds);
   virtual void OnOAuthError();
   virtual void OnNetworkError(int response_code);
 
  private:
   // Prototype for a response handler.
   typedef CloudPrintURLFetcher::ResponseAction
       (CloudPrintProxyBackend::Core::*ResponseHandler)(
-          const URLFetcher* source,
+          const content::URLFetcher* source,
           const GURL& url,
           DictionaryValue* json_data,
           bool succeeded);
   // Begin response handlers
   CloudPrintURLFetcher::ResponseAction HandlePrinterListResponse(
-      const URLFetcher* source,
+      const content::URLFetcher* source,
       const GURL& url,
       DictionaryValue* json_data,
       bool succeeded);
 
   CloudPrintURLFetcher::ResponseAction HandleRegisterPrinterResponse(
-      const URLFetcher* source,
+      const content::URLFetcher* source,
       const GURL& url,
       DictionaryValue* json_data,
       bool succeeded);
 
   CloudPrintURLFetcher::ResponseAction HandleRegisterFailedStatusResponse(
-      const URLFetcher* source,
+      const content::URLFetcher* source,
       const GURL& url,
       DictionaryValue* json_data,
       bool succeeded);
 
   CloudPrintURLFetcher::ResponseAction HandlePrintSystemUnavailableResponse(
-      const URLFetcher* source,
+      const content::URLFetcher* source,
       const GURL& url,
       DictionaryValue* json_data,
       bool succeeded);
 
   CloudPrintURLFetcher::ResponseAction HandleEnumPrintersFailedResponse(
-      const URLFetcher* source,
+      const content::URLFetcher* source,
       const GURL& url,
       DictionaryValue* json_data,
       bool succeeded);
 
   CloudPrintURLFetcher::ResponseAction HandleGetAuthCodeResponse(
-      const URLFetcher* source,
+      const content::URLFetcher* source,
       const GURL& url,
       DictionaryValue* json_data,
       bool succeeded);
 
   // End response handlers
 
   // NotifyXXX is how the Core communicates with the frontend across
   // threads.
   void NotifyPrinterListAvailable(
       const printing::PrinterList& printer_list);
@@ skipping 591 matching lines @@
 CloudPrintTokenStore* CloudPrintProxyBackend::Core::GetTokenStore() {
   DCHECK(MessageLoop::current() == backend_->core_thread_.message_loop());
   if (!token_store_.get())
     token_store_.reset(new CloudPrintTokenStore);
   return token_store_.get();
 }
 
 // CloudPrintURLFetcher::Delegate implementation.
 CloudPrintURLFetcher::ResponseAction
 CloudPrintProxyBackend::Core::HandleJSONData(
-    const URLFetcher* source,
+    const content::URLFetcher* source,
     const GURL& url,
     DictionaryValue* json_data,
     bool succeeded) {
   DCHECK(next_response_handler_);
   return (this->*next_response_handler_)(source, url, json_data, succeeded);
 }
 
 void CloudPrintProxyBackend::Core::OnRequestAuthError() {
   OnAuthError();
 }
@@ skipping 19 matching lines @@
   backend_->frontend_->OnAuthenticationFailed();
 }
 
 void CloudPrintProxyBackend::Core::NotifyPrintSystemUnavailable() {
   DCHECK(MessageLoop::current() == backend_->frontend_loop_);
   backend_->frontend_->OnPrintSystemUnavailable();
 }
 
 CloudPrintURLFetcher::ResponseAction
 CloudPrintProxyBackend::Core::HandleGetAuthCodeResponse(
-    const URLFetcher* source,
+    const content::URLFetcher* source,
     const GURL& url,
     DictionaryValue* json_data,
     bool succeeded) {
   DCHECK(MessageLoop::current() == backend_->core_thread_.message_loop());
   if (!succeeded) {
     OnAuthError();
     return CloudPrintURLFetcher::STOP_PROCESSING;
   }
   std::string auth_code;
   if (!json_data->GetString(kOAuthCodeValue, &auth_code)) {
     OnAuthError();
     return CloudPrintURLFetcher::STOP_PROCESSING;
   }
   json_data->GetString(kXMPPJidValue, &robot_email_);
   // Now that we have an auth code we need to get the refresh and access tokens.
   oauth_client_.reset(new gaia::GaiaOAuthClient(
       gaia::kGaiaOAuth2Url,
       g_service_process->GetServiceURLRequestContextGetter()));
   oauth_client_->GetTokensFromAuthCode(oauth_client_info_,
                                        auth_code,
                                        kCloudPrintAPIMaxRetryCount,
                                        this);
 
   return CloudPrintURLFetcher::STOP_PROCESSING;
 }
 
 CloudPrintURLFetcher::ResponseAction
 CloudPrintProxyBackend::Core::HandlePrinterListResponse(
-    const URLFetcher* source,
+    const content::URLFetcher* source,
     const GURL& url,
     DictionaryValue* json_data,
     bool succeeded) {
   DCHECK(MessageLoop::current() == backend_->core_thread_.message_loop());
   if (!succeeded) {
     NOTREACHED();
     return CloudPrintURLFetcher::RETRY_REQUEST;
   }
   ListValue* printer_list = NULL;
   // There may be no "printers" value in the JSON
@@ skipping 98 matching lines @@
   request_->StartPostRequest(post_url,
                              this,
                              kCloudPrintAPIMaxRetryCount,
                              mime_type,
                              post_data,
                              std::string());
 }
 
 CloudPrintURLFetcher::ResponseAction
 CloudPrintProxyBackend::Core::HandleRegisterPrinterResponse(
-    const URLFetcher* source,
+    const content::URLFetcher* source,
     const GURL& url,
     DictionaryValue* json_data,
     bool succeeded) {
   DCHECK(MessageLoop::current() == backend_->core_thread_.message_loop());
   if (succeeded) {
     ListValue* printer_list = NULL;
     // There should be a "printers" value in the JSON
     if (json_data->GetList(kPrinterListValue, &printer_list)) {
       DictionaryValue* printer_data = NULL;
       if (printer_list->GetDictionary(0, &printer_data))
         InitJobHandlerForPrinter(printer_data);
     }
   }
   next_upload_index_++;
   MessageLoop::current()->PostTask(
       FROM_HERE,
       NewRunnableMethod(this,
                         &CloudPrintProxyBackend::Core::RegisterNextPrinter));
   return CloudPrintURLFetcher::STOP_PROCESSING;
 }
 
 CloudPrintURLFetcher::ResponseAction
 CloudPrintProxyBackend::Core::HandleRegisterFailedStatusResponse(
-    const URLFetcher* source,
+    const content::URLFetcher* source,
     const GURL& url,
     DictionaryValue* json_data,
     bool succeeded) {
   DCHECK(MessageLoop::current() == backend_->core_thread_.message_loop());
   next_upload_index_++;
   MessageLoop::current()->PostTask(
       FROM_HERE,
       NewRunnableMethod(this,
                         &CloudPrintProxyBackend::Core::RegisterNextPrinter));
   return CloudPrintURLFetcher::STOP_PROCESSING;
 }
 
 CloudPrintURLFetcher::ResponseAction
 CloudPrintProxyBackend::Core::HandlePrintSystemUnavailableResponse(
-    const URLFetcher* source,
+    const content::URLFetcher* source,
     const GURL& url,
     DictionaryValue* json_data,
     bool succeeded) {
   DCHECK(MessageLoop::current() == backend_->core_thread_.message_loop());
   // Let the frontend know that we do not have a print system.
   backend_->frontend_loop_->PostTask(
       FROM_HERE,
       NewRunnableMethod(this,
                         &Core::NotifyPrintSystemUnavailable));
   return CloudPrintURLFetcher::STOP_PROCESSING;
 }
 
 CloudPrintURLFetcher::ResponseAction
 CloudPrintProxyBackend::Core::HandleEnumPrintersFailedResponse(
-    const URLFetcher* source,
+    const content::URLFetcher* source,
     const GURL& url,
     DictionaryValue* json_data,
     bool succeeded) {
   DCHECK(MessageLoop::current() == backend_->core_thread_.message_loop());
   // Now proceed with printer registration.
   GetRegisteredPrinters();
   return CloudPrintURLFetcher::STOP_PROCESSING;
 }
 
 
@@ skipping 137 matching lines @@
   OnAuthError();
 }
 
 void CloudPrintProxyBackend::Core::OnNetworkError(int response_code) {
   // Since we specify inifinite retries on network errors, this should never
   // be called.
   NOTREACHED() <<
       "OnNetworkError invoked when not expected, response code is " <<
       response_code;
 }