Revert 54405 - Fix late binding induced mismatch of Socket and AuthController...

net/http/http_proxy_client_socket.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.h"
 
 #include "base/string_util.h"
 #include "googleurl/src/gurl.h"
 #include "net/base/host_port_pair.h"
 #include "net/base/io_buffer.h"
@@ skipping 32 matching lines @@
                                             &user_agent))
     request_headers->SetHeader(HttpRequestHeaders::kUserAgent, user_agent);
 
   request_headers->MergeFrom(authorization_headers);
 }
 
 }  // namespace
 
 HttpProxyClientSocket::HttpProxyClientSocket(
     ClientSocketHandle* transport_socket, const GURL& request_url,
-    const HostPortPair& endpoint, const HostPortPair& proxy_server,
-    const scoped_refptr<HttpNetworkSession>& session, bool tunnel)
+    const HostPortPair& endpoint, const scoped_refptr<HttpAuthController>& auth,
+    bool tunnel)
     : ALLOW_THIS_IN_INITIALIZER_LIST(
           io_callback_(this, &HttpProxyClientSocket::OnIOComplete)),
       next_state_(STATE_NONE),
       user_callback_(NULL),
       transport_(transport_socket),
       endpoint_(endpoint),
-      auth_(tunnel ?
-          new HttpAuthController(HttpAuth::AUTH_PROXY,
-                                 GURL("http://" + proxy_server.ToString()),
-                                 session) : NULL),
+      auth_(auth),
       tunnel_(tunnel),
       net_log_(transport_socket->socket()->NetLog()) {
+  DCHECK_EQ(tunnel, auth != NULL);
   // Synthesize the bits of a request that we actually use.
   request_.url = request_url;
   request_.method = "GET";
 }
 
 HttpProxyClientSocket::~HttpProxyClientSocket() {
   Disconnect();
 }
 
 int HttpProxyClientSocket::Connect(CompletionCallback* callback) {
@@ skipping 44 matching lines @@
     }
     keep_alive = true;
   }
 
   // We don't need to drain the response body, so we act as if we had drained
   // the response body.
   return DidDrainBodyForAuthRestart(keep_alive);
 }
 
 int HttpProxyClientSocket::DidDrainBodyForAuthRestart(bool keep_alive) {
+  int rc = OK;
   if (keep_alive && transport_->socket()->IsConnectedAndIdle()) {
     next_state_ = STATE_GENERATE_AUTH_TOKEN;
     transport_->set_is_reused(true);
   } else {
-    // This assumes that the underlying transport socket is a TCP socket,
-    // since only TCP sockets are restartable.
-    next_state_ = STATE_TCP_RESTART;
     transport_->socket()->Disconnect();
+    rc = ERR_RETRY_CONNECTION;
   }
 
   // Reset the other member variables.
   drain_buf_ = NULL;
   http_stream_.reset();
   request_headers_.clear();
   response_ = HttpResponseInfo();
-  return OK;
+  return rc;
 }
 
 void HttpProxyClientSocket::LogBlockedTunnelResponse(int response_code) const {
   LOG(WARNING) << "Blocked proxy response with status " << response_code
                << " to CONNECT request for "
                << GetHostAndPort(request_.url) << ".";
 }
 
 void HttpProxyClientSocket::Disconnect() {
   transport_->socket()->Disconnect();
 
   // Reset other states to make sure they aren't mistakenly used later.
   // These are the states initialized by Connect().
   next_state_ = STATE_NONE;
   user_callback_ = NULL;
 }
 
 bool HttpProxyClientSocket::IsConnected() const {
-  return next_state_ == STATE_DONE && transport_->socket()->IsConnected();
+  return transport_->socket()->IsConnected();
 }
 
 bool HttpProxyClientSocket::IsConnectedAndIdle() const {
-  return next_state_ == STATE_DONE &&
-    transport_->socket()->IsConnectedAndIdle();
+  return transport_->socket()->IsConnectedAndIdle();
+}
+
+bool HttpProxyClientSocket::NeedsRestartWithAuth() const {
+  return next_state_ != STATE_DONE;
 }
 
 int HttpProxyClientSocket::Read(IOBuffer* buf, int buf_len,
-                                CompletionCallback* callback) {
+                            CompletionCallback* callback) {
   DCHECK(!user_callback_);
   if (next_state_ != STATE_DONE) {
     // We're trying to read the body of the response but we're still trying
     // to establish an SSL tunnel through the proxy.  We can't read these
     // bytes when establishing a tunnel because they might be controlled by
     // an active network attacker.  We don't worry about this for HTTP
     // because an active network attacker can already control HTTP sessions.
     // We reach this case when the user cancels a 407 proxy auth prompt.
     // See http://crbug.com/8473.
     DCHECK_EQ(407, response_.headers->response_code());
@@ skipping 81 matching lines @@
         net_log_.EndEvent(NetLog::TYPE_HTTP_TRANSACTION_TUNNEL_READ_HEADERS,
                           NULL);
         break;
       case STATE_DRAIN_BODY:
         DCHECK_EQ(OK, rv);
         rv = DoDrainBody();
         break;
       case STATE_DRAIN_BODY_COMPLETE:
         rv = DoDrainBodyComplete(rv);
         break;
-      case STATE_TCP_RESTART:
-        DCHECK_EQ(OK, rv);
-        rv = DoTCPRestart();
-        break;
-      case STATE_TCP_RESTART_COMPLETE:
-        rv = DoTCPRestartComplete(rv);
-        break;
       case STATE_DONE:
         break;
       default:
         NOTREACHED() << "bad state";
         rv = ERR_UNEXPECTED;
         break;
     }
-  } while (rv != ERR_IO_PENDING && next_state_ != STATE_NONE &&
-           next_state_ != STATE_DONE);
+  } while (rv != ERR_IO_PENDING && next_state_ != STATE_NONE
+           && next_state_ != STATE_DONE);
   return rv;
 }
 
 int HttpProxyClientSocket::DoGenerateAuthToken() {
   next_state_ = STATE_GENERATE_AUTH_TOKEN_COMPLETE;
   return auth_->MaybeGenerateAuthToken(&request_, &io_callback_, net_log_);
 }
 
 int HttpProxyClientSocket::DoGenerateAuthTokenComplete(int result) {
   DCHECK_NE(ERR_IO_PENDING, result);
@@ skipping 104 matching lines @@
     return result;
 
   if (http_stream_->IsResponseBodyComplete())
     return DidDrainBodyForAuthRestart(true);
 
   // Keep draining.
   next_state_ = STATE_DRAIN_BODY;
   return OK;
 }
 
-int HttpProxyClientSocket::DoTCPRestart() {
-  next_state_ = STATE_TCP_RESTART_COMPLETE;
-  return transport_->socket()->Connect(&io_callback_);
-}
-
-int HttpProxyClientSocket::DoTCPRestartComplete(int result) {
-  if (result != OK)
-    return result;
-
-  next_state_ = STATE_GENERATE_AUTH_TOKEN;
-  return result;
-}
-
 int HttpProxyClientSocket::HandleAuthChallenge() {
   DCHECK(response_.headers);
 
   int rv = auth_->HandleAuthChallenge(response_.headers, false, true, net_log_);
   response_.auth_challenge = auth_->auth_info();
   if (rv == OK)
     return ERR_PROXY_AUTH_REQUESTED;
 
   return rv;
 }
 
 }  // namespace net