Allow a non-200 (or non-407) response for a CONNECT request from an HTTPS pro...

net/http/http_stream_request.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_stream_request.h"
 
 #include "base/stl_util-inl.h"
 #include "base/string_number_conversions.h"
 #include "base/string_util.h"
 #include "base/stringprintf.h"
@@ skipping 188 matching lines @@
     const HttpResponseInfo& response,
     HttpAuthController* auth_controller) {
   delegate_->OnNeedsProxyAuth(response, auth_controller);
 }
 
 void HttpStreamRequest::OnNeedsClientAuthCallback(
     SSLCertRequestInfo* cert_info) {
   delegate_->OnNeedsClientAuth(cert_info);
 }
 
+void HttpStreamRequest::OnHttpsProxyTunnelResponseCallback(
+    const HttpResponseInfo& response_info,
+    HttpStream* stream) {
+  delegate_->OnHttpsProxyTunnelResponse(response_info, stream);
+}
+
 void HttpStreamRequest::OnPreconnectsComplete(int result) {
   preconnect_delegate_->OnPreconnectsComplete(this, result);
 }
 
 void HttpStreamRequest::OnIOComplete(int result) {
   RunLoop(result);
 }
 
 int HttpStreamRequest::RunLoop(int result) {
   result = DoLoop(result);
@@ skipping 25 matching lines @@
   }
 
   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());

[vandebo (ex-Chrome), 2010/12/16 02:24:31]

note, no change necessary: Should we now cast this to ProxyClientSocket? Would
that help spdy proxy auth work?

[Ryan Hamilton, 2010/12/16 05:23:50]

Yeah, I thought about that and think it's a good change that we should make. 
However, we need to widen the ProxyClientSocket interface to expose the
auth_controller() method called a few lines later.  I'll do that in a second CL.

         const HttpResponseInfo* tunnel_auth_response =
-            http_proxy_socket->GetResponseInfo();
+            http_proxy_socket->GetConnectResponseInfo();
 
         next_state_ = STATE_WAITING_USER_ACTION;
         MessageLoop::current()->PostTask(
             FROM_HERE,
             method_factory_.NewRunnableMethod(
                 &HttpStreamRequest::OnNeedsProxyAuthCallback,
                 *tunnel_auth_response,
                 http_proxy_socket->auth_controller()));
       }
       return ERR_IO_PENDING;
 
     case ERR_SSL_CLIENT_AUTH_CERT_NEEDED:
       MessageLoop::current()->PostTask(
           FROM_HERE,
           method_factory_.NewRunnableMethod(
               &HttpStreamRequest::OnNeedsClientAuthCallback,
               connection_->ssl_error_response_info().cert_request_info));
       return ERR_IO_PENDING;
 
+    case ERR_HTTPS_PROXY_TUNNEL_RESPONSE:
+      {
+        DCHECK(connection_.get());
+        DCHECK(connection_->socket());
+        DCHECK(establishing_tunnel_);
+
+        ProxyClientSocket* proxy_socket =
+            static_cast<ProxyClientSocket*>(connection_->socket());
+        MessageLoop::current()->PostTask(
+            FROM_HERE,
+            method_factory_.NewRunnableMethod(
+                &HttpStreamRequest::OnHttpsProxyTunnelResponseCallback,
+                *proxy_socket->GetConnectResponseInfo(),
+                proxy_socket->CreateConnectResponseStream()));
+        return ERR_IO_PENDING;
+      }
+
     case OK:
       next_state_ = STATE_DONE;
       MessageLoop::current()->PostTask(
           FROM_HERE,
           method_factory_.NewRunnableMethod(
               &HttpStreamRequest::OnStreamReadyCallback));
       return ERR_IO_PENDING;
 
     default:
       MessageLoop::current()->PostTask(
@@ skipping 369 matching lines @@
     if (proxy_socket->using_spdy()) {
       was_npn_negotiated_ = true;
       SwitchToSpdyMode();
     }
   }
 
   // We may be using spdy without SSL
   if (!force_spdy_over_ssl_ && force_spdy_always_)
     SwitchToSpdyMode();
 
-  if (result == ERR_PROXY_AUTH_REQUESTED) {
+  if (result == ERR_PROXY_AUTH_REQUESTED ||
+      result == ERR_HTTPS_PROXY_TUNNEL_RESPONSE) {
     DCHECK(!ssl_started);
     // Other state (i.e. |using_ssl_|) suggests that |connection_| will have an
     // SSL socket, but there was an error before that could happen.  This
     // puts the in progress HttpProxy socket into |connection_| in order to
-    // complete the auth.  The tunnel restart code is careful to remove it
-    // before returning control to the rest of this class.
+    // complete the auth (or read the response body).  The tunnel restart code
+    // is careful to remove it before returning control to the rest of this
+    // class.
     connection_.reset(connection_->release_pending_http_proxy_connection());
     return result;
   }
 
   if ((!ssl_started && result < 0 &&
        alternate_protocol_mode_ == kUsingAlternateProtocol) ||
       result == ERR_NPN_NEGOTIATION_FAILED) {
     // Mark the alternate protocol as broken and fallback.
     MarkBrokenAlternateProtocolAndFallback();
     return OK;
@@ skipping 55 matching lines @@
   // this socket.  Is there a race for two SPDY requests?  We really
   // need to plumb this through to the connect level.
   if (connection_->socket() && !connection_->is_reused())
     SetSocketMotivation();
 
   const ProxyServer& proxy_server = proxy_info()->proxy_server();
 
   if (!using_spdy_) {
     bool using_proxy = (proxy_info()->is_http() || proxy_info()->is_https()) &&
         request_info().url.SchemeIs("http");
-    stream_.reset(new HttpBasicStream(connection_.release(), using_proxy));
+    stream_.reset(new HttpBasicStream(connection_.release(), NULL,
+                                      using_proxy));
     return OK;
   }
 
   CHECK(!stream_.get());
 
   bool direct = true;
   SpdySessionPool* spdy_pool = session_->spdy_session_pool();
   scoped_refptr<SpdySession> spdy_session;
 
   HostPortProxyPair pair(endpoint_, proxy_server);
@@ skipping 27 matching lines @@
     int error = spdy_pool->GetSpdySessionFromSocket(
         pair, session_->mutable_spdy_settings(), connection_.release(),
         net_log_, spdy_certificate_error_, &spdy_session, using_ssl_);
     if (error != OK)
       return error;
   }
 
   if (spdy_session->IsClosed())
     return ERR_CONNECTION_CLOSED;
 
-  bool useRelativeUrl = direct || request_info().url.SchemeIs("https");
-  stream_.reset(new SpdyHttpStream(spdy_session, useRelativeUrl));
+  bool use_relative_url = direct || request_info().url.SchemeIs("https");
+  stream_.reset(new SpdyHttpStream(spdy_session, use_relative_url));
   return OK;
 }
 
 int HttpStreamRequest::DoCreateStreamComplete(int result) {
   if (result < 0)
     return result;
 
   next_state_ = STATE_NONE;
   return OK;
 }
@@ skipping 250 matching lines @@
                                  base::TimeDelta::FromMinutes(6),
                                  100);
       break;
     default:
       NOTREACHED();
       break;
   }
 }
 
 }  // namespace net