Re-landing issue 4202006 (http://codereview.chromium.org/4202006/show) which ...

chrome/service/cloud_print/cloud_print_proxy_backend.cc

 // Copyright (c) 2010 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"
 #include "base/md5.h"
 #include "base/rand_util.h"
 #include "base/string_split.h"
 #include "base/string_util.h"
 #include "base/utf_string_conversions.h"
 #include "base/values.h"
-#include "chrome/common/net/http_return.h"
+#include "chrome/common/net/url_fetcher_protect.h"
 #include "chrome/service/cloud_print/cloud_print_consts.h"
 #include "chrome/service/cloud_print/cloud_print_helpers.h"
+#include "chrome/service/cloud_print/cloud_print_url_fetcher.h"
 #include "chrome/service/cloud_print/printer_job_handler.h"
 #include "chrome/service/gaia/service_gaia_authenticator.h"
 #include "chrome/service/service_process.h"
 #include "googleurl/src/gurl.h"
 #include "jingle/notifier/base/notifier_options.h"
 #include "jingle/notifier/listener/push_notifications_thread.h"
 #include "jingle/notifier/listener/talk_mediator_impl.h"
 #include "net/url_request/url_request_status.h"
 
 // The real guts of CloudPrintProxyBackend, to keep the public client API clean.
 class CloudPrintProxyBackend::Core
     : public base::RefCountedThreadSafe<CloudPrintProxyBackend::Core>,
-      public URLFetcherDelegate,
+      public CloudPrintURLFetcherDelegate,
       public cloud_print::PrintServerWatcherDelegate,
       public PrinterJobHandlerDelegate,
       public notifier::TalkMediator::Delegate {
  public:
   // It is OK for print_server_url to be empty. In this case system should
   // use system default (local) print server.
   explicit Core(CloudPrintProxyBackend* backend,
                 const GURL& cloud_print_server_url,
                 const DictionaryValue* print_system_settings);
 
@@ skipping 12 matching lines @@
                              const std::string cloud_print_xmpp_token,
                              const std::string email,
                              const std::string& proxy_id);
 
   // Called on the CloudPrintProxyBackend core_thread_ to perform
   // shutdown.
   void DoShutdown();
   void DoRegisterSelectedPrinters(
       const printing::PrinterList& printer_list);
 
-  // URLFetcher::Delegate implementation.
-  virtual void OnURLFetchComplete(const URLFetcher* source, const GURL& url,
-                                  const URLRequestStatus& status,
-                                  int response_code,
-                                  const ResponseCookies& cookies,
-                                  const std::string& data);
+  // CloudPrintURLFetcher::Delegate implementation.
+  virtual CloudPrintURLFetcher::ResponseAction HandleJSONData(
+      const 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,
                                    const std::string& printer_id);
   virtual void OnAuthError();
 
   // notifier::TalkMediator::Delegate implementation.
   virtual void OnNotificationStateChange(
       bool notifications_enabled);
   virtual void OnIncomingNotification(
       const IncomingNotificationData& notification_data);
   virtual void OnOutgoingNotification();
 
- protected:
+ private:
   // Prototype for a response handler.
-  typedef void (CloudPrintProxyBackend::Core::*ResponseHandler)(
-      const URLFetcher* source, const GURL& url,
-      const URLRequestStatus& status, int response_code,
-      const ResponseCookies& cookies, const std::string& data);
+  typedef CloudPrintURLFetcher::ResponseAction
+      (CloudPrintProxyBackend::Core::*ResponseHandler)(
+          const URLFetcher* source,
+          const GURL& url,
+          DictionaryValue* json_data,
+          bool succeeded);
   // Begin response handlers
-  void HandlePrinterListResponse(const URLFetcher* source, const GURL& url,
-                                 const URLRequestStatus& status,
-                                 int response_code,
-                                 const ResponseCookies& cookies,
-                                 const std::string& data);
-  void HandleRegisterPrinterResponse(const URLFetcher* source,
-                                     const GURL& url,
-                                     const URLRequestStatus& status,
-                                     int response_code,
-                                     const ResponseCookies& cookies,
-                                     const std::string& data);
+  CloudPrintURLFetcher::ResponseAction HandlePrinterListResponse(
+      const URLFetcher* source,
+      const GURL& url,
+      DictionaryValue* json_data,
+      bool succeeded);
+
+  CloudPrintURLFetcher::ResponseAction HandleRegisterPrinterResponse(
+      const 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);
   void NotifyAuthenticated(
     const std::string& cloud_print_token,
     const std::string& cloud_print_xmpp_token,
     const std::string& email);
   void NotifyAuthenticationFailed();
 
+  URLFetcherProtectEntry* CreateDefaultRetryPolicy();
+
   // Starts a new printer registration process.
   void StartRegistration();
   // Ends the printer registration process.
   void EndRegistration();
   // Registers printer capabilities and defaults for the next printer in the
   // list with the cloud print server.
   void RegisterNextPrinter();
   // Retrieves the list of registered printers for this user/proxy combination
   // from the cloud print server.
   void GetRegisteredPrinters();
-  void HandleServerError(Task* task_to_retry);
   // Removes the given printer from the list. Returns false if the printer
   // did not exist in the list.
   bool RemovePrinterFromList(const std::string& printer_name);
   // Initializes a job handler object for the specified printer. The job
   // handler is responsible for checking for pending print jobs for this
   // printer and print them.
   void InitJobHandlerForPrinter(DictionaryValue* printer_data);
 
   void HandlePrinterNotification(const std::string& printer_id);
   void PollForJobs();
   // Schedules a task to poll for jobs. Does nothing if a task is already
   // scheduled.
   void ScheduleJobPoll();
 
   // Our parent CloudPrintProxyBackend
   CloudPrintProxyBackend* backend_;
 
   GURL cloud_print_server_url_;
   scoped_ptr<DictionaryValue> print_system_settings_;
   // Pointer to current print system.
   scoped_refptr<cloud_print::PrintSystem> print_system_;
   // The list of printers to be registered with the cloud print server.
   // To begin with,this list is initialized with the list of local and network
   // printers available. Then we query the server for the list of printers
   // already registered. We trim this list to remove the printers already
   // registered. We then pass a copy of this list to the frontend to give the
   // user a chance to further trim the list. When the frontend gives us the
   // final list we make a copy into this so that we can start registering.
   printing::PrinterList printer_list_;
-  // The URLFetcher instance for the current request
-  scoped_ptr<URLFetcher> request_;
+  // The CloudPrintURLFetcher instance for the current request.
+  scoped_refptr<CloudPrintURLFetcher> request_;
   // The index of the nex printer to be uploaded.
   size_t next_upload_index_;
   // The unique id for this proxy
   std::string proxy_id_;
   // The GAIA auth token
   std::string auth_token_;
-  // The number of consecutive times that connecting to the server failed.
-  int server_error_count_;
   // Cached info about the last printer that we tried to upload. We cache this
   // so we won't have to requery the printer if the upload fails and we need
   // to retry.
   std::string last_uploaded_printer_name_;
   printing::PrinterCapsAndDefaults last_uploaded_printer_info_;
   // A map of printer id to job handler.
   typedef std::map<std::string, scoped_refptr<PrinterJobHandler> >
       JobHandlerMap;
   JobHandlerMap job_handler_map_;
   ResponseHandler next_response_handler_;
@@ skipping 66 matching lines @@
   core_thread_.message_loop()->PostTask(FROM_HERE,
       NewRunnableMethod(
           core_.get(),
           &CloudPrintProxyBackend::Core::DoRegisterSelectedPrinters,
           printer_list));
 }
 
 CloudPrintProxyBackend::Core::Core(CloudPrintProxyBackend* backend,
                                    const GURL& cloud_print_server_url,
                                    const DictionaryValue* print_system_settings)
