Revert 54906 - Refactor HttpNetworkTransaction to eliminate the SPDY...

net/http/http_network_transaction.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_network_transaction.h"
 
 #include <set>
 #include <vector>
 
 #include "base/compiler_specific.h"
@@ skipping 280 matching lines @@
   return rv;
 }
 
 int HttpNetworkTransaction::RestartIgnoringLastError(
     CompletionCallback* callback) {
   if (connection_->socket() && connection_->socket()->IsConnectedAndIdle()) {
     // TODO(wtc): Should we update any of the connection histograms that we
     // update in DoSSLConnectComplete if |result| is OK?
     if (using_spdy_) {
       // TODO(cbentzel): Add auth support to spdy. See http://crbug.com/46620
-      next_state_ = STATE_INIT_STREAM;
+      next_state_ = STATE_SPDY_GET_STREAM;
     } else {
       next_state_ = STATE_GENERATE_PROXY_AUTH_TOKEN;
     }
   } else {
     if (connection_->socket())
       connection_->socket()->Disconnect();
     connection_->Reset();
     next_state_ = STATE_INIT_CONNECTION;
   }
   int rv = DoLoop(OK);
@@ skipping 51 matching lines @@
   return rv;
 }
 
 void HttpNetworkTransaction::PrepareForAuthRestart(HttpAuth::Target target) {
   DCHECK(HaveAuth(target));
   DCHECK(!establishing_tunnel_);
   bool keep_alive = false;
   // Even if the server says the connection is keep-alive, we have to be
   // able to find the end of each response in order to reuse the connection.
   if (GetResponseHeaders()->IsKeepAlive() &&
-      stream_->CanFindEndOfResponse()) {
+      http_stream_->CanFindEndOfResponse()) {
     // If the response body hasn't been completely read, we need to drain
     // it first.
-    if (!stream_->IsResponseBodyComplete()) {
+    if (!http_stream_->IsResponseBodyComplete()) {
       next_state_ = STATE_DRAIN_BODY_FOR_AUTH_RESTART;
       read_buf_ = new IOBuffer(kDrainBodyBufferSize);  // A bit bucket.
       read_buf_len_ = kDrainBodyBufferSize;
       return;
     }
     keep_alive = true;
   }
 
   // We don't need to drain the response body, so we act as if we had drained
   // the response body.
@@ skipping 36 matching lines @@
     // See http://crbug.com/8473.
     DCHECK(proxy_info_.is_http());
     DCHECK_EQ(headers->response_code(), 407);
     LOG(WARNING) << "Blocked proxy response with status "
                  << headers->response_code() << " to CONNECT request for "
                  << GetHostAndPort(request_->url) << ".";
     return ERR_TUNNEL_CONNECTION_FAILED;
   }
 
   // Are we using SPDY or HTTP?
-  next_state = STATE_READ_BODY;
-  DCHECK(stream_->GetResponseInfo()->headers);
-  if (!using_spdy_ && !connection_->is_initialized()) {
-    return 0;  // |*connection_| has been reset.  Treat like EOF.
+  if (using_spdy_) {
+    DCHECK(!http_stream_.get());
+    DCHECK(spdy_http_stream_->GetResponseInfo()->headers);
+    next_state = STATE_SPDY_READ_BODY;
+  } else {
+    DCHECK(!spdy_http_stream_.get());
+    next_state = STATE_READ_BODY;
+
+    if (!connection_->is_initialized())
+      return 0;  // |*connection_| has been reset.  Treat like EOF.
   }
 
   read_buf_ = buf;
   read_buf_len_ = buf_len;
 
   next_state_ = next_state;
   int rv = DoLoop(OK);
   if (rv == ERR_IO_PENDING)
     user_callback_ = callback;
   return rv;
 }
 
 const HttpResponseInfo* HttpNetworkTransaction::GetResponseInfo() const {
   return ((headers_valid_ && response_.headers) || response_.ssl_info.cert ||
           response_.cert_request_info) ? &response_ : NULL;
 }
 
 LoadState HttpNetworkTransaction::GetLoadState() const {
   // TODO(wtc): Define a new LoadState value for the
   // STATE_INIT_CONNECTION_COMPLETE state, which delays the HTTP request.
   switch (next_state_) {
     case STATE_RESOLVE_PROXY_COMPLETE:
       return LOAD_STATE_RESOLVING_PROXY_FOR_URL;
     case STATE_INIT_CONNECTION_COMPLETE:
       return connection_->GetLoadState();
     case STATE_GENERATE_PROXY_AUTH_TOKEN_COMPLETE:
     case STATE_GENERATE_SERVER_AUTH_TOKEN_COMPLETE:
     case STATE_SEND_REQUEST_COMPLETE:
-    case STATE_INIT_STREAM_COMPLETE:
+    case STATE_SPDY_GET_STREAM:
+    case STATE_SPDY_SEND_REQUEST_COMPLETE:
       return LOAD_STATE_SENDING_REQUEST;
     case STATE_READ_HEADERS_COMPLETE:
+    case STATE_SPDY_READ_HEADERS_COMPLETE:
       return LOAD_STATE_WAITING_FOR_RESPONSE;
     case STATE_READ_BODY_COMPLETE:
+    case STATE_SPDY_READ_BODY_COMPLETE:
       return LOAD_STATE_READING_RESPONSE;
     default:
       return LOAD_STATE_IDLE;
   }
 }
 
 uint64 HttpNetworkTransaction::GetUploadProgress() const {
-  if (!stream_.get())
+  if (!http_stream_.get())
     return 0;
 
-  return stream_->GetUploadProgress();
+  return http_stream_->GetUploadProgress();
 }
 
 HttpNetworkTransaction::~HttpNetworkTransaction() {
   // If we still have an open socket, then make sure to disconnect it so it
   // won't call us back and we don't try to reuse it later on. However,
   // don't close the socket if we should keep the connection alive.
   if (connection_.get() && connection_->is_initialized()) {
     // The STATE_NONE check guarantees there are no pending socket IOs that
     // could try to call this object back after it is deleted.
     bool keep_alive = next_state_ == STATE_NONE &&
-                      !using_spdy_ &&
-                      stream_.get() &&
-                      stream_->IsResponseBodyComplete() &&
-                      stream_->CanFindEndOfResponse() &&
+                      http_stream_.get() &&
+                      http_stream_->IsResponseBodyComplete() &&
+                      http_stream_->CanFindEndOfResponse() &&
                       GetResponseHeaders()->IsKeepAlive();
     if (!keep_alive)
       connection_->socket()->Disconnect();
   }
 
   if (pac_request_)
     session_->proxy_service()->CancelPacRequest(pac_request_);
 
-  if (using_spdy_ && stream_.get())
-    static_cast<SpdyHttpStream*>(stream_.get())->Cancel();
+  if (spdy_http_stream_.get())
+    spdy_http_stream_->Cancel();
 }
 
 void HttpNetworkTransaction::DoCallback(int rv) {
   DCHECK(rv != ERR_IO_PENDING);
   DCHECK(user_callback_);
 
   // Since Run may result in Read being called, clear user_callback_ up front.
   CompletionCallback* c = user_callback_;
   user_callback_ = NULL;
   c->Run(rv);
@@ skipping 20 matching lines @@
       case STATE_RESOLVE_PROXY_COMPLETE:
         rv = DoResolveProxyComplete(rv);
         break;
       case STATE_INIT_CONNECTION:
         DCHECK_EQ(OK, rv);
         rv = DoInitConnection();
         break;
       case STATE_INIT_CONNECTION_COMPLETE:
         rv = DoInitConnectionComplete(rv);
         break;
-      case STATE_INIT_STREAM:
-        DCHECK_EQ(OK, rv);
-        rv = DoInitStream();
-        break;
-      case STATE_INIT_STREAM_COMPLETE:
-        rv = DoInitStreamComplete(rv);
-        break;
       case STATE_RESTART_TUNNEL_AUTH:
         DCHECK_EQ(OK, rv);
         rv = DoRestartTunnelAuth();
         break;
       case STATE_RESTART_TUNNEL_AUTH_COMPLETE:
         rv = DoRestartTunnelAuthComplete(rv);
         break;
       case STATE_GENERATE_PROXY_AUTH_TOKEN:
         DCHECK_EQ(OK, rv);
         rv = DoGenerateProxyAuthToken();
@@ skipping 39 matching lines @@
         DCHECK_EQ(OK, rv);
         net_log_.BeginEvent(
             NetLog::TYPE_HTTP_TRANSACTION_DRAIN_BODY_FOR_AUTH_RESTART, NULL);
         rv = DoDrainBodyForAuthRestart();
         break;
       case STATE_DRAIN_BODY_FOR_AUTH_RESTART_COMPLETE:
         rv = DoDrainBodyForAuthRestartComplete(rv);
         net_log_.EndEvent(
             NetLog::TYPE_HTTP_TRANSACTION_DRAIN_BODY_FOR_AUTH_RESTART, NULL);
         break;
+      case STATE_SPDY_GET_STREAM:
+        DCHECK_EQ(OK, rv);
+        rv = DoSpdyGetStream();
+        break;
+      case STATE_SPDY_GET_STREAM_COMPLETE:
+        rv = DoSpdyGetStreamComplete(rv);
+        break;
+      case STATE_SPDY_SEND_REQUEST:
+        DCHECK_EQ(OK, rv);
+        net_log_.BeginEvent(NetLog::TYPE_SPDY_TRANSACTION_SEND_REQUEST, NULL);
+        rv = DoSpdySendRequest();
+        break;
+      case STATE_SPDY_SEND_REQUEST_COMPLETE:
+        rv = DoSpdySendRequestComplete(rv);
+        net_log_.EndEvent(NetLog::TYPE_SPDY_TRANSACTION_SEND_REQUEST, NULL);
+        break;
+      case STATE_SPDY_READ_HEADERS:
+        DCHECK_EQ(OK, rv);
+        net_log_.BeginEvent(NetLog::TYPE_SPDY_TRANSACTION_READ_HEADERS, NULL);
+        rv = DoSpdyReadHeaders();
+        break;
+      case STATE_SPDY_READ_HEADERS_COMPLETE:
+        rv = DoSpdyReadHeadersComplete(rv);
+        net_log_.EndEvent(NetLog::TYPE_SPDY_TRANSACTION_READ_HEADERS, NULL);
+        break;
+      case STATE_SPDY_READ_BODY:
+        DCHECK_EQ(OK, rv);
+        net_log_.BeginEvent(NetLog::TYPE_SPDY_TRANSACTION_READ_BODY, NULL);
+        rv = DoSpdyReadBody();
+        break;
+      case STATE_SPDY_READ_BODY_COMPLETE:
+        rv = DoSpdyReadBodyComplete(rv);
+        net_log_.EndEvent(NetLog::TYPE_SPDY_TRANSACTION_READ_BODY, NULL);
+        break;
       default:
         NOTREACHED() << "bad state";
         rv = ERR_FAILED;
         break;
     }
   } while (rv != ERR_IO_PENDING && next_state_ != STATE_NONE);
 
   return rv;
 }
 
