Move backoff_delay_ to the inner Core class.

content/common/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/url_fetcher.h"
 
 #include <set>
 
 #include "base/compiler_specific.h"
 #include "base/file_path.h"
@@ skipping 254 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 124 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 205 matching lines @@
     ReleaseRequest();
 
     base::TimeDelta backoff_delay;
     // Checks the response from server.
     if (response_code_ >= 500 ||
         status.os_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.
       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_) {
         StartURLRequestWhenAppropriate();
         return;
@@ skipping 130 matching lines @@
 }
 
 void URLFetcher::Core::OnCompletedURLRequest(
     const net::URLRequestStatus& status,
     base::TimeDelta backoff_delay) {
   DCHECK(delegate_loop_proxy_->BelongsToCurrentThread());
 
   // Save the status and backoff_delay so that delegates can read it.
   if (delegate_) {
     status_ = status;
-    fetcher_->backoff_delay_ = backoff_delay;
+    backoff_delay_ = backoff_delay;

[willchan no longer on Chromium, 2011/06/30 15:50:24]

It's never read, only written. How do tests use this guy?

[wtc, 2011/06/30 21:36:02]

It's never read in this file.  But it can be read via the
URLFetcher::backoff_delay() getter.  It is only read by
the following code (one is a test, the other is not a test):
content/common/url_fetcher_unittest.cc
chrome/browser/autofill/autofill_download.cc

     InformDelegateFetchIsComplete();
   }
 }
 
 void URLFetcher::Core::InformDelegateFetchIsComplete() {
   delegate_->OnURLFetchComplete(fetcher_);
 }
 
 void URLFetcher::Core::NotifyMalformedContent() {
   DCHECK(io_message_loop_proxy_->BelongsToCurrentThread());
@@ skipping 92 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(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 97 matching lines @@
 }
 
 // static
 int URLFetcher::GetNumFetcherCores() {
   return Core::g_registry.Get().size();
 }
 
 URLFetcher::Delegate* URLFetcher::delegate() const {
   return core_->delegate();
 }