-    : backend_(backend), cloud_print_server_url_(cloud_print_server_url),
-      next_upload_index_(0), server_error_count_(0),
-      next_response_handler_(NULL), new_printers_available_(false),
-      notifications_enabled_(false), job_poll_scheduled_(false) {
+    : backend_(backend),
+      cloud_print_server_url_(cloud_print_server_url),
+      next_upload_index_(0),
+      next_response_handler_(NULL),
+      new_printers_available_(false),
+      notifications_enabled_(false),
+      job_poll_scheduled_(false) {
   if (print_system_settings) {
     // It is possible to have no print settings specified.
     print_system_settings_.reset(
         reinterpret_cast<DictionaryValue*>(print_system_settings->DeepCopy()));
   }
 }
 
 void CloudPrintProxyBackend::Core::DoInitializeWithLsid(
     const std::string& lsid, const std::string& proxy_id) {
   DCHECK(MessageLoop::current() == backend_->core_thread_.message_loop());
@@ skipping 70 matching lines @@
   talk_mediator_->AddSubscribedServiceUrl(push_notifications_channel_);
   talk_mediator_->SetDelegate(this);
   talk_mediator_->SetAuthToken(email, cloud_print_xmpp_token,
                                kSyncGaiaServiceId);
   talk_mediator_->Login();
 
   print_server_watcher_ = print_system_->CreatePrintServerWatcher();
   print_server_watcher_->StartWatching(this);
 
   proxy_id_ = proxy_id;
+
+  // Register the request retry policies for cloud print APIs and job data
+  // requests.
+  URLFetcherProtectManager::GetInstance()->Register(
+      kCloudPrintAPIRetryPolicy, CreateDefaultRetryPolicy());
+  URLFetcherProtectManager::GetInstance()->Register(
+      kJobDataRetryPolicy, CreateDefaultRetryPolicy())->SetMaxRetries(
+          kJobDataMaxRetryCount);
+
   StartRegistration();
 }
 
+URLFetcherProtectEntry*
+CloudPrintProxyBackend::Core::CreateDefaultRetryPolicy() {
+  // Times are in milliseconds.
+  const int kSlidingWindowPeriod = 2000;
+  const int kMaxSendThreshold = 20;
+  const int kMaxRetries = -1;
+  const int kInitialTimeout = 100;
+  const double kMultiplier = 2.0;
+  const int kConstantFactor = 100;
+  const int kMaximumTimeout = 5*60*1000;
+  return new URLFetcherProtectEntry(kSlidingWindowPeriod,
+                                    kMaxSendThreshold,
+                                    kMaxRetries,
+                                    kInitialTimeout,
+                                    kMultiplier,
+                                    kConstantFactor,
+                                    kMaximumTimeout);
+}
+
 void CloudPrintProxyBackend::Core::StartRegistration() {
   DCHECK(MessageLoop::current() == backend_->core_thread_.message_loop());
   printer_list_.clear();
   print_system_->GetPrintBackend()->EnumeratePrinters(&printer_list_);
-  server_error_count_ = 0;
   // Now we need to ask the server about printers that were registered on the
   // server so that we can trim this list.
   GetRegisteredPrinters();
 }
 
 void CloudPrintProxyBackend::Core::EndRegistration() {
   DCHECK(MessageLoop::current() == backend_->core_thread_.message_loop());
-  request_.reset();
+  request_ = NULL;
   if (new_printers_available_) {
     new_printers_available_ = false;
     StartRegistration();
   }
 }
 
 void CloudPrintProxyBackend::Core::DoShutdown() {
   DCHECK(MessageLoop::current() == backend_->core_thread_.message_loop());
   VLOG(1) << "CP_PROXY: Shutdown proxy, id: " << proxy_id_;
   if (print_server_watcher_ != NULL)
     print_server_watcher_->StopWatching();
 
   // Need to kill all running jobs.
   while (!job_handler_map_.empty()) {
     JobHandlerMap::iterator index = job_handler_map_.begin();
     // Shutdown will call our OnPrinterJobHandlerShutdown method which will
     // remove this from the map.
     index->second->Shutdown();
   }
   // Important to delete the TalkMediator on this thread.
   talk_mediator_.reset();
   notifications_enabled_ = false;
-  request_.reset();
+  request_ = NULL;
   MessageLoop::current()->QuitNow();
 }
 
 void CloudPrintProxyBackend::Core::DoRegisterSelectedPrinters(
     const printing::PrinterList& printer_list) {
   DCHECK(MessageLoop::current() == backend_->core_thread_.message_loop());
   if (!print_system_.get())
     return;  // No print system available.
-  server_error_count_ = 0;
   printer_list_.assign(printer_list.begin(), printer_list.end());
   next_upload_index_ = 0;
   RegisterNextPrinter();
 }
 
 void CloudPrintProxyBackend::Core::GetRegisteredPrinters() {
   DCHECK(MessageLoop::current() == backend_->core_thread_.message_loop());
-  request_.reset(
-      new URLFetcher(
-          CloudPrintHelpers::GetUrlForPrinterList(cloud_print_server_url_,
-                                                  proxy_id_),
-          URLFetcher::GET, this));
-  CloudPrintHelpers::PrepCloudPrintRequest(request_.get(), auth_token_);
+  GURL printer_list_url =
+      CloudPrintHelpers::GetUrlForPrinterList(cloud_print_server_url_,
+                                              proxy_id_);
   next_response_handler_ =
       &CloudPrintProxyBackend::Core::HandlePrinterListResponse;
-  request_->Start();
+  request_ = new CloudPrintURLFetcher;
+  request_->StartGetRequest(printer_list_url, this, auth_token_,
+                            kCloudPrintAPIRetryPolicy);
 }
 
 void CloudPrintProxyBackend::Core::RegisterNextPrinter() {
   DCHECK(MessageLoop::current() == backend_->core_thread_.message_loop());
   // For the next printer to be uploaded, create a multi-part post request to
   // upload the printer capabilities and the printer defaults.
   if (next_upload_index_ < printer_list_.size()) {
     const printing::PrinterBasicInfo& info =
         printer_list_.at(next_upload_index_);
     bool have_printer_info = true;
@@ skipping 39 matching lines @@
       // Send a hash of the printer capabilities to the server. We will use this
       // later to check if the capabilities have changed
       CloudPrintHelpers::AddMultipartValueForUpload(
           kPrinterCapsHashValue,
           MD5String(last_uploaded_printer_info_.printer_capabilities),
           mime_boundary, std::string(), &post_data);
       // Terminate the request body
       post_data.append("--" + mime_boundary + "--\r\n");
       std::string mime_type("multipart/form-data; boundary=");
       mime_type += mime_boundary;
-      request_.reset(
-          new URLFetcher(
-              CloudPrintHelpers::GetUrlForPrinterRegistration(
-                  cloud_print_server_url_),
-              URLFetcher::POST, this));
-      CloudPrintHelpers::PrepCloudPrintRequest(request_.get(), auth_token_);
-      request_->set_upload_data(mime_type, post_data);
+      GURL register_url = CloudPrintHelpers::GetUrlForPrinterRegistration(
+          cloud_print_server_url_);
+
       next_response_handler_ =
           &CloudPrintProxyBackend::Core::HandleRegisterPrinterResponse;
-      request_->Start();
+      request_ = new CloudPrintURLFetcher;
+      request_->StartPostRequest(register_url, this, auth_token_,
+                                 kCloudPrintAPIRetryPolicy, mime_type,
+                                 post_data);
+
     } else {
       LOG(ERROR) << "CP_PROXY: Failed to get printer info for: " <<
           info.printer_name;
       next_upload_index_++;
       MessageLoop::current()->PostTask(FROM_HERE, NewRunnableMethod(this,
           &CloudPrintProxyBackend::Core::RegisterNextPrinter));
     }
   } else {
     EndRegistration();
   }
@@ skipping 26 matching lines @@
     int interval_in_seconds = base::RandInt(kMinJobPollIntervalSecs,
                                             kMaxJobPollIntervalSecs);
     MessageLoop::current()->PostDelayedTask(
         FROM_HERE,
         NewRunnableMethod(this, &CloudPrintProxyBackend::Core::PollForJobs),
         interval_in_seconds * 1000);
     job_poll_scheduled_ = true;
   }
 }
 
