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

net/socket/client_socket_pool_base_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/socket/client_socket_pool_base.h"
 
 #include <vector>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
@@ skipping 458 matching lines @@
     base_.CancelRequest(group_name, handle);
   }
 
   virtual void ReleaseSocket(
       const std::string& group_name,
       StreamSocket* socket,
       int id) OVERRIDE {
     base_.ReleaseSocket(group_name, socket, id);
   }
 
-  virtual void Flush() OVERRIDE {
-    base_.Flush();
+  virtual void FlushWithError(int error) OVERRIDE {
+    base_.FlushWithError(error);
   }
 
   virtual bool IsStalled() const OVERRIDE {
     return base_.IsStalled();
   }
 
   virtual void CloseIdleSockets() OVERRIDE {
     base_.CloseIdleSockets();
   }
 
@@ skipping 1988 matching lines @@
 
   ClientSocketHandle handle;
   TestCompletionCallback callback;
   EXPECT_EQ(ERR_IO_PENDING, handle.Init("a",
                                         params_,
                                         kDefaultPriority,
                                         callback.callback(),
                                         pool_.get(),
                                         BoundNetLog()));
 
-  pool_->Flush();
+  pool_->FlushWithError(ERR_NETWORK_CHANGED);
 
   // We'll call back into this now.
   callback.WaitForResult();
 }
 
 TEST_F(ClientSocketPoolBaseTest, DoNotReuseSocketAfterFlush) {
   CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup);
   connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob);
 
   ClientSocketHandle handle;
   TestCompletionCallback callback;
   EXPECT_EQ(ERR_IO_PENDING, handle.Init("a",
                                         params_,
                                         kDefaultPriority,
                                         callback.callback(),
                                         pool_.get(),
                                         BoundNetLog()));
   EXPECT_EQ(OK, callback.WaitForResult());
   EXPECT_EQ(ClientSocketHandle::UNUSED, handle.reuse_type());
 
-  pool_->Flush();
+  pool_->FlushWithError(ERR_NETWORK_CHANGED);
 
   handle.Reset();
   MessageLoop::current()->RunUntilIdle();
 
   EXPECT_EQ(ERR_IO_PENDING, handle.Init("a",
                                         params_,
                                         kDefaultPriority,
                                         callback.callback(),
                                         pool_.get(),
                                         BoundNetLog()));
@@ skipping 56 matching lines @@
   EXPECT_EQ(ERR_IO_PENDING, handle.Init("a",
                                         params_,
                                         kDefaultPriority,
                                         callback.callback(),
                                         pool_.get(),
                                         BoundNetLog()));
 
   // Second job will be started during the first callback, and will
   // asynchronously complete with OK.
   connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob);
-  pool_->Flush();
-  EXPECT_EQ(ERR_ABORTED, callback.WaitForResult());
+  pool_->FlushWithError(ERR_NETWORK_CHANGED);
+  EXPECT_EQ(ERR_NETWORK_CHANGED, callback.WaitForResult());
   EXPECT_EQ(OK, callback.WaitForNestedResult());
 }
 
 // Cancel a pending socket request while we're at max sockets,
 // and verify that the backup socket firing doesn't cause a crash.
 TEST_F(ClientSocketPoolBaseTest, BackupSocketCancelAtMaxSockets) {
   // Max 4 sockets globally, max 4 sockets per group.
   CreatePool(kDefaultMaxSockets, kDefaultMaxSockets);
   pool_->EnableConnectBackupJobs();
 
@@ skipping 925 matching lines @@
   // complete.
   EXPECT_EQ(1, pool_->NumConnectJobsInGroup("a"));
   EXPECT_EQ(0, pool_->NumUnassignedConnectJobsInGroup("a"));
   EXPECT_EQ(0, pool_->IdleSocketCountInGroup("a"));
   EXPECT_EQ(1, pool_->NumActiveSocketsInGroup("a"));
 }
 
 }  // namespace
 
 }  // namespace net