Implement SSLClientSocketPool.

net/http/http_network_transaction_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/http/http_network_transaction.h"
 
 #include <math.h>  // ceil
 #include <vector>
 
 #include "base/basictypes.h"
@@ skipping 41 matching lines @@
       const scoped_refptr<HttpNetworkSession>& session)
       : session_(session) {}
 
   void SetTCPSocketPool(const scoped_refptr<TCPClientSocketPool>& pool) {
     session_->tcp_socket_pool_ = pool;
   }
 
   void SetSocketPoolForSOCKSProxy(
       const HostPortPair& socks_proxy,
       const scoped_refptr<SOCKSClientSocketPool>& pool) {
-    session_->socks_socket_pool_[socks_proxy] = pool;
+    session_->socks_socket_pools_[socks_proxy] = pool;
   }
 
   void SetSocketPoolForHTTPProxy(
       const HostPortPair& http_proxy,
       const scoped_refptr<HttpProxyClientSocketPool>& pool) {
-    session_->http_proxy_socket_pool_[http_proxy] = pool;
+    session_->http_proxy_socket_pools_[http_proxy] = pool;
+  }
+
+  void SetSSLSocketPool(const scoped_refptr<SSLClientSocketPool>& pool) {
+    session_->ssl_socket_pool_ = pool;
+  }
+
+  void SetSocketPoolForSSLWithProxy(
+      const HostPortPair& proxy_host,
+      const scoped_refptr<SSLClientSocketPool>& pool) {
+    session_->ssl_socket_pools_for_proxies_[proxy_host] = pool;
   }
 
  private:
   const scoped_refptr<HttpNetworkSession> session_;
 
   DISALLOW_COPY_AND_ASSIGN(HttpNetworkSessionPeer);
 };
 
 // Helper to manage the lifetimes of the dependencies for a
 // HttpNetworkTransaction.
@@ skipping 152 matching lines @@
   for (size_t i = 0; i < n; ++i) {
     output[i] = bytes[current_byte++];
     current_byte %= arraysize(bytes);
   }
 }
 
 std::string MockGetHostName() {
   return "WTC-WIN7";
 }
 
