Stop refcounting ClientSocketPool.

Establishes that HttpNetworkSession owns all the socket pools.
Move out all the socket pools into a ClientSocketPoolManager.  This is because
of the dependency tree amongst socket pools, which dictates the order in which
they must be constructed and destructed.  In order to better establish it, I
moved them out to their own class.  HttpNetworkSession owns the
ClientSocketPoolManager which owns the pools.  We pass the pools as raw
pointers everywhere.

Note that ClientSocketPoolManager owns more pools than are publicly accessible via its interface.  That's because some of them are wrapped by publicly exposed pools.

Also, ClientSocketPoolHistograms used to be reference counted.  That's because it can be shared by multiple ClientSocketPools.  But it's effectively a global as well, so I make their lifetimes persist for the length of ClientSocketPoolManager too.

I also removed internal refcounting in ClientSocketPoolBase.  I had refcounted
it before I knew about ScopedRunnableMethodFactory back when I first started.

I cleaned up the unit tests a lot.  Back when I was a young padawan, I didn't
really know what I was doing, so I copy/pasted a metric asston of code.  Turns
out most of it was stupid, so I fixed it.  I also stopped the use of
implementation inheritance with ClientSocketPoolTest because it's discouraged
by the style guide and more importantly because it caused the
ClientSocketHandles within the TestSocketRequest vector to be destroyed _after_
the pools themselves were destroyed, which is bad since the handles will call
pool_->Release() which blows up.

BUG=56215,56215
TEST=Existing unit tests

Review URL: http://codereview.chromium.org/3389020

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@60983 0039d316-1c4b-4281-b951-d872f2087c98

1 files changed, 74 insertions, 47 deletions

