[SPDY] Add a SpdyStreamType enum and use it for SpdyStream

net/spdy/spdy_http_stream.cc

 // Copyright (c) 2012 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 "base/bind.h"
@@ skipping 12 matching lines @@
 #include "net/spdy/spdy_protocol.h"
 #include "net/spdy/spdy_session.h"
 
 namespace net {
 
 SpdyHttpStream::SpdyHttpStream(SpdySession* spdy_session,
                                bool direct)
     : weak_factory_(this),
       spdy_session_(spdy_session),
       stream_closed_(false),
-      closed_stream_pushed_(false),
       closed_stream_status_(ERR_FAILED),
       closed_stream_id_(0),
       request_info_(NULL),
       has_upload_data_(false),
       response_info_(NULL),
       response_headers_received_(false),
       user_buffer_len_(0),
       raw_request_body_buf_size_(0),
       buffered_read_callback_pending_(false),
       more_read_data_pending_(false),
@@ skipping 16 matching lines @@
 int SpdyHttpStream::InitializeStream(const HttpRequestInfo* request_info,
                                      RequestPriority priority,
                                      const BoundNetLog& stream_net_log,
                                      const CompletionCallback& callback) {
   DCHECK(!stream_.get());
   if (spdy_session_->IsClosed())
    return ERR_CONNECTION_CLOSED;
 
   request_info_ = request_info;
   if (request_info_->method == "GET") {
     int error = spdy_session_->GetPushStream(request_info_->url, &stream_,

[Ryan Hamilton, 2013/05/26 15:33:49]

Oh, I see.  it does know that it's using a push stream. Cool.

                                              stream_net_log);
     if (error != OK)
       return error;
 
     // |stream_| may be NULL even if OK was returned.
     if (stream_) {
+      DCHECK_EQ(stream_->type(), SPDY_PUSH_STREAM);
       stream_->SetDelegate(this);
       return OK;
     }
   }
 
   int rv = stream_request_.StartRequest(
-      spdy_session_, request_info_->url, priority,
-      stream_net_log,
+      SPDY_REQUEST_RESPONSE_STREAM, spdy_session_, request_info_->url,
+      priority, stream_net_log,
       base::Bind(&SpdyHttpStream::OnStreamCreated,
                  weak_factory_.GetWeakPtr(), callback));
 
   if (rv == OK) {
     stream_ = stream_request_.ReleaseStream();
     stream_->SetDelegate(this);
   }
 
   return rv;
 }
@@ skipping 101 matching lines @@
   if (stream_id == 0)
     return false;
 
   return spdy_session_->GetLoadTimingInfo(stream_id, load_timing_info);
 }
 
 int SpdyHttpStream::SendRequest(const HttpRequestHeaders& request_headers,
                                 HttpResponseInfo* response,
                                 const CompletionCallback& callback) {
   if (stream_closed_) {
-    if (stream_->pushed())
+    if (stream_->type() == SPDY_PUSH_STREAM)
       return closed_stream_status_;
 
     return (closed_stream_status_ == OK) ? ERR_FAILED : closed_stream_status_;
   }
 
   base::Time request_time = base::Time::Now();
   CHECK(stream_.get());
 
   stream_->SetRequestTime(request_time);
   // This should only get called in the case of a request occurring
@@ skipping 32 matching lines @@
 
   response_info_ = response;
 
   // Put the peer's IP address and port into the response.
   IPEndPoint address;
   int result = stream_->GetPeerAddress(&address);
   if (result != OK)
     return result;
   response_info_->socket_address = HostPortPair::FromIPEndPoint(address);
 
-  scoped_ptr<SpdyHeaderBlock> headers(new SpdyHeaderBlock);
-  CreateSpdyHeadersFromHttpRequest(*request_info_, request_headers,
-                                   headers.get(), stream_->GetProtocolVersion(),
-                                   direct_);
-  stream_->net_log().AddEvent(
-      NetLog::TYPE_HTTP_TRANSACTION_SPDY_SEND_REQUEST_HEADERS,
-      base::Bind(&SpdyHeaderBlockNetLogCallback, headers.get()));
-  result =
-      stream_->SendRequestHeaders(
-          headers.Pass(),
-          has_upload_data_ ? MORE_DATA_TO_SEND : NO_MORE_DATA_TO_SEND);
+  if (stream_->type() == SPDY_PUSH_STREAM) {
+    // Pushed streams do not send any data, and should always be
+    // idle. However, we still want to return ERR_IO_PENDING to mimic
+    // non-push behavior. The callback will be called when the
+    // response is received.
+    result = ERR_IO_PENDING;
+  } else {
+    scoped_ptr<SpdyHeaderBlock> headers(new SpdyHeaderBlock);
+    CreateSpdyHeadersFromHttpRequest(
+        *request_info_, request_headers,
+        headers.get(), stream_->GetProtocolVersion(),
+        direct_);
+    stream_->net_log().AddEvent(
+        NetLog::TYPE_HTTP_TRANSACTION_SPDY_SEND_REQUEST_HEADERS,
+        base::Bind(&SpdyHeaderBlockNetLogCallback, headers.get()));
+    result =
+        stream_->SendRequestHeaders(
+            headers.Pass(),
+            has_upload_data_ ? MORE_DATA_TO_SEND : NO_MORE_DATA_TO_SEND);
+  }
+
   if (result == ERR_IO_PENDING) {
     CHECK(callback_.is_null());
     callback_ = callback;
   }
   return result;
 }
 
 void SpdyHttpStream::Cancel() {
   callback_.Reset();
   if (stream_) {
     stream_->Cancel();
     DCHECK(!stream_);
   }
 }
 