-template<typename EmulatedClientSocketPool>
-class CaptureGroupNameSocketPool : public EmulatedClientSocketPool {
+template<typename ParentPool>
+class CaptureGroupNameSocketPool : public ParentPool {
  public:
-  explicit CaptureGroupNameSocketPool(HttpNetworkSession* session)
-      : EmulatedClientSocketPool(0, 0, NULL, session->host_resolver(), NULL,
-                                 NULL) {
-  }
+  explicit CaptureGroupNameSocketPool(HttpNetworkSession* session);
+
   const std::string last_group_name_received() const {
     return last_group_name_;
   }
 
   virtual int RequestSocket(const std::string& group_name,
                             const void* socket_params,
                             RequestPriority priority,
                             ClientSocketHandle* handle,
                             CompletionCallback* callback,
                             const BoundNetLog& net_log) {
@@ skipping 25 matching lines @@
  private:
   std::string last_group_name_;
 };
 
 typedef CaptureGroupNameSocketPool<TCPClientSocketPool>
 CaptureGroupNameTCPSocketPool;
 typedef CaptureGroupNameSocketPool<HttpProxyClientSocketPool>
 CaptureGroupNameHttpProxySocketPool;
 typedef CaptureGroupNameSocketPool<SOCKSClientSocketPool>
 CaptureGroupNameSOCKSSocketPool;
+typedef CaptureGroupNameSocketPool<SSLClientSocketPool>
+CaptureGroupNameSSLSocketPool;
+
+template<typename ParentPool>
+CaptureGroupNameSocketPool<ParentPool>::CaptureGroupNameSocketPool(
+    HttpNetworkSession* session)
+    : ParentPool(0, 0, NULL, session->host_resolver(), NULL, NULL) {}
+
+template<>
+CaptureGroupNameSSLSocketPool::CaptureGroupNameSocketPool(
+    HttpNetworkSession* session)
+    : SSLClientSocketPool(0, 0, NULL, session->host_resolver(), NULL, NULL,
+                          NULL, NULL, NULL) {}
 
 //-----------------------------------------------------------------------------
 
 TEST_F(HttpNetworkTransactionTest, Basic) {
   SessionDependencies session_deps;
   scoped_ptr<HttpTransaction> trans(
       new HttpNetworkTransaction(CreateSession(&session_deps)));
 }
 
 TEST_F(HttpNetworkTransactionTest, SimpleGET) {
@@ skipping 1094 matching lines @@
   EXPECT_EQ(10, response->headers->GetContentLength());
   EXPECT_TRUE(HttpVersion(1, 1) == response->headers->GetHttpVersion());
 
   // The password prompt info should have been set in response->auth_challenge.
   EXPECT_FALSE(response->auth_challenge.get() == NULL);
 
   EXPECT_EQ(L"myproxy:70", response->auth_challenge->host_and_port);
   EXPECT_EQ(L"MyRealm1", response->auth_challenge->realm);
   EXPECT_EQ(L"basic", response->auth_challenge->scheme);
 
-  // Cleanup the transaction so that the sockets are destroyed before the
-  // net log goes out of scope.
-  trans.reset();
-
-  // We also need to run the message queue for the socket releases to complete.
-  MessageLoop::current()->RunAllPending();
+  // Flush the idle socket before the NetLog and HttpNetworkTransaction go
+  // out of scope.
+  session->FlushSocketPools();
 }
 
 // Test that we don't read the response body when we fail to establish a tunnel,
 // even if the user cancels the proxy's auth attempt.
 TEST_F(HttpNetworkTransactionTest, BasicAuthProxyCancelTunnel) {
   // Configure against proxy server "myproxy:70".
   SessionDependencies session_deps(CreateFixedProxyService("myproxy:70"));
 
   scoped_refptr<HttpNetworkSession> session(CreateSession(&session_deps));
 
@@ skipping 35 matching lines @@
   EXPECT_FALSE(response == NULL);
 
   EXPECT_TRUE(response->headers->IsKeepAlive());
   EXPECT_EQ(407, response->headers->response_code());
   EXPECT_EQ(10, response->headers->GetContentLength());
   EXPECT_TRUE(HttpVersion(1, 1) == response->headers->GetHttpVersion());
 
   std::string response_data;
   rv = ReadTransaction(trans.get(), &response_data);
   EXPECT_EQ(ERR_TUNNEL_CONNECTION_FAILED, rv);
+
+  // Flush the idle socket before the HttpNetworkTransaction goes out of scope.
+  session->FlushSocketPools();
 }
 
 // Test when a server (non-proxy) returns a 407 (proxy-authenticate).
 // The request should fail with ERR_UNEXPECTED_PROXY_AUTH.
 TEST_F(HttpNetworkTransactionTest, UnexpectedProxyAuth) {
   // We are using a DIRECT connection (i.e. no proxy) for this session.
   SessionDependencies session_deps;
   scoped_ptr<HttpTransaction> trans(
       new HttpNetworkTransaction(CreateSession(&session_deps)));
 
@@ skipping 2492 matching lines @@
   EXPECT_EQ(OK, rv);
   EXPECT_EQ("Payload", response_text);
 }
 
 // Tests that for connection endpoints the group names are correctly set.
 
 struct GroupNameTest {
   std::string proxy_server;
   std::string url;
   std::string expected_group_name;
+  bool ssl;
 };
 
 scoped_refptr<HttpNetworkSession> SetupSessionForGroupNameTests(
     const std::string& proxy_server) {
   SessionDependencies session_deps(CreateFixedProxyService(proxy_server));
   scoped_refptr<HttpNetworkSession> session(CreateSession(&session_deps));
 
   HttpAlternateProtocols* alternate_protocols =
       session->mutable_alternate_protocols();
   alternate_protocols->SetAlternateProtocolFor(
@@ skipping 18 matching lines @@
   // We do not complete this request, the dtor will clean the transaction up.
   return trans->Start(&request, &callback, BoundNetLog());
 }
 
 TEST_F(HttpNetworkTransactionTest, GroupNameForDirectConnections) {
   const GroupNameTest tests[] = {
     {
       "",  // unused
       "http://www.google.com/direct",
       "www.google.com:80",
+      false,
     },
     {
       "",  // unused
       "http://[2001:1418:13:1::25]/direct",
       "[2001:1418:13:1::25]:80",
+      false,
     },
 
     // SSL Tests
     {
       "",  // unused
       "https://www.google.com/direct_ssl",
       "ssl/www.google.com:443",
+      true,
     },
     {
       "",  // unused
       "https://[2001:1418:13:1::25]/direct",
       "ssl/[2001:1418:13:1::25]:443",
+      true,
     },
     {
       "",  // unused
       "http://host.with.alternate/direct",
       "ssl/host.with.alternate:443",
+      true,
     },
   };
 
   HttpNetworkTransaction::SetUseAlternateProtocols(true);
 
   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(tests); ++i) {
     scoped_refptr<HttpNetworkSession> session(
         SetupSessionForGroupNameTests(tests[i].proxy_server));
 
     HttpNetworkSessionPeer peer(session);
     scoped_refptr<CaptureGroupNameTCPSocketPool> tcp_conn_pool(
         new CaptureGroupNameTCPSocketPool(session.get()));
     peer.SetTCPSocketPool(tcp_conn_pool);
+    scoped_refptr<CaptureGroupNameSSLSocketPool> ssl_conn_pool(
+        new CaptureGroupNameSSLSocketPool(session.get()));
+    peer.SetSSLSocketPool(ssl_conn_pool);
 
     EXPECT_EQ(ERR_IO_PENDING,
               GroupNameTransactionHelper(tests[i].url, session));
-    EXPECT_EQ(tests[i].expected_group_name,
-              tcp_conn_pool->last_group_name_received());
+    if (tests[i].ssl)
+      EXPECT_EQ(tests[i].expected_group_name,
+                ssl_conn_pool->last_group_name_received());
+    else
+      EXPECT_EQ(tests[i].expected_group_name,
+                tcp_conn_pool->last_group_name_received());
   }
 
   HttpNetworkTransaction::SetUseAlternateProtocols(false);
 }
 
 TEST_F(HttpNetworkTransactionTest, GroupNameForHTTPProxyConnections) {
   const GroupNameTest tests[] = {
     {
       "http_proxy",
       "http://www.google.com/http_proxy_normal",
       "www.google.com:80",
+      false,
     },
 
     // SSL Tests
     {
       "http_proxy",
       "https://www.google.com/http_connect_ssl",
       "ssl/www.google.com:443",
+      true,
     },
 
     {
       "http_proxy",
       "http://host.with.alternate/direct",
       "ssl/host.with.alternate:443",
+      true,
     },
   };
 
   HttpNetworkTransaction::SetUseAlternateProtocols(true);
 
   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(tests); ++i) {
     scoped_refptr<HttpNetworkSession> session(
         SetupSessionForGroupNameTests(tests[i].proxy_server));
 
     HttpNetworkSessionPeer peer(session);
 
+    HostPortPair proxy_host("http_proxy", 80);
     scoped_refptr<CaptureGroupNameHttpProxySocketPool> http_proxy_pool(
         new CaptureGroupNameHttpProxySocketPool(session.get()));
-    peer.SetSocketPoolForHTTPProxy(
-        HostPortPair("http_proxy", 80), http_proxy_pool);
+    peer.SetSocketPoolForHTTPProxy(proxy_host, http_proxy_pool);
+    scoped_refptr<CaptureGroupNameSSLSocketPool> ssl_conn_pool(
+        new CaptureGroupNameSSLSocketPool(session.get()));
+    peer.SetSocketPoolForSSLWithProxy(proxy_host, ssl_conn_pool);
 
     EXPECT_EQ(ERR_IO_PENDING,
               GroupNameTransactionHelper(tests[i].url, session));
-    EXPECT_EQ(tests[i].expected_group_name,
-              http_proxy_pool->last_group_name_received());
+    if (tests[i].ssl)
+      EXPECT_EQ(tests[i].expected_group_name,
+                ssl_conn_pool->last_group_name_received());
+    else
+      EXPECT_EQ(tests[i].expected_group_name,
+                http_proxy_pool->last_group_name_received());
   }
 
   HttpNetworkTransaction::SetUseAlternateProtocols(false);
 }
 
 TEST_F(HttpNetworkTransactionTest, GroupNameForSOCKSConnections) {
   const GroupNameTest tests[] = {
     {
       "socks4://socks_proxy:1080",
       "http://www.google.com/socks4_direct",
       "socks4/www.google.com:80",
+      false,
     },
     {
       "socks5://socks_proxy:1080",
       "http://www.google.com/socks5_direct",
       "socks5/www.google.com:80",
+      false,
     },
 
     // SSL Tests
     {
       "socks4://socks_proxy:1080",
       "https://www.google.com/socks4_ssl",
       "socks4/ssl/www.google.com:443",
+      true,
     },
     {
       "socks5://socks_proxy:1080",
       "https://www.google.com/socks5_ssl",
       "socks5/ssl/www.google.com:443",
+      true,
     },
 
     {
       "socks4://socks_proxy:1080",
       "http://host.with.alternate/direct",
       "socks4/ssl/host.with.alternate:443",
+      true,
     },
   };
 
   HttpNetworkTransaction::SetUseAlternateProtocols(true);
 
   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(tests); ++i) {
     scoped_refptr<HttpNetworkSession> session(
         SetupSessionForGroupNameTests(tests[i].proxy_server));
     HttpNetworkSessionPeer peer(session);
 
+    HostPortPair proxy_host("socks_proxy", 1080);
     scoped_refptr<CaptureGroupNameSOCKSSocketPool> socks_conn_pool(
         new CaptureGroupNameSOCKSSocketPool(session.get()));
-    peer.SetSocketPoolForSOCKSProxy(
-        HostPortPair("socks_proxy", 1080), socks_conn_pool);
+    peer.SetSocketPoolForSOCKSProxy(proxy_host, socks_conn_pool);
+    scoped_refptr<CaptureGroupNameSSLSocketPool> ssl_conn_pool(
+        new CaptureGroupNameSSLSocketPool(session.get()));
+    peer.SetSocketPoolForSSLWithProxy(proxy_host, ssl_conn_pool);
 
     scoped_ptr<HttpTransaction> trans(new HttpNetworkTransaction(session));
 
     EXPECT_EQ(ERR_IO_PENDING,
               GroupNameTransactionHelper(tests[i].url, session));
-    EXPECT_EQ(tests[i].expected_group_name,
-              socks_conn_pool->last_group_name_received());
+    if (tests[i].ssl)
+      EXPECT_EQ(tests[i].expected_group_name,
+                ssl_conn_pool->last_group_name_received());
+    else
+      EXPECT_EQ(tests[i].expected_group_name,
+                socks_conn_pool->last_group_name_received());
   }
 
   HttpNetworkTransaction::SetUseAlternateProtocols(false);
 }
 
 TEST_F(HttpNetworkTransactionTest, ReconsiderProxyAfterFailedConnection) {
   SessionDependencies session_deps(
       CreateFixedProxyService("myproxy:70;foobar:80"));
 
   // This simulates failure resolving all hostnames; that means we will fail
@@ skipping 1695 matching lines @@
         EXPECT_EQ(round + 1, test_config.num_auth_rounds);
         continue;
       }
       if (round + 1 < test_config.num_auth_rounds) {
         EXPECT_FALSE(response->auth_challenge.get() == NULL);
       } else {
         EXPECT_TRUE(response->auth_challenge.get() == NULL);
       }
     }
   }