-// URLFetcher::Delegate implementation.
-void CloudPrintProxyBackend::Core::OnURLFetchComplete(
-    const URLFetcher* source, const GURL& url, const URLRequestStatus& status,
-    int response_code, const ResponseCookies& cookies,
-    const std::string& data) {
-  DCHECK(source == request_.get());
-  // If we get an auth error, we need to give up right away and notify the
-  // frontend loop.
-  if (RC_FORBIDDEN == response_code) {
-    backend_->frontend_loop_->PostTask(FROM_HERE, NewRunnableMethod(this,
-        &Core::NotifyAuthenticationFailed));
-  } else {
-    // We need a next response handler
-    DCHECK(next_response_handler_);
-    (this->*next_response_handler_)(source, url, status, response_code,
-                                    cookies, data);
-  }
+// CloudPrintURLFetcher::Delegate implementation.
+CloudPrintURLFetcher::ResponseAction
+CloudPrintProxyBackend::Core::HandleJSONData(
+    const 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();
 }
 
 void CloudPrintProxyBackend::Core::NotifyPrinterListAvailable(
     const printing::PrinterList& printer_list) {
   DCHECK(MessageLoop::current() == backend_->frontend_loop_);
   backend_->frontend_->OnPrinterListAvailable(printer_list);
 }
 
 void CloudPrintProxyBackend::Core::NotifyAuthenticated(
     const std::string& cloud_print_token,
     const std::string& cloud_print_xmpp_token,
     const std::string& email) {
   DCHECK(MessageLoop::current() == backend_->frontend_loop_);
   backend_->frontend_->OnAuthenticated(cloud_print_token,
                                        cloud_print_xmpp_token, email);
 }
 
 void CloudPrintProxyBackend::Core::NotifyAuthenticationFailed() {
   DCHECK(MessageLoop::current() == backend_->frontend_loop_);
   backend_->frontend_->OnAuthenticationFailed();
 }
 
-void CloudPrintProxyBackend::Core::HandlePrinterListResponse(
-    const URLFetcher* source, const GURL& url, const URLRequestStatus& status,
-    int response_code, const ResponseCookies& cookies,
-    const std::string& data) {
+CloudPrintURLFetcher::ResponseAction
+CloudPrintProxyBackend::Core::HandlePrinterListResponse(
+    const URLFetcher* source,
+    const GURL& url,
+    DictionaryValue* json_data,
+    bool succeeded) {
   DCHECK(MessageLoop::current() == backend_->core_thread_.message_loop());
-  bool succeeded = false;
-  if (status.is_success() && response_code == 200) {
-    server_error_count_ = 0;
-    // Parse the response JSON for the list of printers already registered.
-    DictionaryValue* response_dict_temp = NULL;
-    CloudPrintHelpers::ParseResponseJSON(data, &succeeded,
-                                         &response_dict_temp);
-    scoped_ptr<DictionaryValue> response_dict;
-    response_dict.reset(response_dict_temp);
-    if (succeeded) {
-      DCHECK(response_dict.get());
-      ListValue* printer_list = NULL;
-      response_dict->GetList(kPrinterListValue, &printer_list);
-      // There may be no "printers" value in the JSON
-      if (printer_list) {
-        for (size_t index = 0; index < printer_list->GetSize(); index++) {
-          DictionaryValue* printer_data = NULL;
-          if (printer_list->GetDictionary(index, &printer_data)) {
-            std::string printer_name;
-            printer_data->GetString(kNameValue, &printer_name);
-            RemovePrinterFromList(printer_name);
-            InitJobHandlerForPrinter(printer_data);
-          } else {
-            NOTREACHED();
-          }
-        }
-      }
-      MessageLoop::current()->DeleteSoon(FROM_HERE, request_.release());
-      if (!printer_list_.empty()) {
-        // Let the frontend know that we have a list of printers available.
-        backend_->frontend_loop_->PostTask(FROM_HERE, NewRunnableMethod(this,
-            &Core::NotifyPrinterListAvailable, printer_list_));
+  if (!succeeded) {
+    NOTREACHED();
+    return CloudPrintURLFetcher::RETRY_REQUEST;
+  }
+  ListValue* printer_list = NULL;
+  json_data->GetList(kPrinterListValue, &printer_list);
+  // There may be no "printers" value in the JSON
+  if (printer_list) {
+    for (size_t index = 0; index < printer_list->GetSize(); index++) {
+      DictionaryValue* printer_data = NULL;
+      if (printer_list->GetDictionary(index, &printer_data)) {
+        std::string printer_name;
+        printer_data->GetString(kNameValue, &printer_name);
+        RemovePrinterFromList(printer_name);
+        InitJobHandlerForPrinter(printer_data);
       } else {
-        // No more work to be done here.
-        MessageLoop::current()->PostTask(
-            FROM_HERE, NewRunnableMethod(this, &Core::EndRegistration));
+        NOTREACHED();
       }
     }
   }
-
-  if (!succeeded)
-    HandleServerError(NewRunnableMethod(this, &Core::GetRegisteredPrinters));
+  request_ = NULL;
+  if (!printer_list_.empty()) {
+    // Let the frontend know that we have a list of printers available.
+    backend_->frontend_loop_->PostTask(FROM_HERE, NewRunnableMethod(this,
+        &Core::NotifyPrinterListAvailable, printer_list_));
+  } else {
+    // No more work to be done here.
+    MessageLoop::current()->PostTask(
+        FROM_HERE, NewRunnableMethod(this, &Core::EndRegistration));
+  }
+  return CloudPrintURLFetcher::STOP_PROCESSING;
 }
 
 void CloudPrintProxyBackend::Core::InitJobHandlerForPrinter(
     DictionaryValue* printer_data) {
   DCHECK(MessageLoop::current() == backend_->core_thread_.message_loop());
   DCHECK(printer_data);
   PrinterJobHandler::PrinterInfoFromCloud printer_info_cloud;
   printer_data->GetString(kIdValue, &printer_info_cloud.printer_id);
   DCHECK(!printer_info_cloud.printer_id.empty());
   VLOG(1) << "CP_PROXY: Init job handler for printer id: "
@@ skipping 28 matching lines @@
     }
     scoped_refptr<PrinterJobHandler> job_handler;
     job_handler = new PrinterJobHandler(printer_info, printer_info_cloud,
                                         auth_token_, cloud_print_server_url_,
                                         print_system_.get(), this);
     job_handler_map_[printer_info_cloud.printer_id] = job_handler;
     job_handler->Initialize();
   }
 }
 
-void CloudPrintProxyBackend::Core::HandleRegisterPrinterResponse(
-    const URLFetcher* source, const GURL& url, const URLRequestStatus& status,
-    int response_code, const ResponseCookies& cookies,
-    const std::string& data) {
+CloudPrintURLFetcher::ResponseAction
+CloudPrintProxyBackend::Core::HandleRegisterPrinterResponse(
+    const URLFetcher* source,
+    const GURL& url,
+    DictionaryValue* json_data,
+    bool succeeded) {
   DCHECK(MessageLoop::current() == backend_->core_thread_.message_loop());
-  VLOG(1) << "CP_PROXY: Handle register printer response, code: "
-          << response_code;
-  Task* next_task =
+  if (succeeded) {
+    ListValue* printer_list = NULL;
+    json_data->GetList(kPrinterListValue, &printer_list);
+    // There should be a "printers" value in the JSON
+    DCHECK(printer_list);
+    if (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);
-  if (status.is_success() && (response_code == 200)) {
-    bool succeeded = false;
-    DictionaryValue* response_dict = NULL;
-    CloudPrintHelpers::ParseResponseJSON(data, &succeeded, &response_dict);
-    if (succeeded) {
-      DCHECK(response_dict);
-      ListValue* printer_list = NULL;
-      response_dict->GetList(kPrinterListValue, &printer_list);
-      // There should be a "printers" value in the JSON
-      DCHECK(printer_list);
-      if (printer_list) {
-        DictionaryValue* printer_data = NULL;
-        if (printer_list->GetDictionary(0, &printer_data))
-          InitJobHandlerForPrinter(printer_data);
-      }
-    }
-    server_error_count_ = 0;
-    next_upload_index_++;
-    MessageLoop::current()->PostTask(FROM_HERE, next_task);
-  } else {
-    HandleServerError(next_task);
-  }
-}
-
-void CloudPrintProxyBackend::Core::HandleServerError(Task* task_to_retry) {
-  DCHECK(MessageLoop::current() == backend_->core_thread_.message_loop());
-  VLOG(1) << "CP_PROXY: Server error.";
-  CloudPrintHelpers::HandleServerError(
-      &server_error_count_, -1, kMaxRetryInterval, kBaseRetryInterval,
-      task_to_retry, NULL);
+                        &CloudPrintProxyBackend::Core::RegisterNextPrinter));
+  return CloudPrintURLFetcher::STOP_PROCESSING;
 }
 
 bool CloudPrintProxyBackend::Core::RemovePrinterFromList(
     const std::string& printer_name) {
   DCHECK(MessageLoop::current() == backend_->core_thread_.message_loop());
   for (printing::PrinterList::iterator index = printer_list_.begin();
        index != printer_list_.end(); index++) {
     if (0 == base::strcasecmp(index->printer_name.c_str(),
                               printer_name.c_str())) {
       index = printer_list_.erase(index);
@@ skipping 48 matching lines @@
   VLOG(1) << "CP_PROXY: Printer job handle shutdown, id " << printer_id;
   job_handler_map_.erase(printer_id);
 }
 
 void CloudPrintProxyBackend::Core::OnAuthError() {
   DCHECK(MessageLoop::current() == backend_->core_thread_.message_loop());
   VLOG(1) << "CP_PROXY: Auth Error";
   backend_->frontend_loop_->PostTask(FROM_HERE, NewRunnableMethod(this,
       &Core::NotifyAuthenticationFailed));
 }