Convert implicit scoped_refptr constructor calls to explicit ones, part 2

net/spdy/spdy_session.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_session.h"
 
 #include "base/basictypes.h"
 #include "base/linked_ptr.h"
 #include "base/logging.h"
 #include "base/message_loop.h"
@@ skipping 237 matching lines @@
       streams_abandoned_count_(0),
       frames_received_(0),
       sent_settings_(false),
       received_settings_(false),
       initial_send_window_size_(spdy::kInitialWindowSize),
       initial_recv_window_size_(spdy::kInitialWindowSize),
       net_log_(BoundNetLog::Make(net_log, NetLog::SOURCE_SPDY_SESSION)) {
   DCHECK(HttpStreamFactory::spdy_enabled());
   net_log_.BeginEvent(
       NetLog::TYPE_SPDY_SESSION,
-      new NetLogSpdySessionParameter(host_port_proxy_pair_));
+      make_scoped_refptr(
+          new NetLogSpdySessionParameter(host_port_proxy_pair_)));
 
   // TODO(mbelshe): consider randomization of the stream_hi_water_mark.
 
   spdy_framer_.set_visitor(this);
 
   SendSettings();
 }
 
 SpdySession::~SpdySession() {
   state_ = CLOSED;
@@ skipping 187 matching lines @@
           flags, false, headers.get()));
   QueueFrame(syn_frame.get(), priority, stream);
 
   static base::StatsCounter spdy_requests("spdy.requests");
   spdy_requests.Increment();
   streams_initiated_count_++;
 
   if (net_log().IsLoggingAllEvents()) {
     net_log().AddEvent(
         NetLog::TYPE_SPDY_SESSION_SYN_STREAM,
-        new NetLogSpdySynParameter(headers, flags, stream_id));
+        make_scoped_refptr(
+            new NetLogSpdySynParameter(headers, flags, stream_id)));
   }
 
   return ERR_IO_PENDING;
 }
 
 int SpdySession::WriteStreamData(spdy::SpdyStreamId stream_id,
                                  net::IOBuffer* data, int len,
                                  spdy::SpdyDataFlags flags) {
   // Find our stream
   DCHECK(IsStreamActive(stream_id));
@@ skipping 10 matching lines @@
   // Obey send window size of the stream if flow control is enabled.
   if (use_flow_control_) {
     if (stream->send_window_size() <= 0) {
       // Because we queue frames onto the session, it is possible that
       // a stream was not flow controlled at the time it attempted the
       // write, but when we go to fulfill the write, it is now flow
       // controlled.  This is why we need the session to mark the stream
       // as stalled - because only the session knows for sure when the
       // stall occurs.
       stream->set_stalled_by_flow_control(true);
-      net_log().AddEvent(NetLog::TYPE_SPDY_SESSION_STALLED_ON_SEND_WINDOW,
-                         new NetLogIntegerParameter("stream_id", stream_id));
+      net_log().AddEvent(
+          NetLog::TYPE_SPDY_SESSION_STALLED_ON_SEND_WINDOW,
+          make_scoped_refptr(
+              new NetLogIntegerParameter("stream_id", stream_id)));
       return ERR_IO_PENDING;
     }
     int new_len = std::min(len, stream->send_window_size());
     if (new_len < len) {
       len = new_len;
       flags = static_cast<spdy::SpdyDataFlags>(flags & ~spdy::DATA_FLAG_FIN);
     }
     stream->DecreaseSendWindowSize(len);
   }
 
-  if (net_log().IsLoggingAllEvents())
-    net_log().AddEvent(NetLog::TYPE_SPDY_SESSION_SEND_DATA,
-                       new NetLogSpdyDataParameter(stream_id, len, flags));
+  if (net_log().IsLoggingAllEvents()) {
+    net_log().AddEvent(
+        NetLog::TYPE_SPDY_SESSION_SEND_DATA,
+        make_scoped_refptr(new NetLogSpdyDataParameter(stream_id, len, flags)));
+  }
 
   // TODO(mbelshe): reduce memory copies here.
   scoped_ptr<spdy::SpdyDataFrame> frame(
       spdy_framer_.CreateDataFrame(stream_id, data->data(), len, flags));
   QueueFrame(frame.get(), stream->priority(), stream);
   return ERR_IO_PENDING;
 }
 
 void SpdySession::CloseStream(spdy::SpdyStreamId stream_id, int status) {
   // TODO(mbelshe): We should send a RST_STREAM control frame here
   //                so that the server can cancel a large send.
 
   DeleteStream(stream_id, status);
 }
 
 void SpdySession::ResetStream(
     spdy::SpdyStreamId stream_id, spdy::SpdyStatusCodes status) {
 
   net_log().AddEvent(
       NetLog::TYPE_SPDY_SESSION_SEND_RST_STREAM,
-      new NetLogSpdyRstParameter(stream_id, status));
+      make_scoped_refptr(new NetLogSpdyRstParameter(stream_id, status)));
 
   scoped_ptr<spdy::SpdyRstStreamControlFrame> rst_frame(
       spdy_framer_.CreateRstStream(stream_id, status));
 
   // Default to lowest priority unless we know otherwise.
   int priority = 3;
   if(IsStreamActive(stream_id)) {
     scoped_refptr<SpdyStream> stream = active_streams_[stream_id];
     priority = stream->priority();
   }
