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

net/base/host_resolver_impl_unittest.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/host_resolver_impl.h"
 
 #include <algorithm>
 #include <string>
 
 #include "base/bind.h"
@@ skipping 717 matching lines @@
   EXPECT_EQ(ERR_IO_PENDING, CreateRequest("b", 83)->Resolve());
 
   EXPECT_TRUE(proc_->WaitFor(1u));
 
   // Triggering an IP address change.
   NetworkChangeNotifier::NotifyObserversOfIPAddressChangeForTests();
 
   // |MyHandler| will send quit message once all the requests have finished.
   MessageLoop::current()->Run();
 
-  EXPECT_EQ(ERR_ABORTED, requests_[0]->result());
+  EXPECT_EQ(ERR_NETWORK_CHANGED, requests_[0]->result());
   EXPECT_EQ(ERR_IO_PENDING, requests_[1]->result());
   EXPECT_EQ(ERR_IO_PENDING, requests_[2]->result());
   EXPECT_EQ(ERR_IO_PENDING, requests_[3]->result());
   // Clean up.
   proc_->SignalMultiple(requests_.size());
 }
 
 TEST_F(HostResolverImplTest, StartWithinCallback) {
   struct MyHandler : public Handler {
     virtual void Handle(Request* req) OVERRIDE {
@@ skipping 74 matching lines @@
   NetworkChangeNotifier::NotifyObserversOfIPAddressChangeForTests();
   MessageLoop::current()->RunUntilIdle();  // Notification happens async.
 
   // Resolve "host1" again -- this time it won't be served from cache, so it
   // will complete asynchronously.
   req = CreateRequest("host1", 80);
   EXPECT_EQ(ERR_IO_PENDING, req->Resolve());
   EXPECT_EQ(OK, req->WaitForResult());
 }
 
-// Test that IP address changes send ERR_ABORTED to pending requests.
+// Test that IP address changes send ERR_NETWORK_CHANGED to pending requests.
 TEST_F(HostResolverImplTest, AbortOnIPAddressChanged) {
   Request* req = CreateRequest("host1", 70);
   EXPECT_EQ(ERR_IO_PENDING, req->Resolve());
 
   EXPECT_TRUE(proc_->WaitFor(1u));
   // Triggering an IP address change.
   NetworkChangeNotifier::NotifyObserversOfIPAddressChangeForTests();
   MessageLoop::current()->RunUntilIdle();  // Notification happens async.
   proc_->SignalAll();
 
-  EXPECT_EQ(ERR_ABORTED, req->WaitForResult());
+  EXPECT_EQ(ERR_NETWORK_CHANGED, req->WaitForResult());
   EXPECT_EQ(0u, resolver_->GetHostCache()->size());
 }
 
 // Obey pool constraints after IP address has changed.
 TEST_F(HostResolverImplTest, ObeyPoolConstraintsAfterIPAddressChange) {
   // Runs at most one job at a time.
   CreateSerialResolver();
   EXPECT_EQ(ERR_IO_PENDING, CreateRequest("a")->Resolve());
   EXPECT_EQ(ERR_IO_PENDING, CreateRequest("b")->Resolve());
   EXPECT_EQ(ERR_IO_PENDING, CreateRequest("c")->Resolve());
 
   EXPECT_TRUE(proc_->WaitFor(1u));
   // Triggering an IP address change.
   NetworkChangeNotifier::NotifyObserversOfIPAddressChangeForTests();
   MessageLoop::current()->RunUntilIdle();  // Notification happens async.
   proc_->SignalMultiple(3u);  // Let the false-start go so that we can catch it.
 
-  EXPECT_EQ(ERR_ABORTED, requests_[0]->WaitForResult());
+  EXPECT_EQ(ERR_NETWORK_CHANGED, requests_[0]->WaitForResult());
 
   EXPECT_EQ(1u, num_running_jobs());
 
   EXPECT_FALSE(requests_[1]->completed());
   EXPECT_FALSE(requests_[2]->completed());
 
   EXPECT_EQ(OK, requests_[2]->WaitForResult());
   EXPECT_EQ(OK, requests_[1]->result());
 }
 
@@ skipping 21 matching lines @@
   EXPECT_EQ(ERR_IO_PENDING, CreateRequest("bbb")->Resolve());
   EXPECT_EQ(ERR_IO_PENDING, CreateRequest("eee")->Resolve());
   EXPECT_EQ(ERR_IO_PENDING, CreateRequest("ccc")->Resolve());
 
   // Wait until all are blocked;
   EXPECT_TRUE(proc_->WaitFor(3u));
   // Trigger an IP address change.
   NetworkChangeNotifier::NotifyObserversOfIPAddressChangeForTests();
   // This should abort all running jobs.
   MessageLoop::current()->RunUntilIdle();
-  EXPECT_EQ(ERR_ABORTED, requests_[0]->result());
-  EXPECT_EQ(ERR_ABORTED, requests_[1]->result());
-  EXPECT_EQ(ERR_ABORTED, requests_[2]->result());
+  EXPECT_EQ(ERR_NETWORK_CHANGED, requests_[0]->result());
+  EXPECT_EQ(ERR_NETWORK_CHANGED, requests_[1]->result());
+  EXPECT_EQ(ERR_NETWORK_CHANGED, requests_[2]->result());
   ASSERT_EQ(6u, requests_.size());
   // Unblock all calls to proc.
   proc_->SignalMultiple(requests_.size());
   // Run until the re-started requests finish.
   EXPECT_EQ(OK, requests_[3]->WaitForResult());
   EXPECT_EQ(OK, requests_[4]->WaitForResult());
   EXPECT_EQ(OK, requests_[5]->WaitForResult());
   // Verify that results of aborted Jobs were not cached.
   EXPECT_EQ(6u, proc_->GetCaptureList().size());
   EXPECT_EQ(3u, resolver_->GetHostCache()->size());
@@ skipping 555 matching lines @@
   // Make |proc_| default to failures.
   proc_->AddRuleForAllFamilies("", "");
 
   // DnsTask should still be enabled.
   Request* req = CreateRequest("ok_last", 80);
   EXPECT_EQ(ERR_IO_PENDING, req->Resolve());
   EXPECT_EQ(OK, req->WaitForResult());
 }
 
 }  // namespace net