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

net/base/mock_host_resolver.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/base/mock_host_resolver.h"
 
 #include <string>
 #include <vector>
 
 #include "base/bind.h"
@@ skipping 66 matching lines @@
     return rv;
   }
   if (synchronous_mode_) {
     return ResolveProc(id, info, addresses);
   }
   // Store the request for asynchronous resolution
   Request* req = new Request(info, addresses, callback);
   requests_[id] = req;
   if (handle)
     *handle = reinterpret_cast<RequestHandle>(id);
-  MessageLoop::current()->PostTask(FROM_HERE,
-                                   base::Bind(&MockHostResolverBase::ResolveNow,
-                                              AsWeakPtr(),
-                                              id));
+
+  if (!ondemand_mode_) {
+    MessageLoop::current()->PostTask(
+        FROM_HERE,
+        base::Bind(&MockHostResolverBase::ResolveNow, AsWeakPtr(), id));
+  }
+
   return ERR_IO_PENDING;
 }
 
 int MockHostResolverBase::ResolveFromCache(const RequestInfo& info,
                                            AddressList* addresses,
                                            const BoundNetLog& net_log) {
   DCHECK(CalledOnValidThread());
   next_request_id_++;
   int rv = ResolveFromIPLiteralOrCache(info, addresses);
   return rv;
 }
 
 void MockHostResolverBase::CancelRequest(RequestHandle handle) {
   DCHECK(CalledOnValidThread());
   size_t id = reinterpret_cast<size_t>(handle);
   RequestMap::iterator it = requests_.find(id);
   if (it != requests_.end()) {
     scoped_ptr<Request> req(it->second);
     requests_.erase(it);
   } else {
     NOTREACHED() << "CancelRequest must NOT be called after request is "
         "complete or canceled.";
   }
 }
 
 HostCache* MockHostResolverBase::GetHostCache() {
   return cache_.get();
 }
 
+void MockHostResolverBase::ResolveAllPending() {
+  DCHECK(CalledOnValidThread());
+  DCHECK(ondemand_mode_);
+  for (RequestMap::iterator i = requests_.begin(); i != requests_.end(); ++i) {
+    MessageLoop::current()->PostTask(
+        FROM_HERE,
+        base::Bind(&MockHostResolverBase::ResolveNow, AsWeakPtr(), i->first));
+  }
+}
+
 // start id from 1 to distinguish from NULL RequestHandle
 MockHostResolverBase::MockHostResolverBase(bool use_caching)
-    : synchronous_mode_(false), next_request_id_(1) {
+    : synchronous_mode_(false),
+      ondemand_mode_(false),
+      next_request_id_(1) {
   rules_ = CreateCatchAllHostResolverProc();
 
   if (use_caching) {
     cache_.reset(new HostCache(kMaxCacheEntries));
   }
 }
 
 int MockHostResolverBase::ResolveFromIPLiteralOrCache(const RequestInfo& info,
                                                       AddressList* addresses) {
   IPAddressNumber ip;
@@ skipping 252 matching lines @@
   CHECK_EQ(old_proc, current_proc_);
 }
 
 void ScopedDefaultHostResolverProc::Init(HostResolverProc* proc) {
   current_proc_ = proc;
   previous_proc_ = HostResolverProc::SetDefault(current_proc_);
   current_proc_->SetLastProc(previous_proc_);
 }
 
 }  // namespace net