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

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_number_conversions.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/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"
@@ skipping 83 matching lines @@
   // 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();
@@ skipping 216 matching lines @@
   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_->EnumeratePrinters(&printer_list_);
   // 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() {
@@ skipping 37 matching lines @@
 
 void CloudPrintProxyBackend::Core::GetRegisteredPrinters() {
   DCHECK(MessageLoop::current() == backend_->core_thread_.message_loop());
   GURL printer_list_url =
       CloudPrintHelpers::GetUrlForPrinterList(cloud_print_server_url_,
                                               proxy_id_);
   next_response_handler_ =
       &CloudPrintProxyBackend::Core::HandlePrinterListResponse;
   request_ = new CloudPrintURLFetcher;
   request_->StartGetRequest(printer_list_url, this, auth_token_,
-                            kCloudPrintAPIRetryPolicy);
+                            kCloudPrintAPIMaxRetryCount);
 }
 
 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 46 matching lines @@
       post_data.append("--" + mime_boundary + "--\r\n");
       std::string mime_type("multipart/form-data; boundary=");
       mime_type += mime_boundary;
       GURL register_url = CloudPrintHelpers::GetUrlForPrinterRegistration(
           cloud_print_server_url_);
 
       next_response_handler_ =
           &CloudPrintProxyBackend::Core::HandleRegisterPrinterResponse;
       request_ = new CloudPrintURLFetcher;
       request_->StartPostRequest(register_url, this, auth_token_,
-                                 kCloudPrintAPIRetryPolicy, mime_type,
+                                 kCloudPrintAPIMaxRetryCount, 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 {
@@ skipping 260 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));
 }