Convert implicit scoped_refptr constructor calls to explicit ones, part 2

net/socket_stream/socket_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.
 //
 // TODO(ukai): code is similar with http_network_transaction.cc.  We should
 //   think about ways to share code, if possible.
 
 #include "net/socket_stream/socket_stream.h"
 
 #include <set>
@@ skipping 120 matching lines @@
   if (context_)
     ssl_config_service()->GetSSLConfig(&ssl_config_);
   DCHECK_EQ(next_state_, STATE_NONE);
 
   AddRef();  // Released in Finish()
   // Open a connection asynchronously, so that delegate won't be called
   // back before returning Connect().
   next_state_ = STATE_RESOLVE_PROXY;
   net_log_.BeginEvent(
       NetLog::TYPE_SOCKET_STREAM_CONNECT,
-      new NetLogStringParameter("url", url_.possibly_invalid_spec()));
+      make_scoped_refptr(
+          new NetLogStringParameter("url", url_.possibly_invalid_spec())));
   MessageLoop::current()->PostTask(
       FROM_HERE,
       NewRunnableMethod(this, &SocketStream::DoLoop, OK));
 }
 
 bool SocketStream::SendData(const char* data, int len) {
   DCHECK(MessageLoop::current()) <<
       "The current MessageLoop must exist";
   DCHECK_EQ(MessageLoop::TYPE_IO, MessageLoop::current()->type()) <<
       "The current MessageLoop must be TYPE_IO";
   if (!socket_.get() || !socket_->IsConnected() || next_state_ == STATE_NONE)
     return false;
   if (write_buf_) {
     int current_amount_send = write_buf_size_ - write_buf_offset_;
     for (PendingDataQueue::const_iterator iter = pending_write_bufs_.begin();
          iter != pending_write_bufs_.end();
          ++iter)
       current_amount_send += (*iter)->size();
 
     current_amount_send += len;
     if (current_amount_send > max_pending_send_allowed_)
       return false;
 
-    pending_write_bufs_.push_back(new IOBufferWithSize(len));
+    pending_write_bufs_.push_back(make_scoped_refptr(
+        new IOBufferWithSize(len)));
     memcpy(pending_write_bufs_.back()->data(), data, len);
     return true;
   }
   DCHECK(!current_write_buf_);
   write_buf_ = new IOBuffer(len);
   memcpy(write_buf_->data(), data, len);
   write_buf_size_ = len;
   write_buf_offset_ = 0;
   // Send pending data asynchronously, so that delegate won't be called
   // back before returning SendData().
@@ skipping 262 matching lines @@
         return;
       default:
         NOTREACHED() << "bad state " << state;
         Finish(result);
         return;
     }
     // If the connection is not established yet and had actual errors,
     // close the connection.
     if (state != STATE_READ_WRITE && result < ERR_IO_PENDING) {
       DCHECK_EQ(next_state_, STATE_CLOSE);
-      net_log_.EndEvent(NetLog::TYPE_SOCKET_STREAM_CONNECT,
-                        new NetLogIntegerParameter("net_error", result));
+      net_log_.EndEvent(
+          NetLog::TYPE_SOCKET_STREAM_CONNECT,
+          make_scoped_refptr(new NetLogIntegerParameter("net_error", result)));
     }
   } while (result != ERR_IO_PENDING);
 }
 
 int SocketStream::DoResolveProxy() {
   DCHECK(!pac_request_);
   next_state_ = STATE_RESOLVE_PROXY_COMPLETE;
 
   if (!proxy_url_.is_valid()) {
     next_state_ = STATE_CLOSE;
@@ skipping 559 matching lines @@
 
 SSLConfigService* SocketStream::ssl_config_service() const {
   return context_->ssl_config_service();
 }
 
 ProxyService* SocketStream::proxy_service() const {
   return context_->proxy_service();
 }
 
 }  // namespace net