Attn: Mike Belshe

net/spdy/spdy_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_stream.h"
 
 #include "base/logging.h"
 #include "base/message_loop.h"
 #include "base/values.h"
 #include "net/spdy/spdy_session.h"
@@ skipping 33 matching lines @@
       priority_(0),
       stalled_by_flow_control_(false),
       send_window_size_(spdy::kSpdyStreamInitialWindowSize),
       recv_window_size_(spdy::kSpdyStreamInitialWindowSize),
       pushed_(pushed),
       response_received_(false),
       session_(session),
       delegate_(NULL),
       request_time_(base::Time::Now()),
       response_(new spdy::SpdyHeaderBlock),
+      syn_reply_received_(false),
+      metrics_started_(false),
+      close_pending_(false),
       io_state_(STATE_NONE),
       response_status_(OK),
       cancelled_(false),
       has_upload_data_(false),
       net_log_(net_log),
       send_bytes_(0),
       recv_bytes_(0) {
 }
 
 SpdyStream::~SpdyStream() {
@@ skipping 159 matching lines @@
 }
 
 base::Time SpdyStream::GetRequestTime() const {
   return request_time_;
 }
 
 void SpdyStream::SetRequestTime(base::Time t) {
   request_time_ = t;
 }
 
+bool SpdyStream::using_sctp() {
+  return session_->using_sctp();
+}
+
+bool SpdyStream::using_sctp_control_stream() {
+  return session_->using_sctp_control_stream();
+}
+
 int SpdyStream::OnResponseReceived(const spdy::SpdyHeaderBlock& response) {
   int rv = OK;
 
-  metrics_.StartStream();
+  // We need to avoid starting metrics a second time.  If we are using SCTP
+  // with a single dictionary, and the SYN_REPLY was delayed or lost, we may
+  // have already started metrics when the first DATA frame arrived.
+  if ( !(using_sctp()                &&
+         using_sctp_control_stream() &&
+         metrics_started())
+     ) {
+    set_metrics_started();
+    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)
@@ skipping 32 matching lines @@
     // ERR_INCOMPLETE_SPDY_HEADERS means that we are waiting for more
     // headers before the response header block is complete.
     if (rv == ERR_INCOMPLETE_SPDY_HEADERS)
       rv = OK;
   }
   return rv;
 }
 
 void SpdyStream::OnDataReceived(const char* data, int length) {
   DCHECK_GE(length, 0);
+  // TODO(jtl): revisit this
+  // We need to start metrics here if we are using SCTP without multiple
+  // dictionaries, the SYN_REPLY has not yet arrived and metrics have not yet
+  // been started.
+  if (using_sctp()                &&
+      using_sctp_control_stream() &&
+      !syn_reply_received()       &&
+      !metrics_started()) {
+    set_metrics_started();
+    metrics_.StartStream();
+  }
 
   // If we don't have a response, then the SYN_REPLY did not come through.
   // We cannot pass data up to the caller unless the reply headers have been
   // received.
-  if (!response_received()) {
+  // Exception - when using SCTP with a single dictionary, all SPDY CONTROL
+  // frames are sent on SCTP stream 0, while all SPDY DATA frames are sent on
+  // SCTP stream n > 0.  This means that data can arrive before a SYN_REPLY,
+  // due to reordering or loss.  In this case we can't require response_received
+  // to be true.
+  if (!response_received() &&
+      !(using_sctp() && using_sctp_control_stream())) {
+    printf("SpdyStream::OnDataReceived: closing stream %d\n", stream_id_);
     session_->CloseStream(stream_id_, ERR_SYN_REPLY_NOT_RECEIVED);
     return;
   }
 
   if (!delegate_ || continue_buffering_data_) {
     // It should be valid for this to happen in the server push case.
     // We'll return received data when delegate gets attached to the stream.
     if (length > 0) {
       IOBufferWithSize* buf = new IOBufferWithSize(length);
       memcpy(buf->data(), data, length);
       pending_buffers_.push_back(make_scoped_refptr(buf));
     } else {
       pending_buffers_.push_back(NULL);
       metrics_.StopStream();
       // Note: we leave the stream open in the session until the stream
       //       is claimed.
     }
     return;
   }
 
   CHECK(!closed());
 
   // A zero-length read means that the stream is being closed.
-  if (!length) {
+  // Exception - if using SCTP and sending all SPDY control framed on SCTP
+  // stream 0, we can't close the stream if we haven't received the SYN_REPLY
+  // yet.
+  if (!length && using_sctp() && using_sctp_control_stream() &&
+      !syn_reply_received()) {
+    printf("SpdyStream::OnDataReceived: marking stream %d as ** close_pending "
+           "*** because !length.\n", stream_id_);
+    set_close_pending();  // mark stream for closure once SYN_REPLY arrives.
+    return;
+  } else if (!length) {
     metrics_.StopStream();
+    printf("SpdyStream::OnDataReceived: closing stream %d because !length.\n",
+           stream_id_);
     session_->CloseStream(stream_id_, net::OK);
     // Note: |this| may be deleted after calling CloseStream.
     return;
   }
 
   if (session_->flow_control())
     DecreaseRecvWindowSize(length);
 
   // Track our bandwidth.
   metrics_.RecordBytes(length);
@@ skipping 261 matching lines @@
   UMA_HISTOGRAM_TIMES("Net.SpdyStreamDownloadTime",
       recv_last_byte_time_ - recv_first_byte_time_);
   UMA_HISTOGRAM_TIMES("Net.SpdyStreamTime",
       recv_last_byte_time_ - send_time_);
 
   UMA_HISTOGRAM_COUNTS("Net.SpdySendBytes", send_bytes_);
   UMA_HISTOGRAM_COUNTS("Net.SpdyRecvBytes", recv_bytes_);
 }
 
 }  // namespace net