Implement MAX_CONCURRENT_STREAMS SETTINGS header

net/spdy/spdy_http_stream.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/spdy/spdy_http_stream.h"
 
+#include <algorithm>
 #include <list>
+#include <string>
 
 #include "base/logging.h"
 #include "base/message_loop.h"
 #include "base/string_util.h"
 #include "net/base/load_flags.h"
 #include "net/http/http_request_info.h"
 #include "net/http/http_response_info.h"
 #include "net/spdy/spdy_session.h"
 
 namespace {
@@ skipping 101 matching lines @@
     (*headers)["cache-control"] = "no-cache";
   } else if (info.load_flags & net::LOAD_VALIDATE_CACHE) {
     (*headers)["cache-control"] = "max-age=0";
   }
 }
 
 }  // anonymous namespace
 
 namespace net {
 
-SpdyHttpStream::SpdyHttpStream(const scoped_refptr<SpdyStream>& stream)
+SpdyHttpStream::SpdyHttpStream()
     : ALLOW_THIS_IN_INITIALIZER_LIST(read_callback_factory_(this)),
-      stream_(stream),
+      stream_(NULL),
+      spdy_session_(NULL),
       response_info_(NULL),
       download_finished_(false),
       user_callback_(NULL),
       user_buffer_len_(0),
       buffered_read_callback_pending_(false),
-      more_read_data_pending_(false) {
-  CHECK(stream_.get());
-  stream_->SetDelegate(this);
+      more_read_data_pending_(false) { }
+
+SpdyHttpStream::~SpdyHttpStream() {
+  if (stream_)
+    stream_->DetachDelegate();
 }
 
-SpdyHttpStream::~SpdyHttpStream() {
-  stream_->DetachDelegate();
+int SpdyHttpStream::InitializeStream(
+    SpdySession* spdy_session,
+    const HttpRequestInfo& request_info,
+    const BoundNetLog& stream_net_log,
+    CompletionCallback* callback) {
+  spdy_session_ = spdy_session;
+  request_info_ = request_info;
+  if (request_info_.method == "GET") {
+    int error = spdy_session_->GetPushStream(request_info.url, &stream_,
+                                             stream_net_log);
+    if (error != OK)
+      return error;
+  }
+
+  if (stream_.get())
+    return OK;
+  else
+    return spdy_session_->CreateStream(request_info_.url,
+                                       request_info_.priority, &stream_,
+                                       stream_net_log, callback, this);
 }
 
 void SpdyHttpStream::InitializeRequest(
-    const HttpRequestInfo& request_info,
     base::Time request_time,
     UploadDataStream* upload_data) {
-  request_info_ = request_info;
+  CHECK(stream_.get());
+  stream_->SetDelegate(this);
   linked_ptr<spdy::SpdyHeaderBlock> headers(new spdy::SpdyHeaderBlock);
   CreateSpdyHeadersFromHttpRequest(request_info_, headers.get());
   stream_->set_spdy_headers(headers);
 
   stream_->SetRequestTime(request_time);
   // This should only get called in the case of a request occuring
   // during server push that has already begun but hasn't finished,
   // so we set the response's request time to be the actual one
   if (response_info_)
     response_info_->request_time = request_time;
@@ skipping 110 matching lines @@
   bool has_upload_data = request_body_stream_.get() != NULL;
   int result = stream_->DoSendRequest(has_upload_data);
   if (result == ERR_IO_PENDING) {
     CHECK(!user_callback_);
     user_callback_ = callback;
   }
   return result;
 }
 
 void SpdyHttpStream::Cancel() {
+  if (spdy_session_)
+    spdy_session_->CancelPendingCreateStreams(this);
   user_callback_ = NULL;
-  stream_->Cancel();
+  if (stream_)
+    stream_->Cancel();
 }
 
 bool SpdyHttpStream::OnSendHeadersComplete(int status) {
   return request_body_stream_.get() == NULL;
 }
 
 int SpdyHttpStream::OnSendBody() {
   CHECK(request_body_stream_.get());
   int buf_len = static_cast<int>(request_body_stream_->buf_len());
   if (!buf_len)
@@ skipping 127 matching lines @@
   CHECK_NE(rv, ERR_IO_PENDING);
   CHECK(user_callback_);
 
   // Since Run may result in being called back, clear user_callback_ in advance.
   CompletionCallback* c = user_callback_;
   user_callback_ = NULL;
   c->Run(rv);
 }
 
 }  // namespace net