@@ skipping 85 matching lines @@
       want_spdy_over_npn;
   using_spdy_ = false;
   response_.was_fetched_via_proxy = !proxy_info_.is_direct();
 
   // Check first if we have a spdy session for this group.  If so, then go
   // straight to using that.
   HostPortProxyPair pair(endpoint_, proxy_info_.ToPacString());
   if (session_->spdy_session_pool()->HasSession(pair)) {
     using_spdy_ = true;
     reused_socket_ = true;
-    next_state_ = STATE_INIT_STREAM;
-    spdy_session_ =
-        session_->spdy_session_pool()->Get(pair, session_, net_log_);
+    next_state_ = STATE_SPDY_GET_STREAM;
     return OK;
   }
 
   // Build the string used to uniquely identify connections of this type.
   // Determine the host and port to connect to.
   std::string connection_group = endpoint_.ToString();
   DCHECK(!connection_group.empty());
 
   if (using_ssl_)
     connection_group = StringPrintf("ssl/%s", connection_group.c_str());
@@ skipping 187 matching lines @@
     if (!reused_socket_) {
       if (using_spdy_)
         UpdateConnectionTypeHistograms(CONNECTION_SPDY);
       else
         UpdateConnectionTypeHistograms(CONNECTION_HTTP);
     }
 
     if (!using_ssl_) {
       DCHECK_EQ(OK, result);
       if (using_spdy_)
-        next_state_ = STATE_INIT_STREAM;
+        next_state_ = STATE_SPDY_GET_STREAM;
       else
         next_state_ = STATE_GENERATE_PROXY_AUTH_TOKEN;
       return result;
     }
   }
 
   // Handle SSL errors below.
   DCHECK(using_ssl_);
   DCHECK(ssl_started);
   if (IsCertificateError(result)) {
@@ skipping 16 matching lines @@
     response_.cert_request_info =
         connection_->ssl_error_response_info().cert_request_info;
     return HandleCertificateRequest(result);
   }
   if (result < 0)
     return HandleSSLHandshakeError(result);
 
   if (using_spdy_) {
     UpdateConnectionTypeHistograms(CONNECTION_SPDY);
     // TODO(cbentzel): Add auth support to spdy. See http://crbug.com/46620
-    next_state_ = STATE_INIT_STREAM;
+    next_state_ = STATE_SPDY_GET_STREAM;
   } else {
     next_state_ = STATE_GENERATE_PROXY_AUTH_TOKEN;
   }
   return OK;
 }
 
