Eliminate the establishing_tunnel_ internal state and move to explicit...

net/http/http_network_transaction.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_NETWORK_TRANSACTION_H_
 #define NET_HTTP_HTTP_NETWORK_TRANSACTION_H_
 
 #include <string>
 
 #include "base/basictypes.h"
@@ skipping 65 matching lines @@
   virtual uint64 GetUploadProgress() const;
 
  private:
   FRIEND_TEST(HttpNetworkTransactionTest, ResetStateForRestart);
 
   enum State {
     STATE_RESOLVE_PROXY,
     STATE_RESOLVE_PROXY_COMPLETE,
     STATE_INIT_CONNECTION,
     STATE_INIT_CONNECTION_COMPLETE,
+    STATE_TUNNEL_SEND_REQUEST,
+    STATE_TUNNEL_SEND_REQUEST_COMPLETE,
+    STATE_TUNNEL_READ_HEADERS,
+    STATE_TUNNEL_READ_HEADERS_COMPLETE,
     STATE_SSL_CONNECT,
     STATE_SSL_CONNECT_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_READ_BODY,
     STATE_READ_BODY_COMPLETE,
@@ skipping 21 matching lines @@
   int DoLoop(int result);
 
   // Each of these methods corresponds to a State value.  Those with an input
   // argument receive the result from the previous state.  If a method returns
   // ERR_IO_PENDING, then the result from OnIOComplete will be passed to the
   // next state method as the result arg.
   int DoResolveProxy();
   int DoResolveProxyComplete(int result);
   int DoInitConnection();
   int DoInitConnectionComplete(int result);
+  int DoTunnelSendRequest();
+  int DoTunnelSendRequestComplete(int result);
+  int DoTunnelReadHeaders();
+  int DoTunnelReadHeadersComplete(int result);
   int DoSSLConnect();
   int DoSSLConnectComplete(int result);
   int DoSendRequest();
   int DoSendRequestComplete(int result);
   int DoReadHeaders();
   int DoReadHeadersComplete(int result);
   int DoResolveCanonicalName();
   int DoResolveCanonicalNameComplete(int result);
   int DoReadBody();
   int DoReadBodyComplete(int result);
@@ skipping 67 matching lines @@
   void PrepareForAuthRestart(HttpAuth::Target target);
 
   // Called when we don't need to drain the response body or have drained it.
   // Resets |connection_| unless |keep_alive| is true, then calls
   // ResetStateForRestart.  Sets |next_state_| appropriately.
   void DidDrainBodyForAuthRestart(bool keep_alive);
 
   // Resets the members of the transaction so it can be restarted.
   void ResetStateForRestart();
 
+  // Clear the state used to setup the tunnel.
+  void ClearTunnelState();
+
   // Returns true if we should try to add a Proxy-Authorization header
   bool ShouldApplyProxyAuth() const;
 
   // Returns true if we should try to add an Authorization header.
   bool ShouldApplyServerAuth() const;
 
   // Adds either the proxy auth header, or the origin server auth header,
   // as specified by |target|.
   void AddAuthorizationHeader(
       HttpAuth::Target target, HttpRequestHeaders* authorization_headers) const;
 
   // Returns a log message for all the response headers related to the auth
   // challenge.
   std::string AuthChallengeLogMessage() const;
 
   // Handles HTTP status code 401 or 407.
   // HandleAuthChallenge() returns a network error code, or OK on success.
   // May update |pending_auth_target_| or |response_.auth_challenge|.
-  int HandleAuthChallenge();
+  int HandleAuthChallenge(bool establishing_tunnel);
 
   // Populates response_.auth_challenge with the challenge information, so that
   // URLRequestHttpJob can prompt for a username/password.
   void PopulateAuthChallenge(HttpAuth::Target target,
                              const GURL& auth_origin);
 
   // Invalidates any auth cache entries after authentication has failed.
   // The identity that was rejected is auth_identity_[target].
   void InvalidateRejectedAuthFromCache(HttpAuth::Target target,
                                        const GURL& auth_origin);
@@ skipping 72 matching lines @@
   // True if we've validated the headers that the stream parser has returned.
   bool headers_valid_;
 
   // True if we've logged the time of the first response byte.  Used to
   // prevent logging across authentication activity where we see multiple
   // responses.
   bool logged_response_time;
 
   bool using_ssl_;     // True if handling a HTTPS request
 
-  // True while establishing a tunnel.  This allows the HTTP CONNECT
-  // request/response to reuse the STATE_SEND_REQUEST,
-  // STATE_SEND_REQUEST_COMPLETE, STATE_READ_HEADERS, and
-  // STATE_READ_HEADERS_COMPLETE states and allows us to tell them apart from
-  // the real request/response of the transaction.
-  bool establishing_tunnel_;
-
   // True if this network transaction is using SPDY instead of HTTP.
   bool using_spdy_;
 
   AlternateProtocolMode alternate_protocol_mode_;
 
   // Only valid if |alternate_protocol_mode_| == kUsingAlternateProtocol.
   HttpAlternateProtocols::Protocol alternate_protocol_;
 
   // True if we've used the username/password embedded in the URL.  This
   // makes sure we use the embedded identity only once for the transaction,
@@ skipping 29 matching lines @@
   // The hostname and port of the endpoint.  This is not necessarily the one
   // specified by the URL, due to Alternate-Protocol or fixed testing ports.
   HostPortPair endpoint_;
 
   DISALLOW_COPY_AND_ASSIGN(HttpNetworkTransaction);
 };
 
 }  // namespace net
 
 #endif  // NET_HTTP_HTTP_NETWORK_TRANSACTION_H_