Introduce STATE_RESERVED_REMOTE. No behavioral changes

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 "base/bind.h"
 #include "base/compiler_specific.h"
 #include "base/logging.h"
 #include "base/message_loop/message_loop.h"
@@ skipping 104 matching lines @@
 SpdyStream::~SpdyStream() {
   CHECK(!write_handler_guard_);
   UpdateHistograms();
 }
 
 void SpdyStream::SetDelegate(Delegate* delegate) {
   CHECK(!delegate_);
   CHECK(delegate);
   delegate_ = delegate;
 
+  // TODO(baranovich): allow STATE_RESERVED_REMOTE when push promises will be
+  // implemented.
   CHECK(io_state_ == STATE_IDLE ||
         io_state_ == STATE_HALF_CLOSED_LOCAL_UNCLAIMED);
 
   if (io_state_ == STATE_HALF_CLOSED_LOCAL_UNCLAIMED) {
     DCHECK_EQ(type_, SPDY_PUSH_STREAM);
     base::MessageLoop::current()->PostTask(
         FROM_HERE,
         base::Bind(&SpdyStream::PushedStreamReplay, GetWeakPtr()));
   }
 }
@@ skipping 275 matching lines @@
         session_->ResetStream(stream_id_, RST_STREAM_PROTOCOL_ERROR,
                               "Response received before request sent");
         return ERR_SPDY_PROTOCOL_ERROR;
       }
       break;
 
     case SPDY_PUSH_STREAM:
       // Push streams transition to a locally half-closed state upon headers.
       // We must continue to buffer data while waiting for a call to
       // SetDelegate() (which may not ever happen).
-      // TODO(jgraettinger): When PUSH_PROMISE is added, Handle RESERVED_REMOTE
-      // cases here depending on whether the delegate is already set.
-      CHECK_EQ(io_state_, STATE_IDLE);
+      // TODO(baranovich): For HTTP 2 push streams, delegate may be set before
+      // receiving response headers when PUSH_PROMISE will be implemented.
+      // TODO(baranovich): In HTTP 2 additional HEADERS frames are not allowed.
+      // Set |response_headers_status_| to RESPONSE_HEADERS_ARE_COMPLETE.

[Johnny, 2014/06/09 18:44:16]

Current behavior is that we'll accept & merge headers without question until a
delegate is set, and a push stream will have response_headers_status_ set to
RESPONSE_HEADERS_ARE_COMPLETE only after a delegate has been set and the
delegate's OnResponseHeadersUpdated() indicated that all response headers were
received.

The problem with trying to set RESPONSE_HEADERS_ARE_COMPLETE beforehand is that
we don't know what kind of delegate will eventually arrive, and we don't know
what "complete" means in the stream context. That's up to the delegate.

+      CHECK_EQ(io_state_, STATE_RESERVED_REMOTE);
       DCHECK(!delegate_);
       io_state_ = STATE_HALF_CLOSED_LOCAL_UNCLAIMED;
       break;
   }
 
   metrics_.StartStream();
 
   DCHECK_NE(io_state_, STATE_IDLE);
 
   response_time_ = response_time;
@@ skipping 11 matching lines @@
   } else if (type_ == SPDY_PUSH_STREAM &&
              response_headers_status_ == RESPONSE_HEADERS_ARE_COMPLETE) {
     session_->ResetStream(
         stream_id_, RST_STREAM_PROTOCOL_ERROR,
         "Additional headers received for push stream");
     return ERR_SPDY_PROTOCOL_ERROR;
   }
   return MergeWithResponseHeaders(additional_response_headers);
 }
 
+int SpdyStream::OnPushPromiseHeadersReceived(const SpdyHeaderBlock& headers) {
+  CHECK(!request_headers_.get());
+  CHECK_EQ(io_state_, STATE_IDLE);
+  CHECK_EQ(type_, SPDY_PUSH_STREAM);
+  DCHECK(!delegate_);
+
+  io_state_ = STATE_RESERVED_REMOTE;
+  request_headers_.reset(new SpdyHeaderBlock(headers));
+  return OK;
+}
+
 void SpdyStream::OnDataReceived(scoped_ptr<SpdyBuffer> buffer) {
   DCHECK(session_->IsStreamActive(stream_id_));
 
   // If we're still buffering data for a push stream, we will do the
   // check for data received with incomplete headers in
   // PushedStreamReplayData().
   if (io_state_ == STATE_HALF_CLOSED_LOCAL_UNCLAIMED) {
     DCHECK_EQ(type_, SPDY_PUSH_STREAM);
     // 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.
@@ skipping 259 matching lines @@
 }
 
 bool SpdyStream::GetLoadTimingInfo(LoadTimingInfo* load_timing_info) const {
   if (stream_id_ == 0)
     return false;
 
   return session_->GetLoadTimingInfo(stream_id_, load_timing_info);
 }
 
 GURL SpdyStream::GetUrlFromHeaders() const {
-  if (type_ != SPDY_PUSH_STREAM && !request_headers_)
+  if (!request_headers_)
     return GURL();
 
-  const SpdyHeaderBlock& headers =
-      (type_ == SPDY_PUSH_STREAM) ? response_headers_ : *request_headers_;
-  return GetUrlFromHeaderBlock(headers, GetProtocolVersion(),
-                               type_ == SPDY_PUSH_STREAM);
+  return GetUrlFromHeaderBlock(
+      *request_headers_, GetProtocolVersion(), type_ == SPDY_PUSH_STREAM);
 }
 
 bool SpdyStream::HasUrlFromHeaders() const {
   return !GetUrlFromHeaders().is_empty();
 }
 
 void SpdyStream::UpdateHistograms() {
   // 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())
@@ skipping 139 matching lines @@
       description = base::StringPrintf("Unknown state 0x%08X (%u)", state,
                                        state);
       break;
   }
   return description;
 }
 
 #undef STATE_CASE
 
 }  // namespace net