[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 94 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(stream_->ReceivedInitialResponseHeaders()) {
     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) {
+int SpdyHttpStream::OnResponseHeadersUpdated(
+    const SpdyHeaderBlock& response_headers) {
   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;
   }
 
-  // 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_)) {
+  if (!SpdyHeadersToHttpResponse(
+          response_headers, stream_->GetProtocolVersion(), response_info_)) {
     // We might not have complete headers yet.
     return ERR_INCOMPLETE_SPDY_HEADERS;
   }
 
+  response_info_->response_time = stream_->response_time();
   response_headers_received_ = true;
   // 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 OK;
 }
 
 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;
 
   // Note that data may be received for a SpdyStream prior to the user calling
@@ skipping 176 matching lines @@
 bool SpdyHttpStream::IsSpdyHttpStream() const {
   return true;
 }
 
 void SpdyHttpStream::Drain(HttpNetworkSession* session) {
   Close(false);
   delete this;
 }
 
 }  // namespace net