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

net/spdy/spdy_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_stream.h"
 
 #include <limits>
 
 #include "base/bind.h"
 #include "base/compiler_specific.h"
@@ skipping 60 matching lines @@
     }
     DCHECK_GT(stream_->stream_id(), 0u);
     return scoped_ptr<SpdyBuffer>(
         new SpdyBuffer(stream_->ProduceSynStreamFrame()));
   }
 
  private:
   const base::WeakPtr<SpdyStream> stream_;
 };
 
-SpdyStream::SpdyStream(SpdySession* session,
+SpdyStream::SpdyStream(SpdyStreamType type,
+                       SpdySession* session,
                        const std::string& path,
                        RequestPriority priority,
                        int32 initial_send_window_size,
                        int32 initial_recv_window_size,
-                       bool pushed,
                        const BoundNetLog& net_log)
-    : weak_ptr_factory_(this),
+    : type_(type),
+      weak_ptr_factory_(this),
       in_do_loop_(false),
       continue_buffering_data_(true),
       stream_id_(0),
       path_(path),
       priority_(priority),
       slot_(0),
       send_stalled_by_flow_control_(false),
       send_window_size_(initial_send_window_size),
       recv_window_size_(initial_recv_window_size),
       unacked_recv_window_bytes_(0),
-      pushed_(pushed),
       response_received_(false),
       session_(session),
       delegate_(NULL),
-      send_status_(MORE_DATA_TO_SEND),
+      send_status_(
+          (type_ == SPDY_PUSH_STREAM) ?
+          NO_MORE_DATA_TO_SEND : MORE_DATA_TO_SEND),
       request_time_(base::Time::Now()),
       response_(new SpdyHeaderBlock),
       io_state_(STATE_NONE),
       response_status_(OK),
       net_log_(net_log),
       send_bytes_(0),
       recv_bytes_(0),
       domain_bound_cert_type_(CLIENT_CERT_INVALID_TYPE),
       just_completed_frame_type_(DATA),
       just_completed_frame_size_(0) {
 }
 
 SpdyStream::~SpdyStream() {
   CHECK(!in_do_loop_);
   UpdateHistograms();
 }
 
 void SpdyStream::SetDelegate(Delegate* delegate) {
   CHECK(delegate);
   delegate_ = delegate;
 
-  if (pushed_) {
+  if (type_ == SPDY_PUSH_STREAM) {
     CHECK(response_received());
     base::MessageLoop::current()->PostTask(
         FROM_HERE,
         base::Bind(&SpdyStream::PushedStreamReplayData, GetWeakPtr()));
   } else {
     continue_buffering_data_ = false;
   }
 }
 
 void SpdyStream::PushedStreamReplayData() {
@@ skipping 236 matching lines @@
   metrics_.StartStream();
 
   DCHECK(response_->empty());
   *response_ = response;  // TODO(ukai): avoid copy.
 
   recv_first_byte_time_ = base::TimeTicks::Now();
   response_time_ = base::Time::Now();
 
   // If we receive a response before we are in STATE_WAITING_FOR_RESPONSE, then
   // the server has sent the SYN_REPLY too early.
-  if (!pushed_ && io_state_ != STATE_WAITING_FOR_RESPONSE)
+  if (type_ != SPDY_PUSH_STREAM && io_state_ != STATE_WAITING_FOR_RESPONSE)
     return ERR_SPDY_PROTOCOL_ERROR;
-  if (pushed_)
+  if (type_ == SPDY_PUSH_STREAM)
     CHECK_EQ(io_state_, STATE_NONE);
   io_state_ = STATE_OPEN;
 
   // Append all the headers into the response header block.
   for (SpdyHeaderBlock::const_iterator it = response.begin();
        it != response.end(); ++it) {
     // Disallow uppercase headers.
     if (ContainsUpperAscii(it->first)) {
       session_->ResetStream(stream_id_, priority_, RST_STREAM_PROTOCOL_ERROR,
                             "Upper case characters in header: " + it->first);
@@ skipping 161 matching lines @@
   CHECK(!in_do_loop_);
   if (stream_id_ != 0) {
     session_->CloseActiveStream(stream_id_, OK);
   } else {
     session_->CloseCreatedStream(GetWeakPtr(), OK);
   }
 }
 
 int SpdyStream::SendRequestHeaders(scoped_ptr<SpdyHeaderBlock> headers,
                                    SpdySendStatus send_status) {
+  CHECK_NE(type_, SPDY_PUSH_STREAM);

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

I don't think this is right, is it?  When a request is made for a URL which can
be handled by a pushed stream, the SpdyHttpStream does not know that, does it? 
I thought it would actually call SendRequestHeaders.

EDIT: Ah, but actually looking at SpdyHttpStream shows that I'm wrong :>

   CHECK_EQ(send_status_, MORE_DATA_TO_SEND);
   CHECK(!request_);
+  CHECK(!pending_send_data_);
+  CHECK_EQ(io_state_, STATE_NONE);
   request_ = headers.Pass();
-  // Pushed streams do not send any data, and should always be
-  // idle. However, we still want to return IO_PENDING to mimic
-  // non-push behavior.
   send_status_ = send_status;
-  if (pushed_) {
-    DCHECK(is_idle());
-    DCHECK_EQ(send_status_, NO_MORE_DATA_TO_SEND);
-    DCHECK(response_received());
-    send_time_ = base::TimeTicks::Now();
-    return ERR_IO_PENDING;
-  }
-  CHECK_EQ(STATE_NONE, io_state_);
   io_state_ = STATE_GET_DOMAIN_BOUND_CERT;
   return DoLoop(OK);
 }
 
 void SpdyStream::SendStreamData(IOBuffer* data,
                                 int length,
                                 SpdySendStatus send_status) {
+  CHECK_NE(type_, SPDY_PUSH_STREAM);
   CHECK_EQ(send_status_, MORE_DATA_TO_SEND);
+  CHECK_GE(io_state_, STATE_SEND_BODY);
   CHECK(!pending_send_data_);
   pending_send_data_ = new DrainableIOBuffer(data, length);
   send_status_ = send_status;
   QueueNextDataFrame();
 }
 
 bool SpdyStream::GetSSLInfo(SSLInfo* ssl_info,
                             bool* was_npn_negotiated,
                             NextProto* protocol_negotiated) {
   return session_->GetSSLInfo(
@@ skipping 15 matching lines @@
     send_stalled_by_flow_control_ = false;
     QueueNextDataFrame();
   }
 }
 
 base::WeakPtr<SpdyStream> SpdyStream::GetWeakPtr() {
   return weak_ptr_factory_.GetWeakPtr();
 }
 
 bool SpdyStream::HasUrl() const {
-  if (pushed_)
+  if (type_ == SPDY_PUSH_STREAM)
     return response_received();
   return request_.get() != NULL;
 }
 
 GURL SpdyStream::GetUrl() const {
   DCHECK(HasUrl());
 
-  const SpdyHeaderBlock& headers = (pushed_) ? *response_ : *request_;
-  return GetUrlFromHeaderBlock(headers, GetProtocolVersion(), pushed_);
+  const SpdyHeaderBlock& headers =
+      (type_ == SPDY_PUSH_STREAM) ? *response_ : *request_;
+  return GetUrlFromHeaderBlock(headers, GetProtocolVersion(),
+                               type_ == SPDY_PUSH_STREAM);
 }
 
 void SpdyStream::OnGetDomainBoundCertComplete(int result) {
-  DCHECK_EQ(STATE_GET_DOMAIN_BOUND_CERT_COMPLETE, io_state_);
+  DCHECK_EQ(io_state_, STATE_GET_DOMAIN_BOUND_CERT_COMPLETE);
   DoLoop(result);
 }
 
 int SpdyStream::DoLoop(int result) {
   CHECK(!in_do_loop_);
   in_do_loop_ = true;
 
   do {
     State state = io_state_;
     io_state_ = STATE_NONE;
@@ skipping 64 matching lines @@
            io_state_ != STATE_OPEN);
 
   CHECK(in_do_loop_);
   in_do_loop_ = false;
 
   return result;
 }
 
 int SpdyStream::DoGetDomainBoundCert() {
   CHECK(request_.get());
+  DCHECK_NE(type_, SPDY_PUSH_STREAM);
   GURL url = GetUrl();
-  if (!session_->NeedsCredentials() || pushed_ || !url.SchemeIs("https")) {
+  if (!session_->NeedsCredentials() || !url.SchemeIs("https")) {
     // Proceed directly to sending the request headers
     io_state_ = STATE_SEND_REQUEST_HEADERS;
     return OK;
   }
 
   slot_ = session_->credential_state()->FindCredentialSlot(GetUrl());
   if (slot_ != SpdyCredentialState::kNoEntry) {
     // Proceed directly to sending the request headers
     io_state_ = STATE_SEND_REQUEST_HEADERS;
     return OK;
   }
 
   io_state_ = STATE_GET_DOMAIN_BOUND_CERT_COMPLETE;
   ServerBoundCertService* sbc_service = session_->GetServerBoundCertService();
   DCHECK(sbc_service != NULL);
   std::vector<uint8> requested_cert_types;
   requested_cert_types.push_back(CLIENT_CERT_ECDSA_SIGN);
   int rv = sbc_service->GetDomainBoundCert(
       url.GetOrigin().host(), requested_cert_types,
       &domain_bound_cert_type_, &domain_bound_private_key_, &domain_bound_cert_,
       base::Bind(&SpdyStream::OnGetDomainBoundCertComplete, GetWeakPtr()),
       &domain_bound_cert_request_handle_);
   return rv;
 }
 
 int SpdyStream::DoGetDomainBoundCertComplete(int result) {
+  DCHECK_NE(type_, SPDY_PUSH_STREAM);
   if (result != OK)
     return result;
 
   io_state_ = STATE_SEND_DOMAIN_BOUND_CERT;
   slot_ =  session_->credential_state()->SetHasCredential(GetUrl());
   return OK;
 }
 
 int SpdyStream::DoSendDomainBoundCert() {
+  CHECK(request_.get());
+  DCHECK_NE(type_, SPDY_PUSH_STREAM);
   io_state_ = STATE_SEND_DOMAIN_BOUND_CERT_COMPLETE;
-  CHECK(request_.get());
 
   std::string origin = GetUrl().GetOrigin().spec();
   DCHECK(origin[origin.length() - 1] == '/');
   origin.erase(origin.length() - 1);  // Trim trailing slash.
   scoped_ptr<SpdyFrame> frame;
   int rv = session_->CreateCredentialFrame(
       origin, domain_bound_cert_type_, domain_bound_private_key_,
       domain_bound_cert_, priority_, &frame);
   if (rv != OK) {
     DCHECK_NE(rv, ERR_IO_PENDING);
@@ skipping 10 matching lines @@
   // the state machine appropriately.
   session_->EnqueueStreamWrite(
       GetWeakPtr(), CREDENTIAL,
       scoped_ptr<SpdyBufferProducer>(
           new SimpleBufferProducer(
               scoped_ptr<SpdyBuffer>(new SpdyBuffer(frame.Pass())))));
   return ERR_IO_PENDING;
 }
 
 int SpdyStream::DoSendDomainBoundCertComplete(int result) {
+  DCHECK_NE(type_, SPDY_PUSH_STREAM);
   if (result != OK)
     return result;
 
   DCHECK_EQ(just_completed_frame_type_, CREDENTIAL);
   io_state_ = STATE_SEND_REQUEST_HEADERS;
   return OK;
 }
 
 int SpdyStream::DoSendRequestHeaders() {
+  DCHECK_NE(type_, SPDY_PUSH_STREAM);
   io_state_ = STATE_SEND_REQUEST_HEADERS_COMPLETE;
 
   session_->EnqueueStreamWrite(
       GetWeakPtr(), SYN_STREAM,
       scoped_ptr<SpdyBufferProducer>(
           new SynStreamBufferProducer(GetWeakPtr())));
   return ERR_IO_PENDING;
 }
 
 int SpdyStream::DoSendRequestHeadersComplete() {
+  DCHECK_NE(type_, SPDY_PUSH_STREAM);
   DCHECK_EQ(just_completed_frame_type_, SYN_STREAM);
   DCHECK_NE(stream_id_, 0u);
   if (!delegate_)
     return ERR_UNEXPECTED;
 
-  // We don't store the return value in |send_status_|; see comments
-  // in spdy_stream.h for OnSendRequestHeadersComplete().
-  SpdySendStatus send_status = delegate_->OnSendRequestHeadersComplete();
+  delegate_->OnSendRequestHeadersComplete();
 
-  io_state_ =
-      (send_status == MORE_DATA_TO_SEND) ?
-      STATE_SEND_BODY : STATE_WAITING_FOR_RESPONSE;
+  switch (type_) {
+    case SPDY_BIDIRECTIONAL_STREAM:
+      DCHECK_EQ(send_status_, MORE_DATA_TO_SEND);
+      io_state_ = STATE_WAITING_FOR_RESPONSE;
+      break;
+
+    case SPDY_REQUEST_RESPONSE_STREAM:
+      io_state_ =
+          (send_status_ == MORE_DATA_TO_SEND) ?
+          STATE_SEND_BODY : STATE_WAITING_FOR_RESPONSE;
+      break;
+
+    case SPDY_PUSH_STREAM:
+      // Fall through.
+    default:
+      NOTREACHED();
+      return ERR_UNEXPECTED;
+  }
 
   return OK;
 }
 
 // DoSendBody is called to send the optional body for the request.  This call
 // will also be called as each write of a chunk of the body completes.
 int SpdyStream::DoSendBody() {
+  DCHECK_NE(type_, SPDY_PUSH_STREAM);
   io_state_ = STATE_SEND_BODY_COMPLETE;
   CHECK(delegate_);
   delegate_->OnSendBody();
   return ERR_IO_PENDING;
 }
 
 int SpdyStream::DoSendBodyComplete(int result) {
+  DCHECK_NE(type_, SPDY_PUSH_STREAM);
   result = ProcessJustCompletedFrame(result, STATE_SEND_BODY_COMPLETE);
 
   if (result != OK)
     return result;
 
   delegate_->OnSendBodyComplete();
 
   io_state_ =
       (send_status_ == MORE_DATA_TO_SEND) ?
       STATE_SEND_BODY : STATE_WAITING_FOR_RESPONSE;
@@ skipping 49 matching lines @@
 
   if (!delegate_) {
     NOTREACHED();
     return ERR_UNEXPECTED;
   }
 
   return OK;
 }
 
 void SpdyStream::UpdateHistograms() {
-  // We need all timers to be filled in, otherwise metrics can be bogus.
-  if (send_time_.is_null() || recv_first_byte_time_.is_null() ||
-      recv_last_byte_time_.is_null())
+  // We need at least the receive timers to be filled in, as otherwise
+  // metrics can be bogus.
+  if (recv_first_byte_time_.is_null() || recv_last_byte_time_.is_null())
     return;
 
+  base::TimeTicks effective_send_time;
+  if (type_ == SPDY_PUSH_STREAM) {
+    // Push streams shouldn't have |send_time_| filled in.
+    DCHECK(send_time_.is_null());
+    effective_send_time = recv_first_byte_time_;
+  } else {
+    // For non-push streams, we also need |send_time_| to be filled
+    // in.
+    if (send_time_.is_null())
+      return;
+    effective_send_time = send_time_;
+  }
+
   UMA_HISTOGRAM_TIMES("Net.SpdyStreamTimeToFirstByte",
-      recv_first_byte_time_ - send_time_);
+                      recv_first_byte_time_ - effective_send_time);
   UMA_HISTOGRAM_TIMES("Net.SpdyStreamDownloadTime",
-      recv_last_byte_time_ - recv_first_byte_time_);
+                      recv_last_byte_time_ - recv_first_byte_time_);
   UMA_HISTOGRAM_TIMES("Net.SpdyStreamTime",
-      recv_last_byte_time_ - send_time_);
+                      recv_last_byte_time_ - effective_send_time);
 
   UMA_HISTOGRAM_COUNTS("Net.SpdySendBytes", send_bytes_);
   UMA_HISTOGRAM_COUNTS("Net.SpdyRecvBytes", recv_bytes_);
 }
 
 void SpdyStream::QueueNextDataFrame() {
   // Until the request has been completely sent, we cannot be sure
   // that our stream_id is correct.
   DCHECK_GT(io_state_, STATE_SEND_REQUEST_HEADERS_COMPLETE);
   CHECK_GT(stream_id_, 0u);
@@ skipping 26 matching lines @@
                    GetWeakPtr(), payload_size));
   }
 
   session_->EnqueueStreamWrite(
       GetWeakPtr(), DATA,
       scoped_ptr<SpdyBufferProducer>(
           new SimpleBufferProducer(data_buffer.Pass())));
 }
 
 }  // namespace net