Fix late binding induced mismatch of Socket and AuthController

net/http/http_proxy_client_socket.h

 // 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.
 
 #ifndef NET_HTTP_HTTP_PROXY_CLIENT_SOCKET_H_
 #define NET_HTTP_HTTP_PROXY_CLIENT_SOCKET_H_
 #pragma once
 
 #include <string>
 
@@ skipping 17 matching lines @@
 class HttpStream;
 class IOBuffer;;
 
 class HttpProxyClientSocket : public ClientSocket {
  public:
   // Takes ownership of |transport_socket|, which should already be connected
   // by the time Connect() is called.  If tunnel is true then on Connect()
   // this socket will establish an Http tunnel.
   HttpProxyClientSocket(ClientSocketHandle* transport_socket,
                         const GURL& request_url, const HostPortPair& endpoint,
-                        const scoped_refptr<HttpAuthController>& auth,
+                        const HostPortPair& proxy_server,
+                        const scoped_refptr<HttpNetworkSession>& session,
                         bool tunnel);
 
   // On destruction Disconnect() is called.
   virtual ~HttpProxyClientSocket();
 
   // If Connect (or its callback) returns PROXY_AUTH_REQUESTED, then
   // credentials should be added to the HttpAuthController before calling
   // RestartWithAuth.
   int RestartWithAuth(CompletionCallback* callback);
 
-  // Indicates if RestartWithAuth needs to be called. i.e. if Connect
-  // returned PROXY_AUTH_REQUESTED.  Only valid after Connect has been called.
-  bool NeedsRestartWithAuth() const;
+  const HttpResponseInfo* GetResponseInfo() const {
+    return response_.headers ? &response_ : NULL;
+  }
 
-  const HttpResponseInfo* GetResponseInfo() const {
-      return response_.headers ? &response_ : NULL;
+  const scoped_refptr<HttpAuthController>& auth_controller() {
+    return auth_;
   }
 
   // ClientSocket methods:
 
   // Authenticates to the Http Proxy and then passes data freely.
   virtual int Connect(CompletionCallback* callback);
   virtual void Disconnect();
   virtual bool IsConnected() const;
   virtual bool IsConnectedAndIdle() const;
   virtual const BoundNetLog& NetLog() const { return net_log_; }
@@ skipping 13 matching lines @@
     STATE_GENERATE_AUTH_TOKEN,
     STATE_GENERATE_AUTH_TOKEN_COMPLETE,
     STATE_SEND_REQUEST,
     STATE_SEND_REQUEST_COMPLETE,
     STATE_READ_HEADERS,
     STATE_READ_HEADERS_COMPLETE,
     STATE_RESOLVE_CANONICAL_NAME,
     STATE_RESOLVE_CANONICAL_NAME_COMPLETE,
     STATE_DRAIN_BODY,
     STATE_DRAIN_BODY_COMPLETE,
+    STATE_TCP_RESTART,
+    STATE_TCP_RESTART_COMPLETE,
     STATE_DONE,
   };
 
   // The size in bytes of the buffer we use to drain the response body that
   // we want to throw away.  The response body is typically a small error
   // page just a few hundred bytes long.
   enum { kDrainBodyBufferSize = 1024 };
 
   int PrepareForAuthRestart();
   int DidDrainBodyForAuthRestart(bool keep_alive);
 
   int HandleAuthChallenge();
 
   void LogBlockedTunnelResponse(int response_code) const;
 
   void DoCallback(int result);
   void OnIOComplete(int result);
 
   int DoLoop(int last_io_result);
   int DoGenerateAuthToken();
   int DoGenerateAuthTokenComplete(int result);
   int DoSendRequest();
   int DoSendRequestComplete(int result);
   int DoReadHeaders();
   int DoReadHeadersComplete(int result);
   int DoDrainBody();
   int DoDrainBodyComplete(int result);
+  int DoTCPRestart();
+  int DoTCPRestartComplete(int result);
 
   CompletionCallbackImpl<HttpProxyClientSocket> io_callback_;
   State next_state_;
 
   // Stores the callback to the layer above, called on completing Connect().
   CompletionCallback* user_callback_;
 
   HttpRequestInfo request_;
   HttpResponseInfo response_;
 
@@ skipping 12 matching lines @@
   std::string request_headers_;
 
   const BoundNetLog net_log_;
 
   DISALLOW_COPY_AND_ASSIGN(HttpProxyClientSocket);
 };
 
 }  // namespace net
 
 #endif  // NET_HTTP_HTTP_PROXY_CLIENT_SOCKET_H_