Fix crash in ClientSocketPoolBase.

net/socket/tcp_client_socket_pool_unittest.cc

 // Copyright (c) 2006-2008 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/tcp_client_socket_pool.h"
 
 #include "base/compiler_specific.h"
 #include "base/message_loop.h"
 #include "net/base/host_resolver_unittest.h"
 #include "net/base/net_errors.h"
@@ skipping 77 matching lines @@
   }
 
   virtual int Write(IOBuffer* buf, int buf_len,
                     CompletionCallback* callback) {
     return ERR_FAILED;
   }
 };
 
 class MockPendingClientSocket : public ClientSocket {
  public:
-  MockPendingClientSocket()
-      : method_factory_(ALLOW_THIS_IN_INITIALIZER_LIST(this)) {}
+  MockPendingClientSocket(bool should_connect)
+      : method_factory_(ALLOW_THIS_IN_INITIALIZER_LIST(this)),
+        should_connect_(should_connect),
+        is_connected_(false) {}
 
   // ClientSocket methods:
   virtual int Connect(CompletionCallback* callback) {
     MessageLoop::current()->PostTask(
         FROM_HERE,
         method_factory_.NewRunnableMethod(
            &MockPendingClientSocket::DoCallback, callback));
     return ERR_IO_PENDING;
   }
 
   virtual void Disconnect() {}
 
   virtual bool IsConnected() const {
-    return false;
+    return is_connected_;
   }
   virtual bool IsConnectedAndIdle() const {
-    return false;
+    return is_connected_;
   }
 
   // Socket methods:
   virtual int Read(IOBuffer* buf, int buf_len,
                    CompletionCallback* callback) {
     return ERR_FAILED;
   }
 
   virtual int Write(IOBuffer* buf, int buf_len,
                     CompletionCallback* callback) {
     return ERR_FAILED;
   }
 
  private:
   void DoCallback(CompletionCallback* callback) {
-    callback->Run(OK);
+    if (should_connect_) {
+      is_connected_ = true;
+      callback->Run(OK);
+    } else {
+      is_connected_ = false;
+      callback->Run(ERR_CONNECTION_FAILED);
+    }
   }
 
   ScopedRunnableMethodFactory<MockPendingClientSocket> method_factory_;
+  bool should_connect_;
+  bool is_connected_;
 };
 
 class MockClientSocketFactory : public ClientSocketFactory {
  public:
   enum ClientSocketType {
     MOCK_CLIENT_SOCKET,
     MOCK_FAILING_CLIENT_SOCKET,
     MOCK_PENDING_CLIENT_SOCKET,
+    MOCK_PENDING_FAILING_CLIENT_SOCKET,
   };
 
   MockClientSocketFactory()
       : allocation_count_(0), client_socket_type_(MOCK_CLIENT_SOCKET) {}
 
   virtual ClientSocket* CreateTCPClientSocket(const AddressList& addresses) {
     allocation_count_++;
     switch (client_socket_type_) {
       case MOCK_CLIENT_SOCKET:
         return new MockClientSocket();
       case MOCK_FAILING_CLIENT_SOCKET:
         return new MockFailingClientSocket();
       case MOCK_PENDING_CLIENT_SOCKET:
-        return new MockPendingClientSocket();
+        return new MockPendingClientSocket(true);
+      case MOCK_PENDING_FAILING_CLIENT_SOCKET:
+        return new MockPendingClientSocket(false);
       default:
         NOTREACHED();
         return new MockClientSocket();
     }
   }
 
   virtual SSLClientSocket* CreateSSLClientSocket(
       ClientSocket* transport_socket,
       const std::string& hostname,
       const SSLConfig& ssl_config) {
@@ skipping 408 matching lines @@
   // Let's wait for the rest to complete now.
 
   for (size_t i = kMaxSocketsPerGroup; i < arraysize(reqs); ++i) {
     EXPECT_EQ(OK, reqs[i]->WaitForResult());
     reqs[i]->handle.Reset();
   }
 
   EXPECT_EQ(kNumPendingRequests, TestSocketRequest::completion_count);
 }
 
+// Make sure that pending requests get serviced after active requests fail.
+TEST_F(TCPClientSocketPoolTest, FailingActiveRequestWithPendingRequests) {
+  client_socket_factory_.set_client_socket_type(
+      MockClientSocketFactory::MOCK_PENDING_FAILING_CLIENT_SOCKET);
+
+  scoped_ptr<TestSocketRequest> reqs[kMaxSocketsPerGroup * 2 + 1];
+
+  // Queue up all the requests
+
+  HostResolver::RequestInfo info("www.google.com", 80);
+  for (size_t i = 0; i < arraysize(reqs); ++i) {
+    reqs[i].reset(new TestSocketRequest(pool_.get(), &request_order_));
+    int rv = reqs[i]->handle.Init("a", info, 5, reqs[i].get());
+    EXPECT_EQ(ERR_IO_PENDING, rv);
+  }
+
+  for (size_t i = 0; i < arraysize(reqs); ++i)
+    EXPECT_EQ(ERR_CONNECTION_FAILED, reqs[i]->WaitForResult());
+}
+
 }  // namespace
 
 }  // namespace net