Implement SSLClientSocketPool.

net/socket/client_socket_pool_base_unittest.cc

 // Copyright (c) 2010 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 "base/callback.h"
 #include "base/compiler_specific.h"
 #include "base/message_loop.h"
 #include "base/platform_thread.h"
@@ skipping 76 matching lines @@
  public:
   MockClientSocketFactory() : allocation_count_(0) {}
 
   virtual ClientSocket* CreateTCPClientSocket(const AddressList& addresses,
                                               NetLog* /* net_log */) {
     allocation_count_++;
     return NULL;
   }
 
   virtual SSLClientSocket* CreateSSLClientSocket(
-      ClientSocket* transport_socket,
+      ClientSocketHandle* transport_socket,
       const std::string& hostname,
       const SSLConfig& ssl_config) {
     NOTIMPLEMENTED();
     return NULL;
   }
 
   void WaitForSignal(TestConnectJob* job) { waiting_jobs_.push_back(job); }
   void SignalJobs();
 
   int allocation_count() const { return allocation_count_; }
 
  private:
   int allocation_count_;
   std::vector<TestConnectJob*> waiting_jobs_;
 };
 
 class TestConnectJob : public ConnectJob {
  public:
   enum JobType {
     kMockJob,
     kMockFailingJob,
     kMockPendingJob,
     kMockPendingFailingJob,
     kMockWaitingJob,
     kMockAdvancingLoadStateJob,
     kMockRecoverableJob,
     kMockPendingRecoverableJob,
+    kMockAdditionalErrorStateJob,
+    kMockPendingAdditionalErrorStateJob,
   };
 
   TestConnectJob(JobType job_type,
                  const std::string& group_name,
                  const TestClientSocketPoolBase::Request& request,
                  base::TimeDelta timeout_duration,
                  ConnectJob::Delegate* delegate,
                  MockClientSocketFactory* client_socket_factory,
                  NetLog* net_log)
       : ConnectJob(group_name, timeout_duration, delegate,
                    BoundNetLog::Make(net_log, NetLog::SOURCE_CONNECT_JOB)),
         job_type_(job_type),
         client_socket_factory_(client_socket_factory),
         method_factory_(ALLOW_THIS_IN_INITIALIZER_LIST(this)),
-        load_state_(LOAD_STATE_IDLE) {}
+        load_state_(LOAD_STATE_IDLE),
+        store_additional_error_state_(false) {}
 
   void Signal() {
     DoConnect(waiting_success_, true /* async */, false /* recoverable */);
   }
 
   virtual LoadState GetLoadState() const { return load_state_; }
 
+  virtual void GetAdditionalErrorState(ClientSocketHandle* handle) {
+    if (store_additional_error_state_) {
+      // Set all of the additional error state fields in some way.
+      handle->set_is_ssl_error(true);
+      scoped_refptr<HttpResponseHeaders> headers(new HttpResponseHeaders(""));
+      handle->set_tunnel_auth_response_info(headers, NULL);
+    }
+  }
+
  private:
   // ConnectJob methods:
 
   virtual int ConnectInternal() {
     AddressList ignored;
     client_socket_factory_->CreateTCPClientSocket(ignored, NULL);
     set_socket(new MockClientSocket());
     switch (job_type_) {
       case kMockJob:
         return DoConnect(true /* successful */, false /* sync */,
@@ skipping 52 matching lines @@
         set_load_state(LOAD_STATE_CONNECTING);
         MessageLoop::current()->PostDelayedTask(
             FROM_HERE,
             method_factory_.NewRunnableMethod(
                 &TestConnectJob::DoConnect,
                 false /* error */,
                 true  /* async */,
                 true  /* recoverable */),
             2);
         return ERR_IO_PENDING;
+      case kMockAdditionalErrorStateJob:
+        store_additional_error_state_ = true;
+        return DoConnect(false /* error */, false /* sync */,
+                         false /* recoverable */);
+      case kMockPendingAdditionalErrorStateJob:
+        set_load_state(LOAD_STATE_CONNECTING);
+        store_additional_error_state_ = true;
+        MessageLoop::current()->PostDelayedTask(
+            FROM_HERE,
+            method_factory_.NewRunnableMethod(
+                &TestConnectJob::DoConnect,
+                false /* error */,
+                true  /* async */,
+                false /* recoverable */),
+            2);
+        return ERR_IO_PENDING;
       default:
         NOTREACHED();
         set_socket(NULL);
         return ERR_FAILED;
     }
   }
 
   void set_load_state(LoadState load_state) { load_state_ = load_state; }
 
   int DoConnect(bool succeed, bool was_async, bool recoverable) {
@@ skipping 27 matching lines @@
           method_factory_.NewRunnableMethod(&TestConnectJob::AdvanceLoadState,
                                             state));
     }
   }
 
   bool waiting_success_;
   const JobType job_type_;
   MockClientSocketFactory* const client_socket_factory_;
   ScopedRunnableMethodFactory<TestConnectJob> method_factory_;
   LoadState load_state_;
