Convert implicit scoped_refptr constructor calls to explicit ones, part 2

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 "base/values.h"
@@ skipping 42 matching lines @@
       delegate_(NULL),
       request_time_(base::Time::Now()),
       response_(new spdy::SpdyHeaderBlock),
       io_state_(STATE_NONE),
       response_status_(OK),
       cancelled_(false),
       has_upload_data_(false),
       net_log_(net_log),
       send_bytes_(0),
       recv_bytes_(0) {
-  net_log_.BeginEvent(NetLog::TYPE_SPDY_STREAM,
-                      new NetLogIntegerParameter("stream_id", stream_id_));
+  net_log_.BeginEvent(
+      NetLog::TYPE_SPDY_STREAM,
+      make_scoped_refptr(new NetLogIntegerParameter("stream_id", stream_id_)));
 }
 
 SpdyStream::~SpdyStream() {
   UpdateHistograms();
   net_log_.EndEvent(NetLog::TYPE_SPDY_STREAM, NULL);
 }
 
 void SpdyStream::SetDelegate(Delegate* delegate) {
   CHECK(delegate);
   delegate_ = delegate;
@@ skipping 66 matching lines @@
     LOG(WARNING) << "Received WINDOW_UPDATE [delta:" << delta_window_size
                  << "] for stream " << stream_id_
                  << " overflows send_window_size_ [current:"
                  << send_window_size_ << "]";
     session_->ResetStream(stream_id_, spdy::FLOW_CONTROL_ERROR);
     return;
   }
 
   send_window_size_ = new_window_size;
 
-  net_log_.AddEvent(NetLog::TYPE_SPDY_STREAM_SEND_WINDOW_UPDATE,
-                    new NetLogSpdyStreamWindowUpdateParameter(stream_id_,
-                        delta_window_size, send_window_size_));
+  net_log_.AddEvent(
+      NetLog::TYPE_SPDY_STREAM_SEND_WINDOW_UPDATE,
+      make_scoped_refptr(new NetLogSpdyStreamWindowUpdateParameter(
+          stream_id_, delta_window_size, send_window_size_)));
   if (stalled_by_flow_control_) {
     stalled_by_flow_control_ = false;
     io_state_ = STATE_SEND_BODY;
     DoLoop(OK);
   }
 }
 
 void SpdyStream::DecreaseSendWindowSize(int delta_window_size) {
   // we only call this method when sending a frame, therefore
   // |delta_window_size| should be within the valid frame size range.
   DCHECK_GE(delta_window_size, 1);
   DCHECK_LE(delta_window_size, kMaxSpdyFrameChunkSize);
 
   // |send_window_size_| should have been at least |delta_window_size| for
   // this call to happen.
   DCHECK_GE(send_window_size_, delta_window_size);
 
   send_window_size_ -= delta_window_size;
 
-  net_log_.AddEvent(NetLog::TYPE_SPDY_STREAM_SEND_WINDOW_UPDATE,
-                    new NetLogSpdyStreamWindowUpdateParameter(stream_id_,
-                        -delta_window_size, send_window_size_));
+  net_log_.AddEvent(
+      NetLog::TYPE_SPDY_STREAM_SEND_WINDOW_UPDATE,
+      make_scoped_refptr(new NetLogSpdyStreamWindowUpdateParameter(
+          stream_id_, -delta_window_size, send_window_size_)));
 }
 
 void SpdyStream::IncreaseRecvWindowSize(int delta_window_size) {
   DCHECK_GE(delta_window_size, 1);
   // By the time a read is isued, stream may become inactive.
   if (!session_->IsStreamActive(stream_id_))
     return;
   int new_window_size = recv_window_size_ + delta_window_size;
   if (recv_window_size_ > 0)
     DCHECK(new_window_size > 0);
 
   recv_window_size_ = new_window_size;
-  net_log_.AddEvent(NetLog::TYPE_SPDY_STREAM_RECV_WINDOW_UPDATE,
-                    new NetLogSpdyStreamWindowUpdateParameter(stream_id_,
-                        delta_window_size, recv_window_size_));
+  net_log_.AddEvent(
+      NetLog::TYPE_SPDY_STREAM_RECV_WINDOW_UPDATE,
+      make_scoped_refptr(new NetLogSpdyStreamWindowUpdateParameter(
+          stream_id_, delta_window_size, recv_window_size_)));
   session_->SendWindowUpdate(stream_id_, delta_window_size);
 }
 
 void SpdyStream::DecreaseRecvWindowSize(int delta_window_size) {
   DCHECK_GE(delta_window_size, 1);
 
   recv_window_size_ -= delta_window_size;
-  net_log_.AddEvent(NetLog::TYPE_SPDY_STREAM_RECV_WINDOW_UPDATE,
-                    new NetLogSpdyStreamWindowUpdateParameter(stream_id_,
-                        -delta_window_size, recv_window_size_));
+  net_log_.AddEvent(
+      NetLog::TYPE_SPDY_STREAM_RECV_WINDOW_UPDATE,
+      make_scoped_refptr(new NetLogSpdyStreamWindowUpdateParameter(
+          stream_id_, -delta_window_size, recv_window_size_)));
 
   // Since we never decrease the initial window size, we should never hit
   // a negative |recv_window_size_|, if we do, it's a flow-control violation.
   if (recv_window_size_ < 0)
     session_->ResetStream(stream_id_, spdy::FLOW_CONTROL_ERROR);
 }
 
 int SpdyStream::GetPeerAddress(AddressList* address) const {
   return session_->GetPeerAddress(address);
 }
@@ skipping 39 matching lines @@
 
 void SpdyStream::OnDataReceived(const char* data, int length) {
   DCHECK_GE(length, 0);
 
   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);
+      pending_buffers_.push_back(make_scoped_refptr(buf));
     } else {
       pending_buffers_.push_back(NULL);
       metrics_.StopStream();
       // Note: we leave the stream open in the session until the stream
       //       is claimed.
     }
     return;
   }
 
  CHECK(!closed());
@@ skipping 20 matching lines @@
   // 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.
     // We'll return received data when delegate gets attached to the stream.
     IOBufferWithSize* buf = new IOBufferWithSize(length);
     memcpy(buf->data(), data, length);
-    pending_buffers_.push_back(buf);
+    pending_buffers_.push_back(make_scoped_refptr(buf));
     return;
   }
 
   delegate_->OnDataReceived(data, length);
 }
 
 // This function is only called when an entire frame is written.
 void SpdyStream::OnWriteComplete(int bytes) {
   DCHECK_LE(0, bytes);
   send_bytes_ += bytes;
@@ skipping 193 matching lines @@
   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