[SPDY] Refactor SpdyStream's handling of response headers

net/spdy/spdy_session.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_session.h"
 
 #include <algorithm>
 #include <map>
 
 #include "base/basictypes.h"
@@ skipping 1581 matching lines @@
 void SpdySession::OnSynStreamCompressed(
     size_t uncompressed_size,
     size_t compressed_size) {
   // Make sure we avoid early decimal truncation.
   int compression_pct = 100 - (100 * compressed_size) / uncompressed_size;
   UMA_HISTOGRAM_PERCENTAGE("Net.SpdySynStreamCompressionPercentage",
                            compression_pct);
 }
 
 
-bool SpdySession::Respond(const SpdyHeaderBlock& headers, SpdyStream* stream) {
+bool SpdySession::Respond(const SpdyHeaderBlock& response_headers,
+                          base::Time response_time,
+                          base::TimeTicks recv_first_byte_time,
+                          SpdyStream* stream) {
   int rv = OK;
   SpdyStreamId stream_id = stream->stream_id();
   // May invalidate |stream|.
-  rv = stream->OnResponseHeadersReceived(headers);
+  rv = stream->OnInitialResponseHeadersReceived(
+      response_headers, response_time, recv_first_byte_time);
   if (rv < 0) {
     DCHECK_NE(rv, ERR_IO_PENDING);
     CloseActiveStream(stream_id, rv);
     return false;
   }
   return true;
 }
 
 void SpdySession::OnSynStream(SpdyStreamId stream_id,
                               SpdyStreamId associated_stream_id,
                               SpdyPriority priority,
                               uint8 credential_slot,
                               bool fin,
                               bool unidirectional,
                               const SpdyHeaderBlock& headers) {
+  base::Time response_time = base::Time::Now();
+  base::TimeTicks recv_first_byte_time = base::TimeTicks::Now();
+
   if (net_log_.IsLoggingAllEvents()) {
     net_log_.AddEvent(
         NetLog::TYPE_SPDY_SESSION_PUSHED_SYN_STREAM,
         base::Bind(&NetLogSpdySynCallback,
                    &headers, fin, unidirectional,
                    stream_id, associated_stream_id));
   }
 
   // Server-initiated streams should have even sequence numbers.
   if ((stream_id & 0x1) != 0) {
@@ skipping 76 matching lines @@
                      request_priority,
                      stream_initial_send_window_size_,
                      stream_initial_recv_window_size_,
                      net_log_));
   stream->set_stream_id(stream_id);
 
   DeleteExpiredPushedStreams();
   unclaimed_pushed_streams_[url] =
       std::pair<SpdyStream*, base::TimeTicks>(stream.get(), time_func_());
 
-  stream->set_response_received();
   InsertActivatedStream(stream.Pass());
 
   ActiveStreamMap::iterator it = active_streams_.find(stream_id);
   if (it == active_streams_.end()) {
     NOTREACHED();
     return;
   }
 
   // Parse the headers.
-  if (!Respond(headers, it->second))
+  if (!Respond(headers, response_time, recv_first_byte_time, it->second))
     return;
 
   base::StatsCounter push_requests("spdy.pushed_streams");
   push_requests.Increment();
 }
 
 void SpdySession::DeleteExpiredPushedStreams() {
   if (unclaimed_pushed_streams_.empty())
     return;
 
@@ skipping 22 matching lines @@
       CloseActiveStream(stream->stream_id(), ERR_INVALID_SPDY_STREAM);
     }
   }
   next_unclaimed_push_stream_sweep_time_ = time_func_() +
       base::TimeDelta::FromSeconds(kMinPushedStreamLifetimeSeconds);
 }
 
 void SpdySession::OnSynReply(SpdyStreamId stream_id,
                              bool fin,
                              const SpdyHeaderBlock& headers) {
+  base::Time response_time = base::Time::Now();
+  base::TimeTicks recv_first_byte_time = base::TimeTicks::Now();
+
   if (net_log().IsLoggingAllEvents()) {
     net_log().AddEvent(
         NetLog::TYPE_SPDY_SESSION_SYN_REPLY,
         base::Bind(&NetLogSpdySynCallback,
                    &headers, fin, false,  // not unidirectional
                    stream_id, 0));
   }
 
   ActiveStreamMap::iterator it = active_streams_.find(stream_id);
   if (it == active_streams_.end()) {
     // NOTE:  it may just be that the stream was cancelled.
     return;
   }
 
   SpdyStream* stream = it->second;
   CHECK_EQ(stream->stream_id(), stream_id);
 
-  if (stream->response_received()) {
+  if (stream->ReceivedInitialResponseHeaders()) {
     stream->LogStreamError(ERR_SYN_REPLY_NOT_RECEIVED,
                            "Received duplicate SYN_REPLY for stream.");
     RecordProtocolErrorHistogram(PROTOCOL_ERROR_SYN_REPLY_NOT_RECEIVED);
     CloseActiveStream(stream->stream_id(), ERR_SPDY_PROTOCOL_ERROR);
     return;
   }
-  stream->set_response_received();
 
-  Respond(headers, stream);
+  Respond(headers, response_time, recv_first_byte_time, stream);
 }
 
 void SpdySession::OnHeaders(SpdyStreamId stream_id,
                             bool fin,
                             const SpdyHeaderBlock& headers) {
   if (net_log().IsLoggingAllEvents()) {
     net_log().AddEvent(
         NetLog::TYPE_SPDY_SESSION_RECV_HEADERS,
         base::Bind(&NetLogSpdySynCallback,
                    &headers, fin, /*unidirectional=*/false,
                    stream_id, 0));
   }
 
   ActiveStreamMap::iterator it = active_streams_.find(stream_id);
   if (it == active_streams_.end()) {
     // NOTE:  it may just be that the stream was cancelled.
     LOG(WARNING) << "Received HEADERS for invalid stream " << stream_id;
     return;
   }
 
   CHECK_EQ(it->second->stream_id(), stream_id);
 
-  int rv = it->second->OnHeaders(headers);
+  int rv = it->second->OnAdditionalResponseHeadersReceived(headers);
   if (rv < 0) {
     DCHECK_NE(rv, ERR_IO_PENDING);
     CloseActiveStream(stream_id, rv);
   }
 }
 
 void SpdySession::OnRstStream(SpdyStreamId stream_id,
                               SpdyRstStreamStatus status) {
   std::string description;
   net_log().AddEvent(
@@ skipping 627 matching lines @@
     if (!queue->empty()) {
       SpdyStreamId stream_id = queue->front();
       queue->pop_front();
       return stream_id;
     }
   }
   return 0;
 }
 
 }  // namespace net