Allow chrome to handle 407 auth challenges to CONNECT requests

net/http/http_stream_factory_impl_job.cc

 // Copyright (c) 2011 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_stream_factory_impl_job.h"
 
 #include "base/bind.h"
 #include "base/logging.h"
 #include "base/stl_util.h"
 #include "base/string_util.h"
@@ skipping 351 matching lines @@
     return ERR_IO_PENDING;
   }
 
   switch (result) {
     case ERR_PROXY_AUTH_REQUESTED:
       {
         DCHECK(connection_.get());
         DCHECK(connection_->socket());
         DCHECK(establishing_tunnel_);
 
-        HttpProxyClientSocket* http_proxy_socket =
-            static_cast<HttpProxyClientSocket*>(connection_->socket());
+        ProxyClientSocket* proxy_socket =
+            static_cast<ProxyClientSocket*>(connection_->socket());
         const HttpResponseInfo* tunnel_auth_response =
-            http_proxy_socket->GetConnectResponseInfo();
+            proxy_socket->GetConnectResponseInfo();
 
         next_state_ = STATE_WAITING_USER_ACTION;
         MessageLoop::current()->PostTask(
             FROM_HERE,
             base::Bind(
                 &HttpStreamFactoryImpl::Job::OnNeedsProxyAuthCallback,
                 ptr_factory_.GetWeakPtr(),
                 *tunnel_auth_response,
-                http_proxy_socket->auth_controller()));
+                proxy_socket->auth_controller()));
       }
       return ERR_IO_PENDING;
 
     case ERR_SSL_CLIENT_AUTH_CERT_NEEDED:
       MessageLoop::current()->PostTask(
           FROM_HERE,
           base::Bind(
               &HttpStreamFactoryImpl::Job::OnNeedsClientAuthCallback,
               ptr_factory_.GetWeakPtr(),
               connection_->ssl_error_response_info().cert_request_info));
@@ skipping 496 matching lines @@
   if (result < 0)
     return result;
 
   session_->proxy_service()->ReportSuccess(proxy_info_);
   next_state_ = STATE_NONE;
   return OK;
 }
 
 int HttpStreamFactoryImpl::Job::DoRestartTunnelAuth() {
   next_state_ = STATE_RESTART_TUNNEL_AUTH_COMPLETE;
-  HttpProxyClientSocket* http_proxy_socket =
-      static_cast<HttpProxyClientSocket*>(connection_->socket());
-  return http_proxy_socket->RestartWithAuth(&io_callback_);
+  ProxyClientSocket* proxy_socket =
+      static_cast<ProxyClientSocket*>(connection_->socket());
+  return proxy_socket->RestartWithAuth(&io_callback_);
 }
 
 int HttpStreamFactoryImpl::Job::DoRestartTunnelAuthComplete(int result) {
   if (result == ERR_PROXY_AUTH_REQUESTED)
     return result;
 
   if (result == OK) {
-    // Now that we've got the HttpProxyClientSocket connected.  We have
+    // Now that we've got the ProxyClientSocket prepared to restart.  We have
     // to release it as an idle socket into the pool and start the connection
     // process from the beginning.  Trying to pass it in with the
     // SSLSocketParams might cause a deadlock since params are dispatched
     // interchangeably.  This request won't necessarily get this http proxy
     // socket, but there will be forward progress.
     establishing_tunnel_ = false;
-    ReturnToStateInitConnection(false /* do not close connection */);
+    ReturnToStateInitConnection(!connection_->socket()->IsConnectedAndIdle());
     return OK;
   }
 
   return ReconsiderProxyAfterError(result);
 }
 
 void HttpStreamFactoryImpl::Job::ReturnToStateInitConnection(
     bool close_connection) {
   if (close_connection && connection_->socket())
     connection_->socket()->Disconnect();
@@ skipping 215 matching lines @@
   if (IsPreconnecting() || !request_) {
     return false;
   }
   if (using_ssl_) {
     return false;
   }
   return request_info_.method == "GET" || request_info_.method == "HEAD";
 }
 
 }  // namespace net