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

net/socket/client_socket_pool_base.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/socket/client_socket_pool_base.h"
 
 #include <math.h>
 #include "base/compiler_specific.h"
 #include "base/format_macros.h"
 #include "base/logging.h"
@@ skipping 171 matching lines @@
   DCHECK_LE(0, max_sockets_per_group);
   DCHECK_LE(max_sockets_per_group, max_sockets);
 
   NetworkChangeNotifier::AddIPAddressObserver(this);
 }
 
 ClientSocketPoolBaseHelper::~ClientSocketPoolBaseHelper() {
   // Clean up any idle sockets and pending connect jobs.  Assert that we have no
   // remaining active sockets or pending requests.  They should have all been
   // cleaned up prior to |this| being destroyed.
-  Flush();
+  FlushWithError(ERR_ABORTED);
   DCHECK(group_map_.empty());
   DCHECK(pending_callback_map_.empty());
   DCHECK_EQ(0, connecting_socket_count_);
   CHECK(higher_layer_pools_.empty());
 
   NetworkChangeNotifier::RemoveIPAddressObserver(this);
 }
 
 ClientSocketPoolBaseHelper::CallbackResultPair::CallbackResultPair()
     : result(OK) {
@@ skipping 693 matching lines @@
       RemoveConnectJob(job, group);
     }
     if (!handed_out_socket) {
       OnAvailableSocketSlot(group_name, group);
       CheckForStalledSocketGroups();
     }
   }
 }
 
 void ClientSocketPoolBaseHelper::OnIPAddressChanged() {
-  Flush();
+  FlushWithError(ERR_NETWORK_CHANGED);
 }
 
-void ClientSocketPoolBaseHelper::Flush() {
+void ClientSocketPoolBaseHelper::FlushWithError(int error) {
   pool_generation_number_++;
   CancelAllConnectJobs();
   CloseIdleSockets();
-  AbortAllRequests();
+  CancelAllRequestsWithError(error);
 }
 
 bool ClientSocketPoolBaseHelper::IsStalled() const {
   // If we are not using |max_sockets_|, then clearly we are not stalled
   if ((handed_out_socket_count_ + connecting_socket_count_) < max_sockets_)
     return false;
   // So in order to be stalled we need to be using |max_sockets_| AND
   // we need to have a request that is actually stalled on the global
   // socket limit.  To find such a request, we look for a group that
   // a has more requests that jobs AND where the number of jobs is less
@@ skipping 100 matching lines @@
       // but i will already have been incremented to a valid iterator before
       // RemoveGroup() is called.
       RemoveGroup(i++);
     } else {
       ++i;
     }
   }
   DCHECK_EQ(0, connecting_socket_count_);
 }
 
-void ClientSocketPoolBaseHelper::AbortAllRequests() {
+void ClientSocketPoolBaseHelper::CancelAllRequestsWithError(int error) {
   for (GroupMap::iterator i = group_map_.begin(); i != group_map_.end();) {
     Group* group = i->second;
 
     RequestQueue pending_requests;
     pending_requests.swap(*group->mutable_pending_requests());
     for (RequestQueue::iterator it2 = pending_requests.begin();
          it2 != pending_requests.end(); ++it2) {
       scoped_ptr<const Request> request(*it2);
       InvokeUserCallbackLater(
-          request->handle(), request->callback(), ERR_ABORTED);
+          request->handle(), request->callback(), error);
     }
 
     // Delete group if no longer needed.
     if (group->IsEmpty()) {
       // RemoveGroup() will call .erase() which will invalidate the iterator,
       // but i will already have been incremented to a valid iterator before
       // RemoveGroup() is called.
       RemoveGroup(i++);
     } else {
       ++i;
@@ skipping 174 matching lines @@
   STLDeleteElements(&jobs_);
   unassigned_job_count_ = 0;
 
   // Cancel pending backup job.
   weak_factory_.InvalidateWeakPtrs();
 }
 
 }  // namespace internal
 
 }  // namespace net