Introduce ERR_NETWORK_CHANGED and allow URLFetcher to automatically retry on that error.

net/url_request/url_fetcher_core.cc

 // Copyright (c) 2012 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 "net/url_request/url_fetcher_core.h"
 
 #include "base/bind.h"
 #include "base/file_util_proxy.h"
 #include "base/logging.h"
 #include "base/single_thread_task_runner.h"
@@ skipping 262 matching lines @@
       delegate_(d),
       delegate_task_runner_(
           base::ThreadTaskRunnerHandle::Get()),
       request_(NULL),
       load_flags_(LOAD_NORMAL),
       response_code_(URLFetcher::RESPONSE_CODE_INVALID),
       buffer_(new IOBuffer(kBufferSize)),
       url_request_data_key_(NULL),
       was_fetched_via_proxy_(false),
       is_chunked_upload_(false),
-      num_retries_(0),
       was_cancelled_(false),
       response_destination_(STRING),
       stop_on_redirect_(false),
       stopped_on_redirect_(false),
       automatically_retry_on_5xx_(true),
-      max_retries_(0),
+      num_retries_on_5xx_(0),
+      max_retries_on_5xx_(0),
+      num_retries_on_network_changes_(0),
+      max_retries_on_network_changes_(0),
       current_upload_bytes_(-1),
       current_response_bytes_(0),
       total_response_bytes_(-1) {
   CHECK(original_url_.is_valid());
 }
 
 void URLFetcherCore::Start() {
   DCHECK(delegate_task_runner_);
   DCHECK(request_context_getter_) << "We need an URLRequestContext!";
   if (network_task_runner_) {
     DCHECK_EQ(network_task_runner_,
               request_context_getter_->GetNetworkTaskRunner());
   } else {
     network_task_runner_ = request_context_getter_->GetNetworkTaskRunner();
   }
   DCHECK(network_task_runner_.get()) << "We need an IO task runner";
 
-  network_task_runner_->PostTask(
-      FROM_HERE, base::Bind(&URLFetcherCore::StartOnIOThread, this));
+  if (NetworkChangeNotifier::IsOffline() &&
+      num_retries_on_network_changes_ < max_retries_on_network_changes_) {
+    // We're currently offline and this request will immediately fail. Try to
+    // start later if |max_retries_on_network_changes_| is set, indicating that
+    // our owner wants the fetcher to automatically retry on network changes.
+    num_retries_on_network_changes_++;
+    NetworkChangeNotifier::AddConnectionTypeObserver(this);
+  } else {
+    network_task_runner_->PostTask(
+        FROM_HERE, base::Bind(&URLFetcherCore::StartOnIOThread, this));
+  }
 }
 
 void URLFetcherCore::Stop() {
   if (delegate_task_runner_)  // May be NULL in tests.
     DCHECK(delegate_task_runner_->BelongsToCurrentThread());
 
   delegate_ = NULL;
   fetcher_ = NULL;
   if (!network_task_runner_.get())
     return;
@@ skipping 81 matching lines @@
 }
 
 void URLFetcherCore::SetStopOnRedirect(bool stop_on_redirect) {
   stop_on_redirect_ = stop_on_redirect;
 }
 
 void URLFetcherCore::SetAutomaticallyRetryOn5xx(bool retry) {
   automatically_retry_on_5xx_ = retry;
 }
 
-void URLFetcherCore::SetMaxRetries(int max_retries) {
-  max_retries_ = max_retries;
+void URLFetcherCore::SetMaxRetriesOn5xx(int max_retries) {
+  max_retries_on_5xx_ = max_retries;
 }
 
-int URLFetcherCore::GetMaxRetries() const {
-  return max_retries_;
+int URLFetcherCore::GetMaxRetriesOn5xx() const {
+  return max_retries_on_5xx_;
 }
 
 base::TimeDelta URLFetcherCore::GetBackoffDelay() const {
   return backoff_delay_;
 }
 
+void URLFetcherCore::SetAutomaticallyRetryOnNetworkChanges(int max_retries) {
+  max_retries_on_network_changes_ = max_retries;
+}
+
 void URLFetcherCore::SaveResponseToFileAtPath(
     const FilePath& file_path,
     scoped_refptr<base::TaskRunner> file_task_runner) {
   DCHECK(delegate_task_runner_->BelongsToCurrentThread());
   file_task_runner_ = file_task_runner;
   response_destination_ = URLFetcherCore::PERMANENT_FILE;
   response_destination_file_path_ = file_path;
 }
 
 void URLFetcherCore::SaveResponseToTemporaryFile(
@@ skipping 167 matching lines @@
       // If the file is open, close it.  After closing the file,
       // RetryOrCompleteUrlFetch() will be called.
       file_writer_->CloseFileAndCompleteRequest();
     } else {
       // Otherwise, complete or retry the URL request directly.
       RetryOrCompleteUrlFetch();
     }
   }
 }
 