+
+  // Flush the idle socket before the HttpNetworkTransaction goes out of scope.
+  session->FlushSocketPools();
 }
 
 class TLSDecompressionFailureSocketDataProvider : public SocketDataProvider {
  public:
   explicit TLSDecompressionFailureSocketDataProvider(bool fail_all)
       : fail_all_(fail_all) {
   }
 
   virtual MockRead GetNextRead() {
     if (fail_all_)
@@ skipping 30 matching lines @@
   SSLSocketDataProvider ssl_socket_data_provider1(
       false, ERR_SSL_DECOMPRESSION_FAILURE_ALERT);
   SSLSocketDataProvider ssl_socket_data_provider2(false, OK);
   session_deps.socket_factory.AddSocketDataProvider(&socket_data_provider1);
   session_deps.socket_factory.AddSocketDataProvider(&socket_data_provider2);
   session_deps.socket_factory.AddSSLSocketDataProvider(
       &ssl_socket_data_provider1);
   session_deps.socket_factory.AddSSLSocketDataProvider(
       &ssl_socket_data_provider2);
 
+  // Work around http://crbug.com/37454
+  StaticSocketDataProvider bug37454_connection;
+  bug37454_connection.set_connect_data(MockConnect(true, ERR_UNEXPECTED));
+  session_deps.socket_factory.AddSocketDataProvider(&bug37454_connection);
+
   scoped_refptr<HttpNetworkSession> session(CreateSession(&session_deps));
   scoped_ptr<HttpTransaction> trans(new HttpNetworkTransaction(session));
   TestCompletionCallback callback;
 
   int rv = trans->Start(&request, &callback, BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
   EXPECT_EQ(OK, callback.WaitForResult());
 
   const HttpResponseInfo* response = trans->GetResponseInfo();
   ASSERT_TRUE(response != NULL);
@@ skipping 149 matching lines @@
 
   int rv = trans->Start(&request, &callback, BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
   EXPECT_EQ(ERR_CONNECTION_CLOSED, callback.WaitForResult());
 
   HttpNetworkTransaction::SetNextProtos("");
   HttpNetworkTransaction::SetUseAlternateProtocols(false);
 }
 
 }  // namespace net