Move backoff_delay_ to the inner Core class.

content/common/net/url_fetcher.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 "content/common/net/url_fetcher.h"
 
 #include <set>
 
 #include "base/compiler_specific.h"
 #include "base/file_path.h"
@@ skipping 267 matching lines @@
   // Where should responses be saved?
   ResponseDestinationType response_destination_;
 
   // If |automatically_retry_on_5xx_| is false, 5xx responses will be
   // propagated to the observer, if it is true URLFetcher will automatically
   // re-execute the request, after the back-off delay has expired.
   // true by default.
   bool automatically_retry_on_5xx_;
   // Maximum retries allowed.
   int max_retries_;
+  // Back-off time delay. 0 by default.
+  base::TimeDelta backoff_delay_;
 
   static base::LazyInstance<Registry> g_registry;
 
   friend class URLFetcher;
   DISALLOW_COPY_AND_ASSIGN(Core);
 };
 
 URLFetcher::Core::Registry::Registry() {}
 URLFetcher::Core::Registry::~Registry() {}
 
@@ skipping 174 matching lines @@
 // static
 URLFetcher::Factory* URLFetcher::factory_ = NULL;
 
 void URLFetcher::Delegate::OnURLFetchComplete(
     const URLFetcher* source,
     const GURL& url,
     const net::URLRequestStatus& status,
     int response_code,
     const net::ResponseCookies& cookies,
     const std::string& data) {
-  NOTREACHED() << "If you don't implemnt this, the no-params version "
+  NOTREACHED() << "If you don't implement this, the no-params version "
                << "should also be implemented, in which case this "
                << "method won't be called...";
 }
 
 // TODO(skerner): This default implementation will be removed, and the
 // method made pure virtual, once all users of URLFetcher are updated
 // to not expect response data as a string argument.  Once this is removed,
 // the method URLFetcher::GetResponseStringRef() can be removed as well.
 // crbug.com/83592 tracks this.
 void URLFetcher::Delegate::OnURLFetchComplete(const URLFetcher* source) {
@@ skipping 229 matching lines @@
   DCHECK(io_message_loop_proxy_->BelongsToCurrentThread());
   base::TimeDelta backoff_delay;
 
   // Checks the response from server.
   if (response_code_ >= 500 ||
       status_.error() == net::ERR_TEMPORARILY_THROTTLED) {
     // When encountering a server error, we will send the request again
     // after backoff time.
     ++num_retries_;
 
-    // Note that backoff_delay_ may be 0 because (a) the URLRequestThrottler
+    // Note that backoff_delay may be 0 because (a) the URLRequestThrottler
     // code does not necessarily back off on the first error, and (b) it
     // only backs off on some of the 5xx status codes.
     base::TimeTicks backoff_release_time = GetBackoffReleaseTime();
     backoff_delay = backoff_release_time - base::TimeTicks::Now();
     if (backoff_delay < base::TimeDelta())
       backoff_delay = base::TimeDelta();
 
     if (automatically_retry_on_5xx_ &&
         num_retries_ <= max_retries_) {
       StartOnIOThread();
@@ skipping 131 matching lines @@
   was_cancelled_ = true;
   temp_file_writer_.reset();
 }
 
 void URLFetcher::Core::OnCompletedURLRequest(
     base::TimeDelta backoff_delay) {
   DCHECK(delegate_loop_proxy_->BelongsToCurrentThread());
 
   // Save the status and backoff_delay so that delegates can read it.
   if (delegate_) {
-    fetcher_->backoff_delay_ = backoff_delay;
+    backoff_delay_ = backoff_delay;
     InformDelegateFetchIsComplete();
   }
 }
 
 void URLFetcher::Core::InformDelegateFetchIsComplete() {
   CHECK(delegate_loop_proxy_->BelongsToCurrentThread());
   if (delegate_) {
     delegate_->OnURLFetchComplete(fetcher_);
   }
 }
@@ skipping 95 matching lines @@
 }
 
 int URLFetcher::max_retries() const {
   return core_->max_retries_;
 }
 
 void URLFetcher::set_max_retries(int max_retries) {
   core_->max_retries_ = max_retries;
 }
 
+base::TimeDelta URLFetcher::backoff_delay() const {
+  return core_->backoff_delay_;
+}
+
+void URLFetcher::set_backoff_delay_for_testing(
+    base::TimeDelta backoff_delay) {
+  core_->backoff_delay_ = backoff_delay;
+}
+
 void URLFetcher::SaveResponseToTemporaryFile(
     scoped_refptr<base::MessageLoopProxy> file_message_loop_proxy) {
   core_->file_message_loop_proxy_ = file_message_loop_proxy;
   core_->response_destination_ = TEMP_FILE;
 }
 
 net::HttpResponseHeaders* URLFetcher::response_headers() const {
   return core_->response_headers_;
 }
 
@@ skipping 113 matching lines @@
 }
 
 // static
 int URLFetcher::GetNumFetcherCores() {
   return Core::g_registry.Get().size();
 }
 
 URLFetcher::Delegate* URLFetcher::delegate() const {
   return core_->delegate();
 }