Make HttpAuthController not reference counted.

net/socket/ssl_client_socket_pool_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_proxy_client_socket_pool.h"
 
 #include "base/callback.h"
 #include "base/compiler_specific.h"
 #include "base/time.h"
 #include "net/base/auth.h"
@@ skipping 62 matching lines @@
         socks_pool ? socks_socket_pool_ : NULL,
         NULL);
   }
 
   scoped_refptr<SSLSocketParams> SSLParams(
       ProxyServer::Scheme proxy, struct MockHttpAuthControllerData* auth_data,
       size_t auth_data_len, bool want_spdy) {
 
     scoped_refptr<HttpProxySocketParams> http_proxy_params;
     if (proxy == ProxyServer::SCHEME_HTTP) {
-      scoped_refptr<MockHttpAuthController> auth_controller =
-         new MockHttpAuthController();
+      MockHttpAuthController* auth_controller = new MockHttpAuthController();
       auth_controller->SetMockAuthControllerData(auth_data, auth_data_len);
       http_proxy_params = new HttpProxySocketParams(proxy_tcp_socket_params_,
                                                     GURL("http://host"),
                                                     HostPortPair("host", 80),
                                                     auth_controller, true);
     }
 
     return make_scoped_refptr(new SSLSocketParams(
         proxy == ProxyServer::SCHEME_DIRECT ? direct_tcp_socket_params_ : NULL,
         http_proxy_params,
@@ skipping 389 matching lines @@
                 "Proxy-Authorization: Basic Zm9vOmJheg==\r\n\r\n"),
   };
   MockRead reads[] = {
       MockRead(false, "HTTP/1.1 200 Connection Established\r\n\r\n"),
   };
   StaticSocketDataProvider data(reads, arraysize(reads), writes,
                                 arraysize(writes));
   data.set_connect_data(MockConnect(false, OK));
   socket_factory_.AddSocketDataProvider(&data);
   MockHttpAuthControllerData auth_data[] = {
-      MockHttpAuthControllerData("Proxy-Authorization: Basic Zm9vOmJheg=="),
+      MockHttpAuthControllerData("Proxy-Authorization: Basic Zm9vOmJheg==", "",
+                                 ""),
   };
   SSLSocketDataProvider ssl(false, OK);
   socket_factory_.AddSSLSocketDataProvider(&ssl);
 
   CreatePool(false, true /* http proxy pool */, true /* socks pool */);
   scoped_refptr<SSLSocketParams> params = SSLParams(ProxyServer::SCHEME_HTTP,
                                                     auth_data,
                                                     arraysize(auth_data),
                                                     false);
 
@@ skipping 12 matching lines @@
                 "Proxy-Connection: keep-alive\r\n"
                 "Proxy-Authorization: Basic Zm9vOmJheg==\r\n\r\n"),
   };
   MockRead reads[] = {
       MockRead("HTTP/1.1 200 Connection Established\r\n\r\n"),
   };
   StaticSocketDataProvider data(reads, arraysize(reads), writes,
                                 arraysize(writes));
   socket_factory_.AddSocketDataProvider(&data);
   MockHttpAuthControllerData auth_data[] = {
-      MockHttpAuthControllerData("Proxy-Authorization: Basic Zm9vOmJheg=="),
+      MockHttpAuthControllerData("Proxy-Authorization: Basic Zm9vOmJheg==", "",
+                                 ""),
   };
   SSLSocketDataProvider ssl(true, OK);
   socket_factory_.AddSSLSocketDataProvider(&ssl);
 
   CreatePool(false, true /* http proxy pool */, true /* socks pool */);
   scoped_refptr<SSLSocketParams> params = SSLParams(ProxyServer::SCHEME_HTTP,
                                                     auth_data,
                                                     arraysize(auth_data),
                                                     false);
 
@@ skipping 18 matching lines @@
   MockRead reads[] = {
       MockRead("HTTP/1.1 407 Proxy Authentication Required\r\n"),
       MockRead("Proxy-Authenticate: Basic realm=\"MyRealm1\"\r\n"),
       MockRead("Content-Length: 10\r\n\r\n"),
       MockRead("0123456789"),
   };
   StaticSocketDataProvider data(reads, arraysize(reads), writes,
                                 arraysize(writes));
   socket_factory_.AddSocketDataProvider(&data);
   MockHttpAuthControllerData auth_data[] = {
-      MockHttpAuthControllerData(""),
+      MockHttpAuthControllerData("", "", ""),
   };
   SSLSocketDataProvider ssl(true, OK);
   socket_factory_.AddSSLSocketDataProvider(&ssl);
 
   CreatePool(false, true /* http proxy pool */, true /* socks pool */);
   scoped_refptr<SSLSocketParams> params = SSLParams(ProxyServer::SCHEME_HTTP,
                                                     auth_data,
                                                     arraysize(auth_data),
                                                     false);
 
@@ skipping 25 matching lines @@
   MockRead reads[] = {
       MockRead("HTTP/1.1 407 Proxy Authentication Required\r\n"),
       MockRead("Proxy-Authenticate: Basic realm=\"MyRealm1\"\r\n"),
       MockRead("Content-Length: 10\r\n\r\n"),
       MockRead("0123456789"),
       MockRead("HTTP/1.1 200 Connection Established\r\n\r\n"),
   };
   StaticSocketDataProvider data(reads, arraysize(reads), writes,
                                 arraysize(writes));
   socket_factory_.AddSocketDataProvider(&data);
