Expose SPDY pushes in DevTools

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 <limits>
 #include <utility>
 
 #include "base/bind.h"
@@ skipping 462 matching lines @@
   CHECK_EQ(type_, SPDY_PUSH_STREAM);
   DCHECK(!delegate_);
 
   io_state_ = STATE_RESERVED_REMOTE;
   request_headers_.reset(new SpdyHeaderBlock(headers));
 }
 
 void SpdyStream::OnDataReceived(scoped_ptr<SpdyBuffer> buffer) {
   DCHECK(session_->IsStreamActive(stream_id_));
 
+  // Track our bandwidth.
+  recv_bytes_ += buffer ? buffer->GetRemainingSize() : 0;
+  recv_last_byte_time_ = base::TimeTicks::Now();
+
   // 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.
     if (buffer) {
       pending_recv_data_.push_back(std::move(buffer));
     } else {
@@ skipping 41 matching lines @@
   size_t length = buffer->GetRemainingSize();
   DCHECK_LE(length, session_->GetDataFrameMaximumPayload());
   base::WeakPtr<SpdyStream> weak_this = GetWeakPtr();
   // May close the stream.
   DecreaseRecvWindowSize(static_cast<int32_t>(length));
   if (!weak_this)
     return;
   buffer->AddConsumeCallback(
       base::Bind(&SpdyStream::OnReadBufferConsumed, GetWeakPtr()));
 
-  // Track our bandwidth.
-  recv_bytes_ += length;
-  recv_last_byte_time_ = base::TimeTicks::Now();
-
   // May close |this|.
   delegate_->OnDataReceived(std::move(buffer));
 }
 
 void SpdyStream::OnPaddingConsumed(size_t len) {
   // Decrease window size because padding bytes are received.
   // Increase window size because padding bytes are consumed (by discarding).
   // Net result: |unacked_recv_window_bytes_| increases by |len|,
   // |recv_window_size_| does not change.
   base::WeakPtr<SpdyStream> weak_this = GetWeakPtr();
@@ skipping 11 matching lines @@
         frame_type == DATA) << frame_type;
 
   int result = (frame_type == SYN_STREAM) ?
       OnRequestHeadersSent() : OnDataSent(frame_size);
   if (result == ERR_IO_PENDING) {
     // The write operation hasn't completed yet.
     return;
   }
 
   if (pending_send_status_ == NO_MORE_DATA_TO_SEND) {
-    if(io_state_ == STATE_OPEN) {
+    if (io_state_ == STATE_OPEN) {
       io_state_ = STATE_HALF_CLOSED_LOCAL;
-    } else if(io_state_ == STATE_HALF_CLOSED_REMOTE) {
+    } else if (io_state_ == STATE_HALF_CLOSED_REMOTE) {
       io_state_ = STATE_CLOSED;
     } else {
       NOTREACHED() << io_state_;
     }
   }
   // Notify delegate of write completion. Must not destroy |this|.
   CHECK(delegate_);
   {
     base::WeakPtr<SpdyStream> weak_this = GetWeakPtr();
     write_handler_guard_ = true;
@@ skipping 175 matching lines @@
   raw_received_bytes_ += received_bytes;
 }
 
 void SpdyStream::AddRawSentBytes(size_t sent_bytes) {
   raw_sent_bytes_ += sent_bytes;
 }
 
 bool SpdyStream::GetLoadTimingInfo(LoadTimingInfo* load_timing_info) const {
   if (stream_id_ == 0)
     return false;
-
-  return session_->GetLoadTimingInfo(stream_id_, load_timing_info);
+  bool result = session_->GetLoadTimingInfo(stream_id_, load_timing_info);
+  if (type_ == SPDY_PUSH_STREAM) {
+    load_timing_info->push_start = recv_first_byte_time_;
+    bool done_receiving = IsClosed() || (!pending_recv_data_.empty() &&
+                                         !pending_recv_data_.back());
+    load_timing_info->push_end =

[Bence, 2016/03/25 14:42:54]

How about this instead:
if (done_receiving) push_end = recv_last_byte_time_;

+        done_receiving ? recv_last_byte_time_ : base::TimeTicks();
+  }
+  return result;
 }
 
 GURL SpdyStream::GetUrlFromHeaders() const {
   if (!request_headers_)
     return GURL();
 
   return GetUrlFromHeaderBlock(*request_headers_, GetProtocolVersion());
 }
 
 bool SpdyStream::HasUrlFromHeaders() const {
@@ skipping 155 matching lines @@
       description = base::StringPrintf("Unknown state 0x%08X (%u)", state,
                                        state);
       break;
   }
   return description;
 }
 
 #undef STATE_CASE
 
 }  // namespace net