@@ skipping 279 matching lines @@
 
   WriteSocketLater();
 }
 
 void SpdySession::CloseSessionOnError(net::Error err, bool remove_from_pool) {
   // Closing all streams can have a side-effect of dropping the last reference
   // to |this|.  Hold a reference through this function.
   scoped_refptr<SpdySession> self(this);
 
   DCHECK_LT(err, OK);
-  net_log_.AddEvent(NetLog::TYPE_SPDY_SESSION_CLOSE,
-                    new NetLogIntegerParameter("status", err));
+  net_log_.AddEvent(
+      NetLog::TYPE_SPDY_SESSION_CLOSE,
+      make_scoped_refptr(new NetLogIntegerParameter("status", err)));
 
   // Don't close twice.  This can occur because we can have both
   // a read and a write outstanding, and each can complete with
   // an error.
   if (state_ != CLOSED) {
     state_ = CLOSED;
     error_ = err;
     if (remove_from_pool)
       RemoveFromPool();
     CloseAllStreams(err);
@@ skipping 61 matching lines @@
   // If this is an active stream, call the callback.
   const scoped_refptr<SpdyStream> stream(it2->second);
   active_streams_.erase(it2);
   if (stream)
     stream->OnClose(status);
   ProcessPendingCreateStreams();
 }
 
 void SpdySession::RemoveFromPool() {
   if (spdy_session_pool_) {
-    spdy_session_pool_->Remove(this);
+    spdy_session_pool_->Remove(make_scoped_refptr(this));
     spdy_session_pool_ = NULL;
   }
 }
 
 scoped_refptr<SpdyStream> SpdySession::GetActivePushStream(
     const std::string& path) {
   static base::StatsCounter used_push_streams("spdy.claimed_push_streams");
 
   PushedStreamMap::iterator it = unclaimed_pushed_streams_.find(path);
   if (it != unclaimed_pushed_streams_.end()) {
@@ skipping 30 matching lines @@
   return false;
 }
 
 void SpdySession::OnError(spdy::SpdyFramer* framer) {
   CloseSessionOnError(net::ERR_SPDY_PROTOCOL_ERROR, true);
 }
 
 void SpdySession::OnStreamFrameData(spdy::SpdyStreamId stream_id,
                                     const char* data,
                                     size_t len) {
-  if (net_log().IsLoggingAllEvents())
-    net_log().AddEvent(NetLog::TYPE_SPDY_SESSION_RECV_DATA,
-        new NetLogSpdyDataParameter(stream_id, len, spdy::SpdyDataFlags()));
+  if (net_log().IsLoggingAllEvents()) {
+    net_log().AddEvent(
+        NetLog::TYPE_SPDY_SESSION_RECV_DATA,
+        make_scoped_refptr(new NetLogSpdyDataParameter(
+            stream_id, len, spdy::SpdyDataFlags())));
+  }
 
   if (!IsStreamActive(stream_id)) {
     // NOTE:  it may just be that the stream was cancelled.
     LOG(WARNING) << "Received data frame for invalid stream " << stream_id;
     return;
   }
 
   scoped_refptr<SpdyStream> stream = active_streams_[stream_id];
   stream->OnDataReceived(data, len);
 }
@@ skipping 13 matching lines @@
 }
 
 void SpdySession::OnSyn(const spdy::SpdySynStreamControlFrame& frame,
                         const linked_ptr<spdy::SpdyHeaderBlock>& headers) {
   spdy::SpdyStreamId stream_id = frame.stream_id();
   spdy::SpdyStreamId associated_stream_id = frame.associated_stream_id();
 
   if (net_log_.IsLoggingAllEvents()) {
     net_log_.AddEvent(
         NetLog::TYPE_SPDY_SESSION_PUSHED_SYN_STREAM,
-        new NetLogSpdySynParameter(
+        make_scoped_refptr(new NetLogSpdySynParameter(
             headers, static_cast<spdy::SpdyControlFlags>(frame.flags()),
-            stream_id));
+            stream_id)));
   }
 
   // Server-initiated streams should have even sequence numbers.
   if ((stream_id & 0x1) != 0) {
     LOG(ERROR) << "Received invalid OnSyn stream id " << stream_id;
     return;
   }
 
   if (IsStreamActive(stream_id)) {
     LOG(ERROR) << "Received OnSyn for active stream " << stream_id;
@@ skipping 75 matching lines @@
   if (stream->response_received()) {
     LOG(WARNING) << "Received duplicate SYN_REPLY for stream " << stream_id;
     CloseStream(stream->stream_id(), ERR_SPDY_PROTOCOL_ERROR);
     return;
   }
   stream->set_response_received();
 
   if (net_log().IsLoggingAllEvents()) {
     net_log().AddEvent(
         NetLog::TYPE_SPDY_SESSION_SYN_REPLY,
-        new NetLogSpdySynParameter(
+        make_scoped_refptr(new NetLogSpdySynParameter(
             headers, static_cast<spdy::SpdyControlFlags>(frame.flags()),
-            stream_id));
+            stream_id)));
   }
 
   Respond(*headers, stream);
 }
 
 void SpdySession::OnControl(const spdy::SpdyControlFrame* frame) {
   const linked_ptr<spdy::SpdyHeaderBlock> headers(new spdy::SpdyHeaderBlock);
   uint32 type = frame->type();
   if (type == spdy::SYN_STREAM || type == spdy::SYN_REPLY) {
     if (!spdy_framer_.ParseHeaderBlock(frame, headers.get())) {
@@ skipping 40 matching lines @@
     default:
       DCHECK(false);  // Error!
   }
 }
 
 void SpdySession::OnRst(const spdy::SpdyRstStreamControlFrame& frame) {
   spdy::SpdyStreamId stream_id = frame.stream_id();
 
   net_log().AddEvent(
       NetLog::TYPE_SPDY_SESSION_RST_STREAM,
-      new NetLogSpdyRstParameter(stream_id, frame.status()));
+      make_scoped_refptr(
+          new NetLogSpdyRstParameter(stream_id, frame.status())));
 
   bool valid_stream = IsStreamActive(stream_id);
   if (!valid_stream) {
     // NOTE:  it may just be that the stream was cancelled.
     LOG(WARNING) << "Received RST for invalid stream" << stream_id;
     return;
   }
   scoped_refptr<SpdyStream> stream = active_streams_[stream_id];
   CHECK_EQ(stream->stream_id(), stream_id);
   CHECK(!stream->cancelled());
 
   if (frame.status() == 0) {
     stream->OnDataReceived(NULL, 0);
   } else {
     LOG(ERROR) << "Spdy stream closed: " << frame.status();
     // TODO(mbelshe): Map from Spdy-protocol errors to something sensical.
     //                For now, it doesn't matter much - it is a protocol error.
     DeleteStream(stream_id, ERR_SPDY_PROTOCOL_ERROR);
   }
 }
 
 void SpdySession::OnGoAway(const spdy::SpdyGoAwayControlFrame& frame) {
   net_log_.AddEvent(
       NetLog::TYPE_SPDY_SESSION_GOAWAY,
-      new NetLogSpdyGoAwayParameter(frame.last_accepted_stream_id(),
-                                    active_streams_.size(),
-                                    unclaimed_pushed_streams_.size()));
+      make_scoped_refptr(
+          new NetLogSpdyGoAwayParameter(frame.last_accepted_stream_id(),
+                                        active_streams_.size(),
+                                        unclaimed_pushed_streams_.size())));
   RemoveFromPool();
   CloseAllStreams(net::ERR_ABORTED);
 
   // TODO(willchan): Cancel any streams that are past the GoAway frame's
   // |last_accepted_stream_id|.
 
   // Don't bother killing any streams that are still reading.  They'll either
   // complete successfully or get an ERR_CONNECTION_CLOSED when the socket is
   // closed.
 }
 
 void SpdySession::OnSettings(const spdy::SpdySettingsControlFrame& frame) {
   spdy::SpdySettings settings;
   if (spdy_framer_.ParseSettings(&frame, &settings)) {
     HandleSettings(settings);
     spdy_settings_->Set(host_port_pair(), settings);
   }
 
   received_settings_ = true;
 
   net_log_.AddEvent(
       NetLog::TYPE_SPDY_SESSION_RECV_SETTINGS,
-      new NetLogSpdySettingsParameter(settings));
+      make_scoped_refptr(new NetLogSpdySettingsParameter(settings)));
 }
 
 void SpdySession::OnWindowUpdate(
     const spdy::SpdyWindowUpdateControlFrame& frame) {
   spdy::SpdyStreamId stream_id = frame.stream_id();
   if (!IsStreamActive(stream_id)) {
     LOG(WARNING) << "Received WINDOW_UPDATE for invalid stream " << stream_id;
     return;
   }
 
   int delta_window_size = static_cast<int>(frame.delta_window_size());
   if (delta_window_size < 1) {
     LOG(WARNING) << "Received WINDOW_UPDATE with an invalid delta_window_size "
                  << delta_window_size;
     ResetStream(stream_id, spdy::FLOW_CONTROL_ERROR);
     return;
   }
 
   scoped_refptr<SpdyStream> stream = active_streams_[stream_id];
   CHECK_EQ(stream->stream_id(), stream_id);
   CHECK(!stream->cancelled());
 
   if (use_flow_control_)
     stream->IncreaseSendWindowSize(delta_window_size);
 
   net_log_.AddEvent(
       NetLog::TYPE_SPDY_SESSION_SEND_WINDOW_UPDATE,
-      new NetLogSpdyWindowUpdateParameter(stream_id,
-                                          delta_window_size,
-                                          stream->send_window_size()));
+      make_scoped_refptr(new NetLogSpdyWindowUpdateParameter(
+          stream_id, delta_window_size, stream->send_window_size())));
 }
 
 void SpdySession::SendWindowUpdate(spdy::SpdyStreamId stream_id,
                                    int delta_window_size) {
   DCHECK(IsStreamActive(stream_id));
   scoped_refptr<SpdyStream> stream = active_streams_[stream_id];
   CHECK_EQ(stream->stream_id(), stream_id);
 
   net_log_.AddEvent(
       NetLog::TYPE_SPDY_SESSION_RECV_WINDOW_UPDATE,
-      new NetLogSpdyWindowUpdateParameter(stream_id,
-                                          delta_window_size,
-                                          stream->recv_window_size()));
+      make_scoped_refptr(new NetLogSpdyWindowUpdateParameter(
+          stream_id, delta_window_size, stream->recv_window_size())));
 
   scoped_ptr<spdy::SpdyWindowUpdateControlFrame> window_update_frame(
       spdy_framer_.CreateWindowUpdate(stream_id, delta_window_size));
   QueueFrame(window_update_frame.get(), stream->priority(), stream);
 }
 
 void SpdySession::SendSettings() {
   const spdy::SpdySettings& settings = spdy_settings_->Get(host_port_pair());
   if (settings.empty())
     return;
   HandleSettings(settings);
 
   net_log_.AddEvent(
       NetLog::TYPE_SPDY_SESSION_SEND_SETTINGS,
-      new NetLogSpdySettingsParameter(settings));
+      make_scoped_refptr(new NetLogSpdySettingsParameter(settings)));
 
   // Create the SETTINGS frame and send it.
   scoped_ptr<spdy::SpdySettingsControlFrame> settings_frame(
       spdy_framer_.CreateSettings(settings));
   sent_settings_ = true;
   QueueFrame(settings_frame.get(), 0, NULL);
 }
 
 void SpdySession::HandleSettings(const spdy::SpdySettings& settings) {
   for (spdy::SpdySettings::const_iterator i = settings.begin(),
@@ skipping 55 matching lines @@
     }
   }
 }
 
 void SpdySession::InvokeUserStreamCreationCallback(
     CompletionCallback* callback, int rv) {
   callback->Run(rv);
 }
 
 }  // namespace net