Fix bug where pushed SPDY streams were never actually closed....

net/spdy/spdy_stream.cc

 // Copyright (c) 2010 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 "base/logging.h"
 #include "base/message_loop.h"
 #include "base/singleton.h"
 #include "net/spdy/spdy_session.h"
@@ skipping 11 matching lines @@
       metrics_(Singleton<BandwidthMetrics>::get()),
       response_received_(false),
       session_(session),
       delegate_(NULL),
       request_time_(base::Time::Now()),
       response_(new spdy::SpdyHeaderBlock),
       io_state_(STATE_NONE),
       response_status_(OK),
       cancelled_(false),
       send_bytes_(0),
-      recv_bytes_(0),
-      histograms_recorded_(false) {}
+      recv_bytes_(0) {
+}
 
 SpdyStream::~SpdyStream() {
   DLOG(INFO) << "Deleting SpdyStream for stream " << stream_id_;
+  UpdateHistograms();
 }
 
 void SpdyStream::SetDelegate(Delegate* delegate) {
   CHECK(delegate);
   delegate_ = delegate;
 
   if (pushed_) {
     CHECK(response_received());
     MessageLoop::current()->PostTask(
         FROM_HERE, NewRunnableMethod(this,
@@ skipping 129 matching lines @@
   LOG(INFO) << "SpdyStream: Data (" << length << " bytes) received for "
             << stream_id_;
 
   if (!delegate_ || continue_buffering_data_) {
     // 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 (length > 0) {
       IOBufferWithSize* buf = new IOBufferWithSize(length);
       memcpy(buf->data(), data, length);
       pending_buffers_.push_back(buf);
+    } else {
+      pending_buffers_.push_back(NULL);
+      metrics_.StopStream();
+      session_->CloseStream(stream_id_, net::OK);
+      // Note: |this| may be deleted after calling CloseStream.
     }
-    else
-      pending_buffers_.push_back(NULL);
     return;
   }
 
  CHECK(!closed());
 
   // If we don't have a response, then the SYN_REPLY did not come through.
   // We cannot pass data up to the caller unless the reply headers have been
   // received.
   if (!response_received()) {
     session_->CloseStream(stream_id_, ERR_SYN_REPLY_NOT_RECEIVED);
     return;
   }
 
   // A zero-length read means that the stream is being closed.
   if (!length) {
     metrics_.StopStream();
-    scoped_refptr<SpdyStream> self(this);
     session_->CloseStream(stream_id_, net::OK);
-    UpdateHistograms();
+    // Note: |this| may be deleted after calling CloseStream.
     return;
   }
 
   // Track our bandwidth.
   metrics_.RecordBytes(length);
   recv_bytes_ += length;
   recv_last_byte_time_ = base::TimeTicks::Now();
 
   if (!delegate_) {
     // It should be valid for this to happen in the server push case.
@@ skipping 194 matching lines @@
 }
 
 int SpdyStream::DoOpen(int result) {
   if (delegate_)
     delegate_->OnDataSent(result);
   io_state_ = STATE_OPEN;
   return result;
 }
 
 void SpdyStream::UpdateHistograms() {
-  if (histograms_recorded_)
-    return;
-
-  histograms_recorded_ = true;
-
   // We need all timers to be filled in, otherwise metrics can be bogus.
   if (send_time_.is_null() || recv_first_byte_time_.is_null() ||
       recv_last_byte_time_.is_null())
     return;
 
   UMA_HISTOGRAM_TIMES("Net.SpdyStreamTimeToFirstByte",
       recv_first_byte_time_ - send_time_);
   UMA_HISTOGRAM_TIMES("Net.SpdyStreamDownloadTime",
       recv_last_byte_time_ - recv_first_byte_time_);
   UMA_HISTOGRAM_TIMES("Net.SpdyStreamTime",
       recv_last_byte_time_ - send_time_);
 
   UMA_HISTOGRAM_COUNTS("Net.SpdySendBytes", send_bytes_);
   UMA_HISTOGRAM_COUNTS("Net.SpdyRecvBytes", recv_bytes_);
 }
 
 }  // namespace net