+  bool store_additional_error_state_;
 
   DISALLOW_COPY_AND_ASSIGN(TestConnectJob);
 };
 
 class TestConnectJobFactory
     : public TestClientSocketPoolBase::ConnectJobFactory {
  public:
   explicit TestConnectJobFactory(MockClientSocketFactory* client_socket_factory)
       : job_type_(TestConnectJob::kMockJob),
         client_socket_factory_(client_socket_factory) {}
@@ skipping 306 matching lines @@
       log.entries(), 3, NetLog::TYPE_SOCKET_POOL));
 }
 
 TEST_F(ClientSocketPoolBaseTest, InitConnectionFailure) {
   CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup);
 
   connect_job_factory_->set_job_type(TestConnectJob::kMockFailingJob);
   CapturingBoundNetLog log(CapturingNetLog::kUnbounded);
 
   TestSocketRequest req(&request_order_, &completion_count_);
+  // Set the additional error state members to ensure that they get cleared.
+  req.handle()->set_is_ssl_error(true);
+  scoped_refptr<HttpResponseHeaders> headers(new HttpResponseHeaders(""));
+  req.handle()->set_tunnel_auth_response_info(headers, NULL);
   EXPECT_EQ(ERR_CONNECTION_FAILED, req.handle()->Init("a", params_,
                                                       kDefaultPriority, &req,
                                                       pool_, log.bound()));
   EXPECT_FALSE(req.handle()->socket());
+  EXPECT_FALSE(req.handle()->is_ssl_error());
+  EXPECT_TRUE(req.handle()->tunnel_auth_response_info().headers.get() == NULL);
 
   EXPECT_EQ(3u, log.entries().size());
   EXPECT_TRUE(LogContainsBeginEvent(
       log.entries(), 0, NetLog::TYPE_SOCKET_POOL));
   EXPECT_TRUE(LogContainsEvent(
       log.entries(), 1, NetLog::TYPE_SOCKET_POOL_BOUND_TO_CONNECT_JOB,
       NetLog::PHASE_NONE));
   EXPECT_TRUE(LogContainsEndEvent(
       log.entries(), 2, NetLog::TYPE_SOCKET_POOL));
 }
@@ skipping 732 matching lines @@
       log.entries(), 3, NetLog::TYPE_SOCKET_POOL));
 }
 
 TEST_F(ClientSocketPoolBaseTest,
        InitConnectionAsynchronousFailure) {
   CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup);
 
   connect_job_factory_->set_job_type(TestConnectJob::kMockPendingFailingJob);
   TestSocketRequest req(&request_order_, &completion_count_);
   CapturingBoundNetLog log(CapturingNetLog::kUnbounded);
+  // Set the additional error state members to ensure that they get cleared.
+  req.handle()->set_is_ssl_error(true);
+  scoped_refptr<HttpResponseHeaders> headers(new HttpResponseHeaders(""));
+  req.handle()->set_tunnel_auth_response_info(headers, NULL);
   EXPECT_EQ(ERR_IO_PENDING, req.handle()->Init("a", params_, kDefaultPriority,
                                                &req, pool_, log.bound()));
   EXPECT_EQ(LOAD_STATE_CONNECTING, pool_->GetLoadState("a", req.handle()));
   EXPECT_EQ(ERR_CONNECTION_FAILED, req.WaitForResult());
