Make HttpAuthController not reference counted.

net/http/http_network_transaction.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 <set>
 #include <vector>
 
 #include "base/compiler_specific.h"
@@ skipping 296 matching lines @@
     const std::wstring& username,
     const std::wstring& password,
     CompletionCallback* callback) {
   HttpAuth::Target target = pending_auth_target_;
   if (target == HttpAuth::AUTH_NONE) {
     NOTREACHED();
     return ERR_UNEXPECTED;
   }
   pending_auth_target_ = HttpAuth::AUTH_NONE;
 
-  auth_controllers_[target]->ResetAuth(username, password);
-
   if (target == HttpAuth::AUTH_PROXY && using_ssl_ && proxy_info_.is_http()) {
     DCHECK(establishing_tunnel_);
+    DCHECK(auth_controllers_[target].get() == NULL);
     next_state_ = STATE_INIT_CONNECTION;
+    auth_controllers_[target].reset(new HttpAuthController(target,
+                                                           AuthURL(target),
+                                                           session_));
+    auth_controllers_[target]->SetCredentials(username, password);
     ResetStateForRestart();
   } else {
+    auth_controllers_[target]->SetCredentials(username, password);
+    auth_controllers_[target]->PrepareForAuthRestart();
     PrepareForAuthRestart(target);
   }
 
   DCHECK(user_callback_ == NULL);
   int rv = DoLoop(OK);
   if (rv == ERR_IO_PENDING)
     user_callback_ = callback;
 
   return rv;
 }
@@ skipping 365 matching lines @@
 
 int HttpNetworkTransaction::DoInitConnection() {
   DCHECK(!connection_->is_initialized());
   DCHECK(proxy_info_.proxy_server().is_valid());
   next_state_ = STATE_INIT_CONNECTION_COMPLETE;
 
   // Now that the proxy server has been resolved, create the auth_controllers_.
   for (int i = 0; i < HttpAuth::AUTH_NUM_TARGETS; i++) {
     HttpAuth::Target target = static_cast<HttpAuth::Target>(i);
     if (!auth_controllers_[target].get())
-      auth_controllers_[target] = new HttpAuthController(target,
-                                                         AuthURL(target),
-                                                         session_);
+      auth_controllers_[target].reset(new HttpAuthController(target,
+                                                             AuthURL(target),
+                                                             session_));
   }
 
   bool want_spdy = alternate_protocol_mode_ == kUsingAlternateProtocol
       && alternate_protocol_ == HttpAlternateProtocols::NPN_SPDY_1;
   using_ssl_ = request_->url.SchemeIs("https") || want_spdy;
   using_spdy_ = false;
   response_.was_fetched_via_proxy = !proxy_info_.is_direct();
 
   // Use the fixed testing ports if they've been provided.
   if (using_ssl_) {
@@ skipping 36 matching lines @@
                                      request_->referrer,
                                      disable_resolver_cache);
   } else {
     ProxyServer proxy_server = proxy_info_.proxy_server();
     proxy_host_port.reset(new HostPortPair(proxy_server.host_port_pair()));
     scoped_refptr<TCPSocketParams> proxy_tcp_params =
         new TCPSocketParams(*proxy_host_port, request_->priority,
                             request_->referrer, disable_resolver_cache);
 
     if (proxy_info_.is_http()) {
-      scoped_refptr<HttpAuthController> http_proxy_auth;
+      scoped_ptr<HttpAuthController> http_proxy_auth;
       if (using_ssl_) {
-        http_proxy_auth = auth_controllers_[HttpAuth::AUTH_PROXY];
+        http_proxy_auth.reset(
+            auth_controllers_[HttpAuth::AUTH_PROXY].release());
         establishing_tunnel_ = true;
       }
       http_proxy_params = new HttpProxySocketParams(proxy_tcp_params,
                                                     request_->url, endpoint_,
-                                                    http_proxy_auth,
+                                                    http_proxy_auth.release(),
                                                     using_ssl_);
     } else {
       DCHECK(proxy_info_.is_socks());
       char socks_version;
       if (proxy_server.scheme() == ProxyServer::SCHEME_SOCKS5)
         socks_version = '5';
       else
         socks_version = '4';
       connection_group =
           StringPrintf("socks%c/%s", socks_version, connection_group.c_str());
@@ skipping 1002 matching lines @@
     default:
       description = StringPrintf("Unknown state 0x%08X (%u)", state, state);
       break;
   }
   return description;
 }
 
 #undef STATE_CASE
 
 }  // namespace net