Implement server push protocol 2.

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/singleton.h"
 #include "net/spdy/spdy_session.h"
 
 namespace net {
 
 SpdyStream::SpdyStream(
     SpdySession* session, spdy::SpdyStreamId stream_id, bool pushed)
-    : stream_id_(stream_id),
+    : continue_buffering_data_(true),
+      stream_id_(stream_id),
       priority_(0),
       send_window_size_(spdy::kInitialWindowSize),
       pushed_(pushed),
       metrics_(Singleton<BandwidthMetrics>::get()),
       syn_reply_received_(false),
       session_(session),
       delegate_(NULL),
       request_time_(base::Time::Now()),
       response_(new spdy::SpdyHeaderBlock),
       response_complete_(false),
       io_state_(STATE_NONE),
       response_status_(OK),
       cancelled_(false),
       send_bytes_(0),
       recv_bytes_(0),
       histograms_recorded_(false) {}
 
 SpdyStream::~SpdyStream() {
   DLOG(INFO) << "Deleting SpdyStream for stream " << stream_id_;
 }
 
 void SpdyStream::SetDelegate(Delegate* delegate) {
   CHECK(delegate);
   delegate_ = delegate;
 
-  if (!response_->empty()) {
-    // The stream already got response.
-    delegate_->OnResponseReceived(*response_, response_time_, OK);
+  if (pushed_) {
+    CHECK(!response_->empty());
+    MessageLoop::current()->PostTask(
+        FROM_HERE, NewRunnableMethod(this,
+                                     &SpdyStream::PushedStreamReplayData));
+  } else {
+    continue_buffering_data_ = false;
   }
+}
 
+void SpdyStream::PushedStreamReplayData() {
+  if (cancelled_ || delegate_ == NULL)
+    return;
+
+  delegate_->OnResponseReceived(*response_, response_time_, OK);
+
+  continue_buffering_data_ = false;
   std::vector<scoped_refptr<IOBufferWithSize> > buffers;
   buffers.swap(pending_buffers_);
   for (size_t i = 0; i < buffers.size(); ++i) {
-    if (delegate_)
-      delegate_->OnDataReceived(buffers[i]->data(), buffers[i]->size());
+    if (delegate_){
+      if (buffers[i])
+        delegate_->OnDataReceived(buffers[i]->data(), buffers[i]->size());
+      else
+        delegate_->OnDataReceived(NULL, 0);
+    }
   }
 }
 
 void SpdyStream::DetachDelegate() {
   delegate_ = NULL;
   if (!response_complete_)
     Cancel();
 }
 
 const linked_ptr<spdy::SpdyHeaderBlock>& SpdyStream::spdy_headers() const {
@@ skipping 62 matching lines @@
   DCHECK(response_->empty());
   *response_ = response;  // TODO(ukai): avoid copy.
 
   recv_first_byte_time_ = base::TimeTicks::Now();
   response_time_ = base::Time::Now();
 
   if (io_state_ == STATE_NONE) {
     CHECK(pushed_);
     io_state_ = STATE_READ_HEADERS;
   } else if (io_state_ == STATE_READ_HEADERS_COMPLETE) {
-    // This SpdyStream could be in this state in both true and false pushed_
-    // conditions.
-    // The false pushed_ condition (client request) will always go through
-    // this state.
-    // The true pushed_condition (server push) can be in this state when the
-    // client requests an X-Associated-Content piece of content prior
-    // to when the server push happens.
+    CHECK(!pushed_);
   } else {
     // We're not expecting a response while in this state.  Error!
     rv = ERR_SPDY_PROTOCOL_ERROR;
   }
 
   rv = DoLoop(rv);
   if (delegate_)
     rv = delegate_->OnResponseReceived(*response_, response_time_, rv);
-  // if delegate_ is not yet attached, we'll return response when delegate
-  // gets attached to the stream.
+  // If delegate_ is not yet attached, we'll call OnResponseReceived after the
+  // delegate gets attached to the stream.
 
   return rv;
 }
 
 void SpdyStream::OnDataReceived(const char* data, int length) {
   DCHECK_GE(length, 0);
   LOG(INFO) << "SpdyStream: Data (" << length << " bytes) received for "
             << stream_id_;
 
-  CHECK(!response_complete_);
+  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(buf);
+    }
+    else
+      pending_buffers_.push_back(NULL);
+    return;
+  }
+
+ CHECK(!response_complete_);
 
   // 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_->empty()) {
     session_->CloseStream(stream_id_, ERR_SYN_REPLY_NOT_RECEIVED);
     return;
   }
 
   // A zero-length read means that the stream is being closed.
@@ skipping 70 matching lines @@
       return result;
   }
 
   send_time_ = base::TimeTicks::Now();
 
   int result = OK;
   if (!pushed_) {
     DCHECK_EQ(io_state_, STATE_NONE);
     io_state_ = STATE_SEND_HEADERS;
   } else {
+    // Pushed stream should not have upload data.
     DCHECK(!has_upload_data);
-    if (!response_->empty()) {
-      // We already have response headers, so we don't need to read the header.
-      // Pushed stream should not have upload data.
-      // We don't need to call DoLoop() in this state.
-      DCHECK_EQ(io_state_, STATE_OPEN);
-      return OK;
-    } else {
-      io_state_ = STATE_READ_HEADERS;
-    }
+    DCHECK(!response_->empty());
+    DCHECK_EQ(io_state_, STATE_OPEN);
+    return ERR_IO_PENDING;
   }
   return DoLoop(result);
 }
 
 int SpdyStream::DoReadResponseHeaders() {
   CHECK(!cancelled_);
 
   // The SYN_REPLY has already been received.
   if (!response_->empty()) {
     CHECK_EQ(STATE_OPEN, io_state_);
@@ skipping 176 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