Implement exponential back-off mechanism and enforce it at the URLRequestHttpJob level.

chrome/service/cloud_print/printer_job_handler.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/printer_job_handler.h"
 
 #include "base/file_util.h"
 #include "base/json/json_reader.h"
 #include "base/md5.h"
 #include "base/string_util.h"
@@ skipping 73 matching lines @@
     // Check if we have work to do.
     if (HavePendingTasks()) {
       if (printer_delete_pending_) {
         printer_delete_pending_ = false;
         task_in_progress_ = true;
         SetNextJSONHandler(&PrinterJobHandler::HandlePrinterDeleteResponse);
         request_ = new CloudPrintURLFetcher;
         request_->StartGetRequest(
             CloudPrintHelpers::GetUrlForPrinterDelete(
                 cloud_print_server_url_, printer_info_cloud_.printer_id),
-            this, auth_token_, kCloudPrintAPIRetryPolicy);
+            this, auth_token_, kCloudPrintAPIMaxRetryCount);
       }
       if (!task_in_progress_ && printer_update_pending_) {
         printer_update_pending_ = false;
         task_in_progress_ = UpdatePrinterInfo();
       }
       if (!task_in_progress_ && job_check_pending_) {
         task_in_progress_ = true;
         job_check_pending_ = false;
         // We need to fetch any pending jobs for this printer
         SetNextJSONHandler(&PrinterJobHandler::HandleJobMetadataResponse);
         request_ = new CloudPrintURLFetcher;
         request_->StartGetRequest(
             CloudPrintHelpers::GetUrlForJobFetch(
                 cloud_print_server_url_, printer_info_cloud_.printer_id,
                 job_fetch_reason_),
-            this, auth_token_, kCloudPrintAPIRetryPolicy);
+            this, auth_token_, kCloudPrintAPIMaxRetryCount);
         last_job_fetch_time_ = base::TimeTicks::Now();
         VLOG(1) << "Last job fetch time for printer "
                 << printer_info_.printer_name.c_str() << " is "
                 << last_job_fetch_time_.ToInternalValue();
         job_fetch_reason_.clear();
       }
     }
   }
 }
 
@@ skipping 86 matching lines @@
   if (!post_data.empty()) {
     // Terminate the request body
     post_data.append("--" + mime_boundary + "--\r\n");
     std::string mime_type("multipart/form-data; boundary=");
     mime_type += mime_boundary;
     SetNextJSONHandler(&PrinterJobHandler::HandlePrinterUpdateResponse);
     request_ = new CloudPrintURLFetcher;
     request_->StartPostRequest(
         CloudPrintHelpers::GetUrlForPrinterUpdate(
             cloud_print_server_url_, printer_info_cloud_.printer_id),
-        this, auth_token_, kCloudPrintAPIRetryPolicy, mime_type, post_data);
+        this, auth_token_, kCloudPrintAPIMaxRetryCount, mime_type, post_data);
     ret = true;
   }
   return ret;
 }
 
 // CloudPrintURLFetcher::Delegate implementation.
 CloudPrintURLFetcher::ResponseAction PrinterJobHandler::HandleRawData(
     const URLFetcher* source,
     const GURL& url,
     const std::string& data) {
@@ skipping 120 matching lines @@
         job_data->GetString(kIdValue, &job_details_.job_id_);
         job_data->GetString(kTitleValue, &job_details_.job_title_);
         std::string print_ticket_url;
         job_data->GetString(kTicketUrlValue, &print_ticket_url);
         job_data->GetString(kFileUrlValue, &print_data_url_);
         SetNextDataHandler(&PrinterJobHandler::HandlePrintTicketResponse);
         request_ = new CloudPrintURLFetcher;
         request_->StartGetRequest(GURL(print_ticket_url.c_str()),
                                   this,
                                   auth_token_,
-                                  kCloudPrintAPIRetryPolicy);
+                                  kCloudPrintAPIMaxRetryCount);
       }
     }
   }
   // If no jobs are available, go to the Stop state.
   if (!job_available)
     MessageLoop::current()->PostTask(
         FROM_HERE, NewRunnableMethod(this, &PrinterJobHandler::Stop));
   return CloudPrintURLFetcher::STOP_PROCESSING;
 }
 
 CloudPrintURLFetcher::ResponseAction
 PrinterJobHandler::HandlePrintTicketResponse(const URLFetcher* source,
                                              const GURL& url,
                                              const std::string& data) {
   VLOG(1) << "CP_PROXY: Handle print ticket response, id: "
           << printer_info_cloud_.printer_id;
   if (print_system_->ValidatePrintTicket(printer_info_.printer_name, data)) {
     job_details_.print_ticket_ = data;
     SetNextDataHandler(&PrinterJobHandler::HandlePrintDataResponse);
     request_ = new CloudPrintURLFetcher;
     request_->StartGetRequest(GURL(print_data_url_.c_str()),
                               this,
                               auth_token_,
-                              kJobDataRetryPolicy);
+                              kJobDataMaxRetryCount);
   } else {
     // The print ticket was not valid. We are done here.
     FailedFetchingJobData();
   }
   return CloudPrintURLFetcher::STOP_PROCESSING;
 }
 
 CloudPrintURLFetcher::ResponseAction
 PrinterJobHandler::HandlePrintDataResponse(const URLFetcher* source,
                                            const GURL& url,
@@ skipping 127 matching lines @@
         SetNextJSONHandler(
             &PrinterJobHandler::HandleFailureStatusUpdateResponse);
       }
       request_ = new CloudPrintURLFetcher;
       request_->StartGetRequest(
           CloudPrintHelpers::GetUrlForJobStatusUpdate(cloud_print_server_url_,
                                                       job_details_.job_id_,
                                                       status),
           this,
           auth_token_,
-          kCloudPrintAPIRetryPolicy);
+          kCloudPrintAPIMaxRetryCount);
     }
   }
 }
 
 void PrinterJobHandler::SetNextJSONHandler(JSONDataHandler handler) {
   next_json_data_handler_ = handler;
   next_data_handler_ = NULL;
 }
 
 void PrinterJobHandler::SetNextDataHandler(DataHandler handler) {
@@ skipping 42 matching lines @@
 }
 
 void PrinterJobHandler::OnJobSpoolFailed() {
   DCHECK(MessageLoop::current() == print_thread_.message_loop());
   job_spooler_ = NULL;
   job_handler_message_loop_proxy_->PostTask(FROM_HERE,
                                             NewRunnableMethod(this,
                                                 &PrinterJobHandler::JobFailed,
                                                 PRINT_FAILED));
 }