+  EXPECT_FALSE(req.handle()->is_ssl_error());
+  EXPECT_TRUE(req.handle()->tunnel_auth_response_info().headers.get() == NULL);
 
   EXPECT_EQ(3u, log.entries().size());
   EXPECT_TRUE(LogContainsBeginEvent(
       log.entries(), 0, NetLog::TYPE_SOCKET_POOL));
   EXPECT_TRUE(LogContainsEvent(
       log.entries(), 1, NetLog::TYPE_SOCKET_POOL_BOUND_TO_CONNECT_JOB,
       NetLog::PHASE_NONE));
   EXPECT_TRUE(LogContainsEndEvent(
       log.entries(), 2, NetLog::TYPE_SOCKET_POOL));
 }
@@ skipping 172 matching lines @@
   TestSocketRequest req(&request_order_, &completion_count_);
   EXPECT_EQ(ERR_IO_PENDING, req.handle()->Init("a", params_, kDefaultPriority,
                                                &req, pool_, BoundNetLog()));
   EXPECT_EQ(LOAD_STATE_CONNECTING, pool_->GetLoadState("a", req.handle()));
   EXPECT_EQ(ERR_PROXY_AUTH_REQUESTED, req.WaitForResult());
   EXPECT_TRUE(req.handle()->is_initialized());
   EXPECT_TRUE(req.handle()->socket());
   req.handle()->Reset();
 }
 
+TEST_F(ClientSocketPoolBaseTest, AdditionalErrorStateSynchronous) {
+  CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup);
+  connect_job_factory_->set_job_type(
+      TestConnectJob::kMockAdditionalErrorStateJob);
+
+  TestSocketRequest req(&request_order_, &completion_count_);
+  EXPECT_EQ(ERR_CONNECTION_FAILED, req.handle()->Init("a", params_,
+                                                      kDefaultPriority, &req,
+                                                      pool_, BoundNetLog()));
+  EXPECT_FALSE(req.handle()->is_initialized());
+  EXPECT_FALSE(req.handle()->socket());
+  EXPECT_TRUE(req.handle()->is_ssl_error());
+  EXPECT_FALSE(req.handle()->tunnel_auth_response_info().headers.get() == NULL);
+  req.handle()->Reset();
+}
+
+TEST_F(ClientSocketPoolBaseTest, AdditionalErrorStateAsynchronous) {
+  CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup);
+
+  connect_job_factory_->set_job_type(
+      TestConnectJob::kMockPendingAdditionalErrorStateJob);
+  TestSocketRequest req(&request_order_, &completion_count_);
+  EXPECT_EQ(ERR_IO_PENDING, req.handle()->Init("a", params_, kDefaultPriority,
+                                               &req, pool_, BoundNetLog()));
+  EXPECT_EQ(LOAD_STATE_CONNECTING, pool_->GetLoadState("a", req.handle()));
+  EXPECT_EQ(ERR_CONNECTION_FAILED, req.WaitForResult());
+  EXPECT_FALSE(req.handle()->is_initialized());
+  EXPECT_FALSE(req.handle()->socket());
+  EXPECT_TRUE(req.handle()->is_ssl_error());
+  EXPECT_FALSE(req.handle()->tunnel_auth_response_info().headers.get() == NULL);
+  req.handle()->Reset();
+}
+
 TEST_F(ClientSocketPoolBaseTest, CleanupTimedOutIdleSockets) {
   CreatePoolWithIdleTimeouts(
       kDefaultMaxSockets, kDefaultMaxSocketsPerGroup,
       base::TimeDelta(),  // Time out unused sockets immediately.
       base::TimeDelta::FromDays(1));  // Don't time out used sockets.
 
   connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob);
 
   // Startup two mock pending connect jobs, which will sit in the MessageLoop.
 
