Attn: Mike Belshe

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>
 
@@ skipping 322 matching lines @@
   // TODO(ahendrickson): This is recorded after the entire SYN_STREAM control
   // frame has been received and processed.  Move to framer?
   response_info_->response_time = response_time;
 
   if (user_callback_)
     DoCallback(status);
   return status;
 }
 
 void SpdyHttpStream::OnDataReceived(const char* data, int length) {
+  // JTL - delete this
+  if (using_sctp()) {
+    if (!using_sctp_control_stream() || stream()->syn_reply_received()) {
+      printf("SpdyHttpStream::OnDataReceived: entered on stream %d "
+             "(length = %d)\n",
+             stream()->stream_id(), length);
+    } else {
+      printf("SpdyHttpStream::OnDataReceived: entered on stream %d, with "
+             "syn_reply_received_ = false (length = %d)\n",
+              stream()->stream_id(), length);
+    }
+  }
   // 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.
-  DCHECK(response_headers_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_headers_received to be true.
+  if ( !(using_sctp() && using_sctp_control_stream()))
+    DCHECK(response_headers_received_);
 
   // 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_->closed() || stream_->pushed());
   if (length > 0) {
     // Save the received data.
     IOBufferWithSize* io_buffer = new IOBufferWithSize(length);
     memcpy(io_buffer->data(), data, length);
     response_body_.push_back(make_scoped_refptr(io_buffer));
@@ skipping 18 matching lines @@
     // We need to complete any pending buffered read now.
     invoked_callback = DoBufferedReadCallback();
   }
   if (!invoked_callback && user_callback_)
     DoCallback(status);
 }
 
 void SpdyHttpStream::ScheduleBufferedReadCallback() {
   // If there is already a scheduled DoBufferedReadCallback, don't issue
   // another one.  Mark that we have received more data and return.
+  if (using_sctp() && using_sctp_control_stream() &&
+      !stream()->syn_reply_received()) {
+    printf("SpdyHttpStream::ScheduleBufferedReadCallback: SYN_REPLY is "
+           "*** pending *** on stream %d\n", stream()->stream_id());  // JTL
+  }
   if (buffered_read_callback_pending_) {
     more_read_data_pending_ = true;
     return;
   }
 
   more_read_data_pending_ = false;
   buffered_read_callback_pending_ = true;
   const int kBufferTimeMs = 1;
   MessageLoop::current()->PostDelayedTask(FROM_HERE, read_callback_factory_.
       NewRunnableMethod(&SpdyHttpStream::DoBufferedReadCallback),
@@ skipping 66 matching lines @@
     SSLCertRequestInfo* cert_request_info) {
   DCHECK(stream_);
   stream_->GetSSLCertRequestInfo(cert_request_info);
 }
 
 bool SpdyHttpStream::IsSpdyHttpStream() const {
   return true;
 }
 
 }  // namespace net