Disallow multiple HEADERS frames on pushed streams.

net/spdy/spdy_http_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_http_stream.h"
 
 #include <algorithm>
 #include <list>
 #include <utility>
 
@@ skipping 24 matching lines @@
                                bool direct)
     : spdy_session_(spdy_session),
       is_reused_(spdy_session_->IsReused()),
       stream_closed_(false),
       closed_stream_status_(ERR_FAILED),
       closed_stream_id_(0),
       closed_stream_received_bytes_(0),
       closed_stream_sent_bytes_(0),
       request_info_(NULL),
       response_info_(NULL),
-      response_headers_status_(RESPONSE_HEADERS_ARE_INCOMPLETE),
+      response_headers_complete_(false),
       user_buffer_len_(0),
       request_body_buf_size_(0),
       buffered_read_callback_pending_(false),
       more_read_data_pending_(false),
       direct_(direct),
       was_alpn_negotiated_(false),
       weak_factory_(this) {
   DCHECK(spdy_session_.get());
 }
 
@@ skipping 42 matching lines @@
 }
 
 int SpdyHttpStream::ReadResponseHeaders(const CompletionCallback& callback) {
   CHECK(!callback.is_null());
   if (stream_closed_)
     return closed_stream_status_;
 
   CHECK(stream_.get());
 
   // Check if we already have the response headers. If so, return synchronously.
-  if (response_headers_status_ == RESPONSE_HEADERS_ARE_COMPLETE) {
+  if (response_headers_complete_) {
     CHECK(!stream_->IsIdle());
     return OK;
   }
 
   // Still waiting for the response, return IO_PENDING.
   CHECK(response_callback_.is_null());
   response_callback_ = callback;
   return ERR_IO_PENDING;
 }
 
@@ skipping 175 matching lines @@
 
 void SpdyHttpStream::Cancel() {
   request_callback_.Reset();
   response_callback_.Reset();
   if (stream_.get()) {
     stream_->Cancel();
     DCHECK(!stream_.get());
   }
 }
 
-void SpdyHttpStream::OnRequestHeadersSent() {
+void SpdyHttpStream::OnHeadersSent() {
   if (HasUploadData()) {
     ReadAndSendRequestBodyData();
   } else {
     MaybePostRequestCallback(OK);
   }
 }
 
-SpdyResponseHeadersStatus SpdyHttpStream::OnResponseHeadersUpdated(
+void SpdyHttpStream::OnHeadersReceived(
     const SpdyHeaderBlock& response_headers) {
-  CHECK_EQ(response_headers_status_, RESPONSE_HEADERS_ARE_INCOMPLETE);
+  DCHECK(!response_headers_complete_);
+  response_headers_complete_ = true;
 
   if (!response_info_) {
     DCHECK_EQ(stream_->type(), SPDY_PUSH_STREAM);
     push_response_info_.reset(new HttpResponseInfo);
     response_info_ = push_response_info_.get();
   }
 
-  if (!SpdyHeadersToHttpResponse(response_headers, response_info_)) {
-    // We do not have complete headers yet.
-    return RESPONSE_HEADERS_ARE_INCOMPLETE;
-  }
+  const bool headers_valid =
+      SpdyHeadersToHttpResponse(response_headers, response_info_);
+  DCHECK(headers_valid);
 
   response_info_->response_time = stream_->response_time();
-  response_headers_status_ = RESPONSE_HEADERS_ARE_COMPLETE;
   // Don't store the SSLInfo in the response here, HttpNetworkTransaction
   // will take care of that part.
   response_info_->was_alpn_negotiated = was_alpn_negotiated_;
   response_info_->request_time = stream_->GetRequestTime();
   response_info_->connection_info = HttpResponseInfo::CONNECTION_INFO_HTTP2;
   response_info_->alpn_negotiated_protocol =
       HttpResponseInfo::ConnectionInfoToString(response_info_->connection_info);
   response_info_->vary_data
       .Init(*request_info_, *response_info_->headers.get());
 
   if (!response_callback_.is_null()) {
     DoResponseCallback(OK);
   }
-
-  return RESPONSE_HEADERS_ARE_COMPLETE;
 }
 
 void SpdyHttpStream::OnDataReceived(std::unique_ptr<SpdyBuffer> buffer) {
-  CHECK_EQ(response_headers_status_, RESPONSE_HEADERS_ARE_COMPLETE);
+  DCHECK(response_headers_complete_);
 
   // 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_.get());
   DCHECK(!stream_->IsClosed() || stream_->type() == SPDY_PUSH_STREAM);
   if (buffer) {
     response_body_queue_.Enqueue(std::move(buffer));
 
     if (user_buffer_.get()) {
@@ skipping 253 matching lines @@
   details->connection_info = HttpResponseInfo::CONNECTION_INFO_HTTP2;
   return;
 }
 
 void SpdyHttpStream::SetPriority(RequestPriority priority) {
   // TODO(akalin): Plumb this through to |stream_request_| and
   // |stream_|.
 }
 
 }  // namespace net