+void URLFetcherCore::OnConnectionTypeChanged(
+    NetworkChangeNotifier::ConnectionType type) {
+  DCHECK_GT(num_retries_on_network_changes_, 0);
+  if (type == NetworkChangeNotifier::CONNECTION_NONE) {
+    // Keep waiting.
+    return;
+  }
+
+  // Stop observing and try again now.
+  NetworkChangeNotifier::RemoveConnectionTypeObserver(this);
+  network_task_runner_->PostTask(
+      FROM_HERE, base::Bind(&URLFetcherCore::StartOnIOThread, this));
+}
+
 void URLFetcherCore::CancelAll() {
   g_registry.Get().CancelAll();
 }
 
 int URLFetcherCore::GetNumFetcherCores() {
   return g_registry.Get().size();
 }
 
 void URLFetcherCore::SetEnableInterceptionForTests(bool enabled) {
   g_interception_enabled = enabled;
@@ skipping 212 matching lines @@
 
 void URLFetcherCore::RetryOrCompleteUrlFetch() {
   DCHECK(network_task_runner_->BelongsToCurrentThread());
   base::TimeDelta backoff_delay;
 
   // Checks the response from server.
   if (response_code_ >= 500 ||
       status_.error() == ERR_TEMPORARILY_THROTTLED) {
     // When encountering a server error, we will send the request again
     // after backoff time.
-    ++num_retries_;
+    ++num_retries_on_5xx_;
 
     // Note that backoff_delay may be 0 because (a) the
     // URLRequestThrottlerManager and related code does not
     // necessarily back off on the first error, (b) it only backs off
     // on some of the 5xx status codes, (c) not all URLRequestContexts
     // have a throttler manager.
     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_) {
+    if (automatically_retry_on_5xx_ &&
+        num_retries_on_5xx_ <= max_retries_on_5xx_) {
       StartOnIOThread();
       return;
     }
   } else {
     backoff_delay = base::TimeDelta();
   }
+
+  // Retry if the request failed due to network changes.
+  if (status_.error() == ERR_NETWORK_CHANGED &&
+      num_retries_on_network_changes_ < max_retries_on_network_changes_) {
+    num_retries_on_network_changes_++;

[szym, 2012/12/10 18:36:31]

nit: pre-increment

[Joao da Silva, 2012/12/11 13:36:43]

Done.

+
+    if (NetworkChangeNotifier::IsOffline()) {
+      // Retry once we're back online.
+      NetworkChangeNotifier::AddConnectionTypeObserver(this);
+    } else {
+      // Retry soon, after flushing all the current tasks which may include
+      // further network change observers.
+      network_task_runner_->PostTask(
+          FROM_HERE, base::Bind(&URLFetcherCore::StartOnIOThread, this));
+    }
+    return;
+  }
+
   request_context_getter_ = NULL;
   first_party_for_cookies_ = GURL();
   url_request_data_key_ = NULL;
   url_request_create_data_callback_.Reset();
   bool posted = delegate_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&URLFetcherCore::OnCompletedURLRequest, this, backoff_delay));
 
   // If the delegate message loop does not exist any more, then the delegate
   // should be gone too.
   DCHECK(posted || !delegate_);
 }
 
 void URLFetcherCore::ReleaseRequest() {
+  if (num_retries_on_network_changes_ > 0)
+    NetworkChangeNotifier::RemoveConnectionTypeObserver(this);
   upload_progress_checker_timer_.reset();
   request_.reset();
   g_registry.Get().RemoveURLFetcherCore(this);
 }
 
 base::TimeTicks URLFetcherCore::GetBackoffReleaseTime() {
   DCHECK(network_task_runner_->BelongsToCurrentThread());
 
   if (original_url_throttler_entry_) {
     base::TimeTicks original_url_backoff =
@@ skipping 123 matching lines @@
 }
 
 void URLFetcherCore::InformDelegateDownloadDataInDelegateThread(
     scoped_ptr<std::string> download_data) {
   DCHECK(delegate_task_runner_->BelongsToCurrentThread());
   if (delegate_)
     delegate_->OnURLFetchDownloadData(fetcher_, download_data.Pass());
 }
 
 }  // namespace net