[SPDY] Refactor SpdyStream's handling of response headers

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 "base/bind.h"
@@ skipping 15 matching lines @@
 namespace net {
 
 SpdyHttpStream::SpdyHttpStream(SpdySession* spdy_session, bool direct)
     : weak_factory_(this),
       spdy_session_(spdy_session),
       stream_closed_(false),
       closed_stream_status_(ERR_FAILED),
       closed_stream_id_(0),
       request_info_(NULL),
       response_info_(NULL),
-      response_headers_received_(false),
+      response_headers_status_(RESPONSE_HEADERS_ARE_INCOMPLETE),
       user_buffer_len_(0),
       request_body_buf_size_(0),
       buffered_read_callback_pending_(false),
       more_read_data_pending_(false),
       direct_(direct) {
   DCHECK(spdy_session_);
 }
 
 SpdyHttpStream::~SpdyHttpStream() {
   if (stream_.get()) {
@@ skipping 52 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(stream_->response_received()) {
+  if (response_headers_status_ == RESPONSE_HEADERS_ARE_COMPLETE) {
     CHECK(stream_->is_idle());
     return OK;
   }
 
   // Still waiting for the response, return IO_PENDING.
   CHECK(callback_.is_null());
   callback_ = callback;
   return ERR_IO_PENDING;
 }
 
@@ skipping 165 matching lines @@
 void SpdyHttpStream::OnRequestHeadersSent() {
   if (!callback_.is_null())
     DoCallback(OK);
 
   // TODO(akalin): Do this immediately after sending the request
   // headers.
   if (HasUploadData())
     ReadAndSendRequestBodyData();
 }
 
-int SpdyHttpStream::OnResponseHeadersReceived(const SpdyHeaderBlock& response,
-                                              base::Time response_time,
-                                              int status) {
+SpdyResponseHeadersStatus SpdyHttpStream::OnResponseHeadersUpdated(
+    const SpdyHeaderBlock& response_headers) {
+  CHECK_EQ(response_headers_status_, RESPONSE_HEADERS_ARE_INCOMPLETE);
+
   if (!response_info_) {
     DCHECK_EQ(stream_->type(), SPDY_PUSH_STREAM);
     push_response_info_.reset(new HttpResponseInfo);
     response_info_ = push_response_info_.get();
   }
 
-  // If the response is already received, these headers are too late.
-  if (response_headers_received_) {
-    LOG(WARNING) << "SpdyHttpStream headers received after response started.";
-    return OK;
+  if (!SpdyHeadersToHttpResponse(
+          response_headers, stream_->GetProtocolVersion(), response_info_)) {
+    // We do not have complete headers yet.
+    return RESPONSE_HEADERS_ARE_INCOMPLETE;
   }
 
-  // TODO(mbelshe): This is the time of all headers received, not just time
-  // to first byte.
-  response_info_->response_time = base::Time::Now();
-
-  if (!SpdyHeadersToHttpResponse(response, stream_->GetProtocolVersion(),
-                                 response_info_)) {
-    // We might not have complete headers yet.
-    return ERR_INCOMPLETE_SPDY_HEADERS;
-  }
-
-  response_headers_received_ = true;
+  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.
   SSLInfo ssl_info;
   NextProto protocol_negotiated = kProtoUnknown;
   stream_->GetSSLInfo(&ssl_info,
                       &response_info_->was_npn_negotiated,
                       &protocol_negotiated);
   response_info_->npn_negotiated_protocol =
       SSLClientSocket::NextProtoToString(protocol_negotiated);
   response_info_->request_time = stream_->GetRequestTime();
   switch (spdy_session_->GetProtocolVersion()) {
     case SPDY2:
       response_info_->connection_info = HttpResponseInfo::CONNECTION_INFO_SPDY2;
       break;
     case SPDY3:
       response_info_->connection_info = HttpResponseInfo::CONNECTION_INFO_SPDY3;
       break;
     case SPDY4:
       response_info_->connection_info = HttpResponseInfo::CONNECTION_INFO_SPDY4;
       break;
     default:
       NOTREACHED();
   }
   response_info_->vary_data
       .Init(*request_info_, *response_info_->headers.get());
-  // 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 (!callback_.is_null())
-    DoCallback(status);
+    DoCallback(OK);
 
-  return status;
+  return RESPONSE_HEADERS_ARE_COMPLETE;
 }
 
-int SpdyHttpStream::OnDataReceived(scoped_ptr<SpdyBuffer> buffer) {
-  // 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.
-  if (!response_headers_received_)
-    return ERR_INCOMPLETE_SPDY_HEADERS;
+void SpdyHttpStream::OnDataReceived(scoped_ptr<SpdyBuffer> buffer) {
+  CHECK_EQ(response_headers_status_, RESPONSE_HEADERS_ARE_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_->closed() || stream_->type() == SPDY_PUSH_STREAM);
   if (buffer) {
     response_body_queue_.Enqueue(buffer.Pass());
 
     if (user_buffer_.get()) {
       // Handing small chunks of data to the caller creates measurable overhead.
       // We buffer data in short time-spans and send a single read notification.
       ScheduleBufferedReadCallback();
     }
   }
-  return OK;
 }
 
 void SpdyHttpStream::OnDataSent() {
   request_body_buf_size_ = 0;
   ReadAndSendRequestBodyData();
 }
 
 void SpdyHttpStream::OnClose(int status) {
   if (stream_.get()) {
     stream_closed_ = true;
@@ skipping 152 matching lines @@
 bool SpdyHttpStream::IsSpdyHttpStream() const {
   return true;
 }
 
 void SpdyHttpStream::Drain(HttpNetworkSession* session) {
   Close(false);
   delete this;
 }
 
 }  // namespace net