Implement MAX_CONCURRENT_STREAMS SETTINGS header

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 "base/compiler_specific.h"
 #include "base/field_trial.h"
 #include "base/format_macros.h"
 #include "base/histogram.h"
@@ skipping 248 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_SPDY_SEND_REQUEST;
+      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 150 matching lines @@
   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_SSL_CONNECT_COMPLETE:
       return LOAD_STATE_SSL_HANDSHAKE;
     case STATE_GENERATE_PROXY_AUTH_TOKEN_COMPLETE:
     case STATE_GENERATE_SERVER_AUTH_TOKEN_COMPLETE:
     case STATE_SEND_REQUEST_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;
@@ skipping 113 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:
@@ skipping 132 matching lines @@
       endpoint_.port = session_->fixed_https_port();
   } else if (session_->fixed_http_port() != 0) {
     endpoint_.port = session_->fixed_http_port();
   }
 
   // Check first if we have a spdy session for this group.  If so, then go
   // straight to using that.
   if (session_->spdy_session_pool()->HasSession(endpoint_)) {
     using_spdy_ = true;
     reused_socket_ = true;
-    next_state_ = STATE_SPDY_SEND_REQUEST;
+    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 189 matching lines @@
   }
 
   if (result == ERR_SSL_CLIENT_AUTH_CERT_NEEDED)
     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_SPDY_SEND_REQUEST;
+    next_state_ = STATE_SPDY_GET_STREAM;
   } else {
     next_state_ = STATE_GENERATE_PROXY_AUTH_TOKEN;
   }
   return OK;
 }
 
 int HttpNetworkTransaction::DoGenerateProxyAuthToken() {
   next_state_ = STATE_GENERATE_PROXY_AUTH_TOKEN_COMPLETE;
   if (!ShouldApplyProxyAuth())
     return OK;
@@ skipping 261 matching lines @@
   if (done) {
     DidDrainBodyForAuthRestart(keep_alive);
   } else {
     // Keep draining.
     next_state_ = STATE_DRAIN_BODY_FOR_AUTH_RESTART;
   }
 
   return OK;
 }
 
-int HttpNetworkTransaction::DoSpdySendRequest() {
-  next_state_ = STATE_SPDY_SEND_REQUEST_COMPLETE;
+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;
 
   if (spdy_pool->HasSession(endpoint_)) {
     spdy_session = spdy_pool->Get(endpoint_, session_, net_log_);
   } else {
     // SPDY is negotiated using the TLS next protocol negotiation (NPN)
     // extension, so |connection_| must contain an SSLClientSocket.
     DCHECK(using_ssl_);
     CHECK(connection_->socket());
     int error = spdy_pool->GetSpdySessionFromSSLSocket(
         endpoint_, session_, connection_.release(), net_log_,
         spdy_certificate_error_, &spdy_session);
     if (error != OK)
       return error;
   }
 
   CHECK(spdy_session.get());
   if(spdy_session->IsClosed())
     return ERR_CONNECTION_CLOSED;
 
-  UploadDataStream* upload_data = NULL;
+  headers_valid_ = false;
+
+  spdy_http_stream_.reset(new SpdyHttpStream());
+  return spdy_http_stream_->InitializeStream(spdy_session, *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 = UploadDataStream::Create(request_->upload_data, &error_code);
-    if (!upload_data)
+    upload_data_stream = UploadDataStream::Create(request_->upload_data,
+                                                  &error_code);
+    if (!upload_data_stream)
       return error_code;
   }
-  headers_valid_ = false;
-  scoped_refptr<SpdyStream> spdy_stream;
-  if (request_->method == "GET") {
-    int error =
-        spdy_session->GetPushStream(request_->url, &spdy_stream, net_log_);
-    if (error != OK)
-      return error;
-  }
-  if (spdy_stream.get()) {
-    DCHECK(spdy_stream->pushed());
-    CHECK(spdy_stream->GetDelegate() == NULL);
-    spdy_http_stream_.reset(new SpdyHttpStream(spdy_stream));
-    spdy_http_stream_->InitializeRequest(*request_, base::Time::Now(), NULL);
-  } else {
-    int error = spdy_session->CreateStream(request_->url,
-                                           request_->priority,
-                                           &spdy_stream,
-                                           net_log_);
-    if (error != OK)
-      return error;
-    DCHECK(!spdy_stream->pushed());
-    CHECK(spdy_stream->GetDelegate() == NULL);
-    spdy_http_stream_.reset(new SpdyHttpStream(spdy_stream));
-    spdy_http_stream_->InitializeRequest(
-        *request_, base::Time::Now(), upload_data);
-  }
+  spdy_http_stream_->InitializeRequest(base::Time::Now(), upload_data_stream);
+
   return spdy_http_stream_->SendRequest(&response_, &io_callback_);
 }
 
 int HttpNetworkTransaction::DoSpdySendRequestComplete(int result) {
   if (result < 0)
     return result;
 
   next_state_ = STATE_SPDY_READ_HEADERS;
   return OK;
 }
@@ skipping 486 matching lines @@
     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;
 }
 
 #undef STATE_CASE
 
 }  // namespace net