@@ skipping 167 matching lines @@
   EXPECT_EQ(2, GetOrderOfRequest(2));
   EXPECT_EQ(3, GetOrderOfRequest(3));
   EXPECT_EQ(4, GetOrderOfRequest(4));
 
   // Make sure we test order of all requests made.
   EXPECT_EQ(kIndexOutOfBounds, GetOrderOfRequest(5));
 }
 
 class TestReleasingSocketRequest : public CallbackRunner< Tuple1<int> > {
  public:
-  explicit TestReleasingSocketRequest(TestClientSocketPool* pool)
-      : pool_(pool) {}
+  TestReleasingSocketRequest(TestClientSocketPool* pool, int expected_result,
+                             bool reset_releasing_handle)
+      : pool_(pool),
+        expected_result_(expected_result),
+        reset_releasing_handle_(reset_releasing_handle) {}
 
   ClientSocketHandle* handle() { return &handle_; }
 
   int WaitForResult() {
     return callback_.WaitForResult();
   }
 
   virtual void RunWithParams(const Tuple1<int>& params) {
     callback_.RunWithParams(params);
-    handle_.Reset();
+    if (reset_releasing_handle_)
+                      handle_.Reset();
     scoped_refptr<TestSocketParams> con_params = new TestSocketParams();
-    EXPECT_EQ(ERR_IO_PENDING, handle2_.Init("a", con_params, kDefaultPriority,
-                                            &callback2_, pool_, BoundNetLog()));
+    EXPECT_EQ(expected_result_, handle2_.Init("a", con_params, kDefaultPriority,
+                                              &callback2_, pool_,
+                                              BoundNetLog()));
   }
 
  private:
   scoped_refptr<TestClientSocketPool> pool_;
+  int expected_result_;
+  bool reset_releasing_handle_;
   ClientSocketHandle handle_;
   ClientSocketHandle handle2_;
   TestCompletionCallback callback_;
   TestCompletionCallback callback2_;
 };
 
+
+TEST_F(ClientSocketPoolBaseTest, AdditionalErrorSocketsDontUseSlot) {
+  CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup);
+
+  EXPECT_EQ(OK, StartRequest("b", kDefaultPriority));
+  EXPECT_EQ(OK, StartRequest("a", kDefaultPriority));
+  EXPECT_EQ(OK, StartRequest("b", kDefaultPriority));
+
+  EXPECT_EQ(static_cast<int>(requests_.size()),
+            client_socket_factory_.allocation_count());
+
+  connect_job_factory_->set_job_type(
+      TestConnectJob::kMockPendingAdditionalErrorStateJob);
+  TestReleasingSocketRequest req(pool_.get(), OK, false);
+  EXPECT_EQ(ERR_IO_PENDING, req.handle()->Init("a", params_, kDefaultPriority,
+                                               &req, pool_, BoundNetLog()));
+  // The next job should complete synchronously
+  connect_job_factory_->set_job_type(TestConnectJob::kMockJob);
+
+  EXPECT_EQ(ERR_CONNECTION_FAILED, req.WaitForResult());
+  EXPECT_FALSE(req.handle()->is_initialized());
+  EXPECT_FALSE(req.handle()->socket());
+  EXPECT_TRUE(req.handle()->is_ssl_error());
+  EXPECT_FALSE(req.handle()->tunnel_auth_response_info().headers.get() == NULL);
+}
+
 // http://crbug.com/44724 regression test.
 // We start releasing the pool when we flush on network change.  When that
 // happens, the only active references are in the ClientSocketHandles.  When a
 // ConnectJob completes and calls back into the last ClientSocketHandle, that
 // callback can release the last reference and delete the pool.  After the
 // callback finishes, we go back to the stack frame within the now-deleted pool.
 // Executing any code that refers to members of the now-deleted pool can cause
 // crashes.
 TEST_F(ClientSocketPoolBaseTest, CallbackThatReleasesPool) {
   CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup);
@@ skipping 213 matching lines @@
   // Finally, signal the waiting Connect.
   client_socket_factory_.SignalJobs();
   EXPECT_EQ(0, pool_->NumConnectJobsInGroup("a"));
 
   MessageLoop::current()->RunAllPending();
 }
 
 }  // namespace
 
 }  // namespace net