-SpdySendStatus SpdyHttpStream::OnSendRequestHeadersComplete() {
+void SpdyHttpStream::OnSendRequestHeadersComplete() {
   if (!callback_.is_null())
     DoCallback(OK);
-  return has_upload_data_ ? MORE_DATA_TO_SEND : NO_MORE_DATA_TO_SEND;
 }
 
 void SpdyHttpStream::OnSendBody() {
   CHECK(request_info_ && request_info_->upload_data_stream);
   if (raw_request_body_buf_size_ > 0) {
     SendRequestBodyData();
   } else {
     // We shouldn't be called if there's no more data to read.
     CHECK(!request_info_->upload_data_stream->IsEOF());
     ReadAndSendRequestBodyData();
   }
 }
 
 void SpdyHttpStream::OnSendBodyComplete() {
   // |status| is the number of bytes written to the SPDY stream.
   CHECK(request_info_ && request_info_->upload_data_stream);
   raw_request_body_buf_size_ = 0;
 }
 
 int SpdyHttpStream::OnResponseReceived(const SpdyHeaderBlock& response,
                                        base::Time response_time,
                                        int status) {
   if (!response_info_) {
-    DCHECK(stream_->pushed());
+    DCHECK_EQ(stream_->type(), SPDY_PUSH_STREAM);
     push_response_info_.reset(new HttpResponseInfo);
     response_info_ = push_response_info_.get();
   }
 
   // If the response is already received, these headers are too late.
   if (response_headers_received_) {
     LOG(WARNING) << "SpdyHttpStream headers received after response started.";
     return OK;
   }
 
@@ skipping 46 matching lines @@
   // SpdyStream won't call us with data if the header block didn't contain a
   // valid set of headers.  So we don't expect to not have headers received
   // here.
   if (!response_headers_received_)
     return ERR_INCOMPLETE_SPDY_HEADERS;
 
   // Note that data may be received for a SpdyStream prior to the user calling
   // ReadResponseBody(), therefore user_buffer_ may be NULL.  This may often
   // happen for server initiated streams.
   DCHECK(stream_.get());
-  DCHECK(!stream_->closed() || stream_->pushed());
+  DCHECK(!stream_->closed() || stream_->type() == SPDY_PUSH_STREAM);
   if (buffer) {
     response_body_queue_.Enqueue(buffer.Pass());
 
     if (user_buffer_) {
       // Handing small chunks of data to the caller creates measurable overhead.
       // We buffer data in short time-spans and send a single read notification.
       ScheduleBufferedReadCallback();
     }
   }
   return OK;
 }
 
 void SpdyHttpStream::OnDataSent() {
   // For HTTP streams, no data is sent from the client while in the OPEN state,
   // so it is never called.
   CHECK(false);
 }
 
 void SpdyHttpStream::OnClose(int status) {
   if (stream_) {
     stream_closed_ = true;
-    closed_stream_pushed_ = stream_->pushed();
     closed_stream_status_ = status;
     closed_stream_id_ = stream_->stream_id();
   }
   stream_.reset();
   bool invoked_callback = false;
   if (status == net::OK) {
     // We need to complete any pending buffered read now.
     invoked_callback = DoBufferedReadCallback();
   }
   if (!invoked_callback && !callback_.is_null())
@@ skipping 135 matching lines @@
 bool SpdyHttpStream::IsSpdyHttpStream() const {
   return true;
 }
 
 void SpdyHttpStream::Drain(HttpNetworkSession* session) {
   Close(false);
   delete this;
 }
 
 }  // namespace net