diff --git a/net/socket/ssl_client_socket_pool_unittest.cc b/net/socket/ssl_client_socket_pool_unittest.cc
index 62d7aac..feac473 100644
--- a/net/socket/ssl_client_socket_pool_unittest.cc
+++ b/net/socket/ssl_client_socket_pool_unittest.cc
@@ -32,7 +32,7 @@ namespace {
 const int kMaxSockets = 32;
 const int kMaxSocketsPerGroup = 6;
 
-class SSLClientSocketPoolTest : public ClientSocketPoolTest {
+class SSLClientSocketPoolTest : public testing::Test {
  protected:
   SSLClientSocketPoolTest()
       : host_resolver_(new MockHostResolver),
@@ -48,60 +48,64 @@ class SSLClientSocketPoolTest : public ClientSocketPoolTest {
                                         NULL)),
         direct_tcp_socket_params_(new TCPSocketParams(
             HostPortPair("host", 443), MEDIUM, GURL(), false)),
-        tcp_socket_pool_(new MockTCPClientSocketPool(
+        tcp_histograms_("MockTCP"),
+        tcp_socket_pool_(
             kMaxSockets,
             kMaxSocketsPerGroup,
-            make_scoped_refptr(new ClientSocketPoolHistograms("MockTCP")),
-            &socket_factory_)),
+            &tcp_histograms_,
+            &socket_factory_),
         proxy_tcp_socket_params_(new TCPSocketParams(
             HostPortPair("proxy", 443), MEDIUM, GURL(), false)),
+        socks_socket_params_(new SOCKSSocketParams(
+            proxy_tcp_socket_params_, true, HostPortPair("sockshost", 443),
+            MEDIUM, GURL())),
+        socks_histograms_("MockSOCKS"),
+        socks_socket_pool_(
+            kMaxSockets,
+            kMaxSocketsPerGroup,
+            &socks_histograms_,
+            &tcp_socket_pool_),
         http_proxy_socket_params_(new HttpProxySocketParams(
             proxy_tcp_socket_params_, NULL, GURL("http://host"), "",
             HostPortPair("host", 80),
             session_->auth_cache(),
             session_->http_auth_handler_factory(),
             true)),
-        http_proxy_socket_pool_(new HttpProxyClientSocketPool(
+        http_proxy_histograms_("MockHttpProxy"),
+        http_proxy_socket_pool_(
             kMaxSockets,
             kMaxSocketsPerGroup,
-            make_scoped_refptr(new ClientSocketPoolHistograms("MockHttpProxy")),
+            &http_proxy_histograms_,
             new MockHostResolver,
-            tcp_socket_pool_,
+            &tcp_socket_pool_,
             NULL,
-            NULL)),
-        socks_socket_params_(new SOCKSSocketParams(
-            proxy_tcp_socket_params_, true, HostPortPair("sockshost", 443),
-            MEDIUM, GURL())),
-        socks_socket_pool_(new MockSOCKSClientSocketPool(
-            kMaxSockets,
-            kMaxSocketsPerGroup,
-            make_scoped_refptr(new ClientSocketPoolHistograms("MockSOCKS")),
-            tcp_socket_pool_)) {
+            NULL) {
     scoped_refptr<SSLConfigService> ssl_config_service(
         new SSLConfigServiceDefaults);
     ssl_config_service->GetSSLConfig(&ssl_config_);
   }
 
   void CreatePool(bool tcp_pool, bool http_proxy_pool, bool socks_pool) {
-    pool_ = new SSLClientSocketPool(
+    ssl_histograms_.reset(new ClientSocketPoolHistograms("SSLUnitTest"));
+    pool_.reset(new SSLClientSocketPool(
         kMaxSockets,
         kMaxSocketsPerGroup,
-        make_scoped_refptr(new ClientSocketPoolHistograms("SSLUnitTest")),
+        ssl_histograms_.get(),
         NULL,
         &socket_factory_,
-        tcp_pool ? tcp_socket_pool_ : NULL,
-        http_proxy_pool ? http_proxy_socket_pool_ : NULL,
-        socks_pool ? socks_socket_pool_ : NULL,
+        tcp_pool ? &tcp_socket_pool_ : NULL,
+        socks_pool ? &socks_socket_pool_ : NULL,
+        http_proxy_pool ? &http_proxy_socket_pool_ : NULL,
         NULL,
-        NULL);
+        NULL));
   }
 
   scoped_refptr<SSLSocketParams> SSLParams(ProxyServer::Scheme proxy,
                                            bool want_spdy_over_npn) {
     return make_scoped_refptr(new SSLSocketParams(
         proxy == ProxyServer::SCHEME_DIRECT ? direct_tcp_socket_params_ : NULL,
-        proxy == ProxyServer::SCHEME_HTTP ? http_proxy_socket_params_ : NULL,
         proxy == ProxyServer::SCHEME_SOCKS5 ? socks_socket_params_ : NULL,
+        proxy == ProxyServer::SCHEME_HTTP ? http_proxy_socket_params_ : NULL,
         proxy,
         "host",
         ssl_config_,
@@ -123,17 +127,22 @@ class SSLClientSocketPoolTest : public ClientSocketPoolTest {
   scoped_refptr<HttpNetworkSession> session_;
 
   scoped_refptr<TCPSocketParams> direct_tcp_socket_params_;
-  scoped_refptr<MockTCPClientSocketPool> tcp_socket_pool_;
+  ClientSocketPoolHistograms tcp_histograms_;
+  MockTCPClientSocketPool tcp_socket_pool_;
 
   scoped_refptr<TCPSocketParams> proxy_tcp_socket_params_;
-  scoped_refptr<HttpProxySocketParams> http_proxy_socket_params_;
-  scoped_refptr<HttpProxyClientSocketPool> http_proxy_socket_pool_;
 
   scoped_refptr<SOCKSSocketParams> socks_socket_params_;
-  scoped_refptr<MockSOCKSClientSocketPool> socks_socket_pool_;
+  ClientSocketPoolHistograms socks_histograms_;
+  MockSOCKSClientSocketPool socks_socket_pool_;
+
+  scoped_refptr<HttpProxySocketParams> http_proxy_socket_params_;
+  ClientSocketPoolHistograms http_proxy_histograms_;
+  HttpProxyClientSocketPool http_proxy_socket_pool_;
 
   SSLConfig ssl_config_;
-  scoped_refptr<SSLClientSocketPool> pool_;
+  scoped_ptr<ClientSocketPoolHistograms> ssl_histograms_;
+  scoped_ptr<SSLClientSocketPool> pool_;
 };
 
 TEST_F(SSLClientSocketPoolTest, TCPFail) {
@@ -146,7 +155,7 @@ TEST_F(SSLClientSocketPoolTest, TCPFail) {
                                                     false);
 
   ClientSocketHandle handle;
-  int rv = handle.Init("a", params, MEDIUM, NULL, pool_, BoundNetLog());
+  int rv = handle.Init("a", params, MEDIUM, NULL, pool_.get(), BoundNetLog());
   EXPECT_EQ(ERR_CONNECTION_FAILED, rv);
   EXPECT_FALSE(handle.is_initialized());
   EXPECT_FALSE(handle.socket());
@@ -164,7 +173,8 @@ TEST_F(SSLClientSocketPoolTest, TCPFailAsync) {
 
   ClientSocketHandle handle;
   TestCompletionCallback callback;
-  int rv = handle.Init("a", params, MEDIUM, &callback, pool_, BoundNetLog());
+  int rv = handle.Init(
+      "a", params, MEDIUM, &callback, pool_.get(), BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
   EXPECT_FALSE(handle.is_initialized());
   EXPECT_FALSE(handle.socket());
@@ -188,7 +198,8 @@ TEST_F(SSLClientSocketPoolTest, BasicDirect) {
 
   ClientSocketHandle handle;
   TestCompletionCallback callback;
-  int rv = handle.Init("a", params, MEDIUM, &callback, pool_, BoundNetLog());
+  int rv = handle.Init(
+      "a", params, MEDIUM, &callback, pool_.get(), BoundNetLog());
   EXPECT_EQ(OK, rv);
   EXPECT_TRUE(handle.is_initialized());
   EXPECT_TRUE(handle.socket());
@@ -206,7 +217,8 @@ TEST_F(SSLClientSocketPoolTest, BasicDirectAsync) {
 
   ClientSocketHandle handle;
   TestCompletionCallback callback;
-  int rv = handle.Init("a", params, MEDIUM, &callback, pool_, BoundNetLog());
+  int rv = handle.Init(
+      "a", params, MEDIUM, &callback, pool_.get(), BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
   EXPECT_FALSE(handle.is_initialized());
   EXPECT_FALSE(handle.socket());
@@ -228,7 +240,8 @@ TEST_F(SSLClientSocketPoolTest, DirectCertError) {
 
   ClientSocketHandle handle;
   TestCompletionCallback callback;
-  int rv = handle.Init("a", params, MEDIUM, &callback, pool_, BoundNetLog());
+  int rv = handle.Init(
+      "a", params, MEDIUM, &callback, pool_.get(), BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
   EXPECT_FALSE(handle.is_initialized());
   EXPECT_FALSE(handle.socket());
@@ -250,7 +263,8 @@ TEST_F(SSLClientSocketPoolTest, DirectSSLError) {
 
   ClientSocketHandle handle;
   TestCompletionCallback callback;
-  int rv = handle.Init("a", params, MEDIUM, &callback, pool_, BoundNetLog());
+  int rv = handle.Init(
+      "a", params, MEDIUM, &callback, pool_.get(), BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
   EXPECT_FALSE(handle.is_initialized());
   EXPECT_FALSE(handle.socket());
@@ -275,7 +289,8 @@ TEST_F(SSLClientSocketPoolTest, DirectWithNPN) {
 
   ClientSocketHandle handle;
   TestCompletionCallback callback;
-  int rv = handle.Init("a", params, MEDIUM, &callback, pool_, BoundNetLog());
+  int rv = handle.Init(
+      "a", params, MEDIUM, &callback, pool_.get(), BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
   EXPECT_FALSE(handle.is_initialized());
   EXPECT_FALSE(handle.socket());
@@ -301,7 +316,8 @@ TEST_F(SSLClientSocketPoolTest, DirectNoSPDY) {
 
   ClientSocketHandle handle;
   TestCompletionCallback callback;
-  int rv = handle.Init("a", params, MEDIUM, &callback, pool_, BoundNetLog());
+  int rv = handle.Init(
+      "a", params, MEDIUM, &callback, pool_.get(), BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
   EXPECT_FALSE(handle.is_initialized());
   EXPECT_FALSE(handle.socket());
@@ -326,7 +342,8 @@ TEST_F(SSLClientSocketPoolTest, DirectGotSPDY) {
 
   ClientSocketHandle handle;
   TestCompletionCallback callback;
-  int rv = handle.Init("a", params, MEDIUM, &callback, pool_, BoundNetLog());
+  int rv = handle.Init(
+      "a", params, MEDIUM, &callback, pool_.get(), BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
   EXPECT_FALSE(handle.is_initialized());
   EXPECT_FALSE(handle.socket());
@@ -357,7 +374,8 @@ TEST_F(SSLClientSocketPoolTest, DirectGotBonusSPDY) {
 
   ClientSocketHandle handle;
   TestCompletionCallback callback;
-  int rv = handle.Init("a", params, MEDIUM, &callback, pool_, BoundNetLog());
+  int rv = handle.Init(
+      "a", params, MEDIUM, &callback, pool_.get(), BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
   EXPECT_FALSE(handle.is_initialized());
   EXPECT_FALSE(handle.socket());
@@ -385,7 +403,8 @@ TEST_F(SSLClientSocketPoolTest, SOCKSFail) {
 
   ClientSocketHandle handle;
   TestCompletionCallback callback;
-  int rv = handle.Init("a", params, MEDIUM, &callback, pool_, BoundNetLog());
+  int rv = handle.Init(
+      "a", params, MEDIUM, &callback, pool_.get(), BoundNetLog());
   EXPECT_EQ(ERR_CONNECTION_FAILED, rv);
   EXPECT_FALSE(handle.is_initialized());
   EXPECT_FALSE(handle.socket());
@@ -403,7 +422,8 @@ TEST_F(SSLClientSocketPoolTest, SOCKSFailAsync) {
 
   ClientSocketHandle handle;
   TestCompletionCallback callback;
-  int rv = handle.Init("a", params, MEDIUM, &callback, pool_, BoundNetLog());
+  int rv = handle.Init(
+      "a", params, MEDIUM, &callback, pool_.get(), BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
   EXPECT_FALSE(handle.is_initialized());
   EXPECT_FALSE(handle.socket());
@@ -427,7 +447,8 @@ TEST_F(SSLClientSocketPoolTest, SOCKSBasic) {
 
   ClientSocketHandle handle;
   TestCompletionCallback callback;
-  int rv = handle.Init("a", params, MEDIUM, &callback, pool_, BoundNetLog());
+  int rv = handle.Init(
+      "a", params, MEDIUM, &callback, pool_.get(), BoundNetLog());
   EXPECT_EQ(OK, rv);
   EXPECT_TRUE(handle.is_initialized());
   EXPECT_TRUE(handle.socket());
@@ -445,7 +466,8 @@ TEST_F(SSLClientSocketPoolTest, SOCKSBasicAsync) {
 
   ClientSocketHandle handle;
   TestCompletionCallback callback;
-  int rv = handle.Init("a", params, MEDIUM, &callback, pool_, BoundNetLog());
+  int rv = handle.Init(
+      "a", params, MEDIUM, &callback, pool_.get(), BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
   EXPECT_FALSE(handle.is_initialized());
   EXPECT_FALSE(handle.socket());
@@ -466,7 +488,8 @@ TEST_F(SSLClientSocketPoolTest, HttpProxyFail) {
 
   ClientSocketHandle handle;
   TestCompletionCallback callback;
-  int rv = handle.Init("a", params, MEDIUM, &callback, pool_, BoundNetLog());
+  int rv = handle.Init(
+      "a", params, MEDIUM, &callback, pool_.get(), BoundNetLog());
   EXPECT_EQ(ERR_PROXY_CONNECTION_FAILED, rv);
   EXPECT_FALSE(handle.is_initialized());
   EXPECT_FALSE(handle.socket());
@@ -484,7 +507,8 @@ TEST_F(SSLClientSocketPoolTest, HttpProxyFailAsync) {
 
   ClientSocketHandle handle;
   TestCompletionCallback callback;
-  int rv = handle.Init("a", params, MEDIUM, &callback, pool_, BoundNetLog());
+  int rv = handle.Init(
+      "a", params, MEDIUM, &callback, pool_.get(), BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
   EXPECT_FALSE(handle.is_initialized());
   EXPECT_FALSE(handle.socket());
@@ -520,7 +544,8 @@ TEST_F(SSLClientSocketPoolTest, HttpProxyBasic) {
 
   ClientSocketHandle handle;
   TestCompletionCallback callback;
-  int rv = handle.Init("a", params, MEDIUM, &callback, pool_, BoundNetLog());
+  int rv = handle.Init(
+      "a", params, MEDIUM, &callback, pool_.get(), BoundNetLog());
   EXPECT_EQ(OK, rv);
   EXPECT_TRUE(handle.is_initialized());
   EXPECT_TRUE(handle.socket());
@@ -549,7 +574,8 @@ TEST_F(SSLClientSocketPoolTest, HttpProxyBasicAsync) {
 
   ClientSocketHandle handle;
   TestCompletionCallback callback;
-  int rv = handle.Init("a", params, MEDIUM, &callback, pool_, BoundNetLog());
+  int rv = handle.Init(
+      "a", params, MEDIUM, &callback, pool_.get(), BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
   EXPECT_FALSE(handle.is_initialized());
   EXPECT_FALSE(handle.socket());
@@ -583,7 +609,8 @@ TEST_F(SSLClientSocketPoolTest, NeedProxyAuth) {
 
   ClientSocketHandle handle;
   TestCompletionCallback callback;
-  int rv = handle.Init("a", params, MEDIUM, &callback, pool_, BoundNetLog());
+  int rv = handle.Init(
+      "a", params, MEDIUM, &callback, pool_.get(), BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
   EXPECT_FALSE(handle.is_initialized());
   EXPECT_FALSE(handle.socket());