-  MockHttpAuthControllerData auth_data[] = {
-      MockHttpAuthControllerData(""),
-      MockHttpAuthControllerData("Proxy-Authorization: Basic Zm9vOmJheg=="),
+  MockHttpAuthControllerData auth_data1[] = {
+      MockHttpAuthControllerData("", "foo", "bar"),
+      MockHttpAuthControllerData("Proxy-Authorization: Basic Zm9vOmJheg==", "",
+                                 ""),
+  };
+  MockHttpAuthControllerData auth_data2[] = {
+      MockHttpAuthControllerData("", "foo", "bar"),
   };
   SSLSocketDataProvider ssl(true, OK);
   socket_factory_.AddSSLSocketDataProvider(&ssl);
 
   CreatePool(false, true /* http proxy pool */, true /* socks pool */);
   scoped_refptr<SSLSocketParams> params = SSLParams(ProxyServer::SCHEME_HTTP,
-                                                    auth_data,
-                                                    arraysize(auth_data),
+                                                    auth_data1,
+                                                    arraysize(auth_data1),
                                                     false);
 
   ClientSocketHandle handle;
   TestCompletionCallback callback;
   int rv = handle.Init("a", params, MEDIUM, &callback, pool_, BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
   EXPECT_FALSE(handle.is_initialized());
   EXPECT_FALSE(handle.socket());
 
   EXPECT_EQ(ERR_PROXY_AUTH_REQUESTED, callback.WaitForResult());
   EXPECT_FALSE(handle.is_initialized());
   EXPECT_FALSE(handle.socket());
   EXPECT_FALSE(handle.is_ssl_error());
   const HttpResponseInfo& tunnel_info = handle.ssl_error_response_info();
   EXPECT_EQ(tunnel_info.headers->response_code(), 407);
 
-  params->http_proxy_params()->auth_controller()->ResetAuth(std::wstring(),
-                                                            std::wstring());
+  params = SSLParams(ProxyServer::SCHEME_HTTP, auth_data2,
+                     arraysize(auth_data2), false);
   rv = handle.Init("a", params, MEDIUM, &callback, pool_, BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
   EXPECT_FALSE(handle.is_initialized());
   EXPECT_FALSE(handle.socket());
 
   // Test that http://crbug.com/49325 doesn't regress.
   EXPECT_EQ(handle.GetLoadState(), LOAD_STATE_ESTABLISHING_PROXY_TUNNEL);
 
   EXPECT_EQ(OK, callback.WaitForResult());
   EXPECT_TRUE(handle.is_initialized());
@@ skipping 19 matching lines @@
   };
   MockRead reads2[] = {
       MockRead("HTTP/1.1 200 Connection Established\r\n\r\n"),
   };
   StaticSocketDataProvider data1(reads1, arraysize(reads1), writes1,
                                 arraysize(writes1));
   socket_factory_.AddSocketDataProvider(&data1);
   StaticSocketDataProvider data2(reads2, arraysize(reads2), writes2,
                                 arraysize(writes2));
   socket_factory_.AddSocketDataProvider(&data2);
-  MockHttpAuthControllerData auth_data[] = {
-      MockHttpAuthControllerData(""),
-      MockHttpAuthControllerData("Proxy-Authorization: Basic Zm9vOmJheg=="),
+  MockHttpAuthControllerData auth_data1[] = {
+      MockHttpAuthControllerData("", "foo", "bar"),
+      MockHttpAuthControllerData("Proxy-Authorization: Basic Zm9vOmJheg==",
+                                 "", ""),
+  };
+  MockHttpAuthControllerData auth_data2[] = {
+      MockHttpAuthControllerData("", "foo", "bar"),
   };
   SSLSocketDataProvider ssl(true, OK);
   socket_factory_.AddSSLSocketDataProvider(&ssl);
 
   CreatePool(false, true /* http proxy pool */, true /* socks pool */);
   scoped_refptr<SSLSocketParams> params = SSLParams(ProxyServer::SCHEME_HTTP,
-                                                    auth_data,
-                                                    arraysize(auth_data),
+                                                    auth_data1,
+                                                    arraysize(auth_data1),
                                                     false);
 
   ClientSocketHandle handle;
   TestCompletionCallback callback;
   int rv = handle.Init("a", params, MEDIUM, &callback, pool_, BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
   EXPECT_FALSE(handle.is_initialized());
   EXPECT_FALSE(handle.socket());
 
   EXPECT_EQ(ERR_PROXY_AUTH_REQUESTED, callback.WaitForResult());
   EXPECT_FALSE(handle.is_initialized());
   EXPECT_FALSE(handle.socket());
   EXPECT_FALSE(handle.is_ssl_error());
   const HttpResponseInfo& tunnel_info = handle.ssl_error_response_info();
   EXPECT_EQ(tunnel_info.headers->response_code(), 407);
 
-  params->http_proxy_params()->auth_controller()->ResetAuth(std::wstring(),
-                                                            std::wstring());
+  params = SSLParams(ProxyServer::SCHEME_HTTP, auth_data2,
+                     arraysize(auth_data2), false);
   rv = handle.Init("a", params, MEDIUM, &callback, pool_, BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
   EXPECT_FALSE(handle.is_initialized());
   EXPECT_FALSE(handle.socket());
 
   EXPECT_EQ(OK, callback.WaitForResult());
   EXPECT_TRUE(handle.is_initialized());
   EXPECT_TRUE(handle.socket());
 }
 
 // It would be nice to also test the timeouts in SSLClientSocketPool.
 
 }  // namespace
 
 }  // namespace net