-int HttpNetworkTransaction::DoInitStream() {
-  next_state_ = STATE_INIT_STREAM_COMPLETE;
-
-  if (!using_spdy_) {
-    stream_.reset(new HttpBasicStream(connection_.get()));
-    return stream_->InitializeStream(request_, net_log_, &io_callback_);
-  }
-
-  CHECK(!stream_.get());
-
-  const scoped_refptr<SpdySessionPool> spdy_pool =
-      session_->spdy_session_pool();
-
-  HostPortProxyPair pair(endpoint_, proxy_info_.ToPacString());
-  if (!spdy_session_.get()) {
-    // SPDY can be negotiated using the TLS next protocol negotiation (NPN)
-    // extension, or just directly using SSL. Either way, |connection_| must
-    // contain an SSLClientSocket.
-    CHECK(connection_->socket());
-    int error = spdy_pool->GetSpdySessionFromSocket(
-        pair, session_, connection_.release(), net_log_,
-        spdy_certificate_error_, &spdy_session_, using_ssl_);
-    if (error != OK)
-      return error;
-  }
-  CHECK(spdy_session_.get());
-  if (spdy_session_->IsClosed())
-    return ERR_CONNECTION_CLOSED;
-
-  headers_valid_ = false;
-
-  stream_.reset(new SpdyHttpStream(spdy_session_.release()));
-  return stream_->InitializeStream(request_, net_log_, &io_callback_);
-}
-
-int HttpNetworkTransaction::DoInitStreamComplete(int result) {
-  if (result < 0)
-    return result;
-
-  next_state_ = STATE_SEND_REQUEST;
-  return OK;
-}
-
 int HttpNetworkTransaction::DoRestartTunnelAuth() {
   next_state_ = STATE_RESTART_TUNNEL_AUTH_COMPLETE;
   HttpProxyClientSocket* http_proxy_socket =
       static_cast<HttpProxyClientSocket*>(connection_->socket());
   return http_proxy_socket->RestartWithAuth(&io_callback_);
 }
 
 int HttpNetworkTransaction::DoRestartTunnelAuthComplete(int result) {
   if (result == ERR_PROXY_AUTH_REQUESTED)
     return HandleTunnelAuthFailure(result);
@@ skipping 43 matching lines @@
   if (!ShouldApplyServerAuth())
     return OK;
   return auth_controllers_[target]->MaybeGenerateAuthToken(request_,
                                                            &io_callback_,
                                                            net_log_);
 }
 
 int HttpNetworkTransaction::DoGenerateServerAuthTokenComplete(int rv) {
   DCHECK_NE(ERR_IO_PENDING, rv);
   if (rv == OK)
-    next_state_ = STATE_INIT_STREAM;
+    next_state_ = STATE_SEND_REQUEST;
   return rv;
 }
 
 int HttpNetworkTransaction::DoSendRequest() {
   next_state_ = STATE_SEND_REQUEST_COMPLETE;
 
   UploadDataStream* request_body = NULL;
   if (request_->upload_data) {
     int error_code;
     request_body = UploadDataStream::Create(request_->upload_data, &error_code);
     if (!request_body)
       return error_code;
   }
 
   // This is constructed lazily (instead of within our Start method), so that
   // we have proxy info available.
-  if (request_headers_.empty() && !using_spdy_) {
+  if (request_headers_.empty()) {
     // Figure out if we can/should add Proxy-Authentication & Authentication
     // headers.
     HttpRequestHeaders authorization_headers;
     bool have_proxy_auth = (ShouldApplyProxyAuth() &&
                             HaveAuth(HttpAuth::AUTH_PROXY));
     bool have_server_auth = (ShouldApplyServerAuth() &&
                              HaveAuth(HttpAuth::AUTH_SERVER));
     if (have_proxy_auth)
       auth_controllers_[HttpAuth::AUTH_PROXY]->AddAuthorizationHeader(
           &authorization_headers);
@@ skipping 12 matching lines @@
     if (net_log_.HasListener()) {
       net_log_.AddEvent(
           NetLog::TYPE_HTTP_TRANSACTION_SEND_REQUEST_HEADERS,
           new NetLogHttpRequestParameter(request_line, request_headers));
     }
 
     request_headers_ = request_line + request_headers.ToString();
   }
 
   headers_valid_ = false;
-  return stream_->SendRequest(request_headers_, request_body, &response_,
-                              &io_callback_);
+  http_stream_.reset(new HttpBasicStream(connection_.get()));
+  http_stream_->InitializeStream(request_, net_log_, NULL);
+  return http_stream_->SendRequest(request_headers_, request_body, &response_,
+                                   &io_callback_);
 }
 
 int HttpNetworkTransaction::DoSendRequestComplete(int result) {
   if (result < 0)
     return HandleIOError(result);
   next_state_ = STATE_READ_HEADERS;
   return OK;
 }
 
 int HttpNetworkTransaction::DoReadHeaders() {
   next_state_ = STATE_READ_HEADERS_COMPLETE;
-  return stream_->ReadResponseHeaders(&io_callback_);
+  return http_stream_->ReadResponseHeaders(&io_callback_);
 }
 
 int HttpNetworkTransaction::HandleConnectionClosedBeforeEndOfHeaders() {
   if (!response_.headers) {
     // The connection was closed before any data was sent. Likely an error
     // rather than empty HTTP/0.9 response.
     return ERR_EMPTY_RESPONSE;
   }
 
   return OK;
 }
 
 int HttpNetworkTransaction::DoReadHeadersComplete(int result) {
-  if (using_spdy_) {
-    // TODO(willchan): Flesh out the support for HTTP authentication here.
-    if (result < 0)
-      return HandleIOError(result);
-
-    if (result == OK)
-      headers_valid_ = true;
-
-    LogTransactionConnectedMetrics();
-    return result;
-  }
-
   // We can get a certificate error or ERR_SSL_CLIENT_AUTH_CERT_NEEDED here
   // due to SSL renegotiation.
   if (using_ssl_) {
     if (IsCertificateError(result)) {
       // We don't handle a certificate error during SSL renegotiation, so we
       // have to return an error that's not in the certificate error range
       // (-2xx).
       LOG(ERROR) << "Got a server certificate with error " << result
                  << " during SSL renegotiation";
       result = ERR_CERT_ERROR_IN_SSL_RENEGOTIATION;
@@ skipping 85 matching lines @@
     ssl_socket->GetSSLInfo(&response_.ssl_info);
   }
 
   headers_valid_ = true;
   return OK;
 }
 
 int HttpNetworkTransaction::DoReadBody() {
   DCHECK(read_buf_);
   DCHECK_GT(read_buf_len_, 0);
-  if (!using_spdy_)
-    DCHECK(connection_->is_initialized());
+  DCHECK(connection_->is_initialized());
 
   next_state_ = STATE_READ_BODY_COMPLETE;
-  return stream_->ReadResponseBody(read_buf_, read_buf_len_, &io_callback_);
+  return http_stream_->ReadResponseBody(read_buf_, read_buf_len_,
+                                        &io_callback_);
 }
 
 int HttpNetworkTransaction::DoReadBodyComplete(int result) {
   // We are done with the Read call.
   bool done = false, keep_alive = false;
   if (result <= 0)
     done = true;
 
-  if (stream_->IsResponseBodyComplete()) {
+  if (http_stream_->IsResponseBodyComplete()) {
     done = true;
-    if (stream_->CanFindEndOfResponse())
+    if (http_stream_->CanFindEndOfResponse())
       keep_alive = GetResponseHeaders()->IsKeepAlive();
   }
 
   // Clean up connection_->if we are done.
   if (done) {
     LogTransactionMetrics();
-    if (!using_spdy_) {
-      if (!keep_alive)
-        connection_->socket()->Disconnect();
-      connection_->Reset();
-      // The next Read call will return 0 (EOF).
-    }
+    if (!keep_alive)
+      connection_->socket()->Disconnect();
+    connection_->Reset();
+    // The next Read call will return 0 (EOF).
   }
 
   // Clear these to avoid leaving around old state.
   read_buf_ = NULL;
   read_buf_len_ = 0;
 
   return result;
 }
 
 int HttpNetworkTransaction::DoDrainBodyForAuthRestart() {
   // This method differs from DoReadBody only in the next_state_.  So we just
   // call DoReadBody and override the next_state_.  Perhaps there is a more
   // elegant way for these two methods to share code.
   int rv = DoReadBody();
   DCHECK(next_state_ == STATE_READ_BODY_COMPLETE);
   next_state_ = STATE_DRAIN_BODY_FOR_AUTH_RESTART_COMPLETE;
   return rv;
 }
 
 // TODO(wtc): This method and the DoReadBodyComplete method are almost
 // the same.  Figure out a good way for these two methods to share code.
 int HttpNetworkTransaction::DoDrainBodyForAuthRestartComplete(int result) {
   // keep_alive defaults to true because the very reason we're draining the
   // response body is to reuse the connection for auth restart.
   bool done = false, keep_alive = true;
   if (result < 0) {
     // Error or closed connection while reading the socket.
     done = true;
     keep_alive = false;
-  } else if (stream_->IsResponseBodyComplete()) {
+  } else if (http_stream_->IsResponseBodyComplete()) {
     done = true;
   }
 
   if (done) {
     DidDrainBodyForAuthRestart(keep_alive);
   } else {
     // Keep draining.
     next_state_ = STATE_DRAIN_BODY_FOR_AUTH_RESTART;
   }
 
   return OK;
 }
 
+int HttpNetworkTransaction::DoSpdyGetStream() {
+  next_state_ = STATE_SPDY_GET_STREAM_COMPLETE;
+  CHECK(!spdy_http_stream_.get());
+
+  // First we get a SPDY session.  Theoretically, we've just negotiated one, but
+  // if one already exists, then screw it, use the existing one!  Otherwise,
+  // use the existing TCP socket.
+
+  const scoped_refptr<SpdySessionPool> spdy_pool =
+      session_->spdy_session_pool();
+  scoped_refptr<SpdySession> spdy_session;
+
+  HostPortProxyPair pair(endpoint_, proxy_info_.ToPacString());
+  if (spdy_pool->HasSession(pair)) {
+    spdy_session = spdy_pool->Get(pair, session_, net_log_);
+  } else {
+    if(using_ssl_) {
+      // SPDY can be negotiated using the TLS next protocol negotiation (NPN)
+      // extension, or just directly using SSL. Either way, |connection_| must
+      // contain an SSLClientSocket.
+      CHECK(connection_->socket());
+      int error = spdy_pool->GetSpdySessionFromSocket(
+          pair, session_, connection_.release(), net_log_,
+          spdy_certificate_error_, &spdy_session, true);
+      if (error != OK)
+        return error;
+    }
+    else {
+      // We may want SPDY without SSL
+      int error = spdy_pool->GetSpdySessionFromSocket(
+          pair, session_, connection_.release(), net_log_,
+          spdy_certificate_error_, &spdy_session, false);
+      if (error != OK)
+        return error;
+    }
+  }
+
+  CHECK(spdy_session.get());
+  if (spdy_session->IsClosed())
+    return ERR_CONNECTION_CLOSED;
+
+  headers_valid_ = false;
+
+  spdy_http_stream_.reset(new SpdyHttpStream(spdy_session));
+  return spdy_http_stream_->InitializeStream(request_, net_log_, &io_callback_);
+}
+
+int HttpNetworkTransaction::DoSpdyGetStreamComplete(int result) {
+  if (result < 0)
+    return result;
+
+  next_state_ = STATE_SPDY_SEND_REQUEST;
+  return OK;
+}
+
+int HttpNetworkTransaction::DoSpdySendRequest() {
+  next_state_ = STATE_SPDY_SEND_REQUEST_COMPLETE;
+
+  UploadDataStream* upload_data_stream = NULL;
+  if (request_->upload_data) {
+    int error_code = OK;
+    upload_data_stream = UploadDataStream::Create(request_->upload_data,
+                                                  &error_code);
+    if (!upload_data_stream)
+      return error_code;
+  }
+  return spdy_http_stream_->SendRequest(request_headers_, upload_data_stream,
+                                        &response_, &io_callback_);
+}
+
+int HttpNetworkTransaction::DoSpdySendRequestComplete(int result) {
+  if (result < 0)
+    return HandleIOError(result);
+
+  next_state_ = STATE_SPDY_READ_HEADERS;
+  return OK;
+}
+
+int HttpNetworkTransaction::DoSpdyReadHeaders() {
+  next_state_ = STATE_SPDY_READ_HEADERS_COMPLETE;
+  return spdy_http_stream_->ReadResponseHeaders(&io_callback_);
+}
+
+int HttpNetworkTransaction::DoSpdyReadHeadersComplete(int result) {
+  // TODO(willchan): Flesh out the support for HTTP authentication here.
+  if (result < 0)
+    return HandleIOError(result);
+
+  if (result == OK)
+    headers_valid_ = true;
+
+  LogTransactionConnectedMetrics();
+  return result;
+}
+
+int HttpNetworkTransaction::DoSpdyReadBody() {
+  next_state_ = STATE_SPDY_READ_BODY_COMPLETE;
+
+  return spdy_http_stream_->ReadResponseBody(
+      read_buf_, read_buf_len_, &io_callback_);
+}
+
+int HttpNetworkTransaction::DoSpdyReadBodyComplete(int result) {
+  read_buf_ = NULL;
+  read_buf_len_ = 0;
+
+  if (result <= 0)
+    spdy_http_stream_.reset();
+
+  return result;
+}
+
 void HttpNetworkTransaction::LogHttpConnectedMetrics(
     const ClientSocketHandle& handle) {
   UMA_HISTOGRAM_ENUMERATION("Net.HttpSocketType", handle.reuse_type(),
                             ClientSocketHandle::NUM_TYPES);
 
   switch (handle.reuse_type()) {
     case ClientSocketHandle::UNUSED:
       UMA_HISTOGRAM_CUSTOM_TIMES("Net.HttpConnectionLatency",
                                  handle.setup_time(),
                                  base::TimeDelta::FromMilliseconds(1),
@@ skipping 258 matching lines @@
       }
       break;
   }
   return error;
 }
 
 void HttpNetworkTransaction::ResetStateForRestart() {
   pending_auth_target_ = HttpAuth::AUTH_NONE;
   read_buf_ = NULL;
   read_buf_len_ = 0;
-  stream_.reset();
+  http_stream_.reset();
   headers_valid_ = false;
   request_headers_.clear();
   response_ = HttpResponseInfo();
 }
 
 HttpResponseHeaders* HttpNetworkTransaction::GetResponseHeaders() const {
   return response_.headers;
 }
 
 bool HttpNetworkTransaction::ShouldResendRequest(int error) const {
-  if (using_spdy_ && stream_ != NULL)
-    return static_cast<SpdyHttpStream *>(stream_.get())->
-        ShouldResendFailedRequest(error);
+  if (using_spdy_ && spdy_http_stream_ != NULL)
+    return spdy_http_stream_->ShouldResendFailedRequest(error);
 
   // NOTE: we resend a request only if we reused a keep-alive connection.
   // This automatically prevents an infinite resend loop because we'll run
   // out of the cached keep-alive connections eventually.
   if (!connection_->ShouldResendFailedRequest(error) ||
       GetResponseHeaders()) {  // We have received some response headers.
     return false;
   }
   return true;
 }
 
 void HttpNetworkTransaction::ResetConnectionAndRequestForResend() {
   // Note:  When using SPDY we may not own a connection.
   if (connection_.get()) {
     if (connection_->socket())
       connection_->socket()->Disconnect();
     connection_->Reset();
   } else {
     DCHECK(using_spdy_);
     connection_.reset(new ClientSocketHandle);
   }
 
   // We need to clear request_headers_ because it contains the real request
   // headers, but we may need to resend the CONNECT request first to recreate
   // the SSL tunnel.
 
-  stream_.reset(NULL);
+  spdy_http_stream_.reset(NULL);
 
   request_headers_.clear();
   next_state_ = STATE_INIT_CONNECTION;  // Resend the request.
 }
 
 int HttpNetworkTransaction::ReconsiderProxyAfterError(int error) {
   DCHECK(!pac_request_);
 
   // A failure to resolve the hostname or any error related to establishing a
   // TCP connection could be grounds for trying a new proxy configuration.
@@ skipping 128 matching lines @@
                          description = StringPrintf("%s (0x%08X)", #s, s); \
                          break
 
 std::string HttpNetworkTransaction::DescribeState(State state) {
   std::string description;
   switch (state) {
     STATE_CASE(STATE_RESOLVE_PROXY);
     STATE_CASE(STATE_RESOLVE_PROXY_COMPLETE);
     STATE_CASE(STATE_INIT_CONNECTION);
     STATE_CASE(STATE_INIT_CONNECTION_COMPLETE);
-    STATE_CASE(STATE_INIT_STREAM);
-    STATE_CASE(STATE_INIT_STREAM_COMPLETE);
     STATE_CASE(STATE_GENERATE_PROXY_AUTH_TOKEN);
     STATE_CASE(STATE_GENERATE_PROXY_AUTH_TOKEN_COMPLETE);
     STATE_CASE(STATE_GENERATE_SERVER_AUTH_TOKEN);
     STATE_CASE(STATE_GENERATE_SERVER_AUTH_TOKEN_COMPLETE);
     STATE_CASE(STATE_SEND_REQUEST);
     STATE_CASE(STATE_SEND_REQUEST_COMPLETE);
     STATE_CASE(STATE_READ_HEADERS);
     STATE_CASE(STATE_READ_HEADERS_COMPLETE);
     STATE_CASE(STATE_READ_BODY);
     STATE_CASE(STATE_READ_BODY_COMPLETE);
     STATE_CASE(STATE_DRAIN_BODY_FOR_AUTH_RESTART);
     STATE_CASE(STATE_DRAIN_BODY_FOR_AUTH_RESTART_COMPLETE);
+    STATE_CASE(STATE_SPDY_GET_STREAM);
+    STATE_CASE(STATE_SPDY_GET_STREAM_COMPLETE);
+    STATE_CASE(STATE_SPDY_SEND_REQUEST);
+    STATE_CASE(STATE_SPDY_SEND_REQUEST_COMPLETE);
+    STATE_CASE(STATE_SPDY_READ_HEADERS);
+    STATE_CASE(STATE_SPDY_READ_HEADERS_COMPLETE);
+    STATE_CASE(STATE_SPDY_READ_BODY);
+    STATE_CASE(STATE_SPDY_READ_BODY_COMPLETE);
     STATE_CASE(STATE_NONE);
     default:
       description = StringPrintf("Unknown state 0x%08X (%u)", state, state);
       break;
   }
   return description;
 }
 
 // TODO(gavinp): re-adjust this once SPDY v3 has three priority bits,
 // eliminating the need for this folding.
 int ConvertRequestPriorityToSpdyPriority(const RequestPriority priority) {
   DCHECK(HIGHEST <= priority && priority < NUM_PRIORITIES);
   switch (priority) {
     case LOWEST:
       return SPDY_PRIORITY_LOWEST-1;
     case IDLE:
       return SPDY_PRIORITY_LOWEST;
     default:
       return priority;
   }
 }
 
 
 
 #undef STATE_CASE
 
 }  // namespace net