Convert implicit scoped_refptr constructor calls to explicit ones, part 2

net/socket/client_socket_pool_base.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/socket/client_socket_pool_base.h"
 
 #include "base/compiler_specific.h"
 #include "base/format_macros.h"
 #include "base/message_loop.h"
 #include "base/metrics/stats_counters.h"
@@ skipping 69 matching lines @@
   return rv;
 }
 
 void ConnectJob::UseForNormalRequest() {
   DCHECK_EQ(UNUSED_PRECONNECT, preconnect_state_);
   preconnect_state_ = USED_PRECONNECT;
 }
 
 void ConnectJob::set_socket(ClientSocket* socket) {
   if (socket) {
-    net_log().AddEvent(NetLog::TYPE_CONNECT_JOB_SET_SOCKET,
-                       new NetLogSourceParameter("source_dependency",
-                                                 socket->NetLog().source()));
+    net_log().AddEvent(NetLog::TYPE_CONNECT_JOB_SET_SOCKET, make_scoped_refptr(
+          new NetLogSourceParameter("source_dependency",
+                                    socket->NetLog().source())));
   }
   socket_.reset(socket);
 }
 
 void ConnectJob::NotifyDelegateOfCompletion(int rv) {
   // The delegate will delete |this|.
   Delegate *delegate = delegate_;
   delegate_ = NULL;
 
   LogConnectCompletion(rv);
   delegate->OnConnectJobComplete(rv, this);
 }
 
 void ConnectJob::ResetTimer(base::TimeDelta remaining_time) {
   timer_.Stop();
   timer_.Start(remaining_time, this, &ConnectJob::OnTimeout);
 }
 
 void ConnectJob::LogConnectStart() {
   net_log().BeginEvent(NetLog::TYPE_SOCKET_POOL_CONNECT_JOB_CONNECT,
-                       new NetLogStringParameter("group_name", group_name_));
+      make_scoped_refptr(new NetLogStringParameter("group_name", group_name_)));
 }
 
 void ConnectJob::LogConnectCompletion(int net_error) {
   scoped_refptr<NetLog::EventParameters> params;
   if (net_error != OK)
     params = new NetLogIntegerParameter("net_error", net_error);
   net_log().EndEvent(NetLog::TYPE_SOCKET_POOL_CONNECT_JOB_CONNECT, params);
 }
 
 void ConnectJob::OnTimeout() {
@@ skipping 108 matching lines @@
   DCHECK(!request.callback());
   DCHECK(!request.handle());
 
   if (num_sockets > max_sockets_per_group_) {
     NOTREACHED();
     num_sockets = max_sockets_per_group_;
   }
 
   request.net_log().BeginEvent(
       NetLog::TYPE_SOCKET_POOL_CONNECTING_N_SOCKETS,
-      new NetLogIntegerParameter("num_sockets", num_sockets));
+      make_scoped_refptr(new NetLogIntegerParameter(
+          "num_sockets", num_sockets)));
 
   Group* group = GetOrCreateGroup(group_name);
 
   for (int num_iterations_left = num_sockets;
        group->NumActiveSocketSlots() < num_sockets &&
        num_iterations_left > 0 ; num_iterations_left--) {
     int rv = RequestSocketInternal(group_name, &request);
     if (rv < 0 && rv != ERR_IO_PENDING) {
       // We're encountering a synchronous error.  Give up.
       break;
@@ skipping 134 matching lines @@
   }
 
   return false;
 }
 
 // static
 void ClientSocketPoolBaseHelper::LogBoundConnectJobToRequest(
     const NetLog::Source& connect_job_source, const Request* request) {
   request->net_log().AddEvent(
       NetLog::TYPE_SOCKET_POOL_BOUND_TO_CONNECT_JOB,
-      new NetLogSourceParameter("source_dependency", connect_job_source));
+      make_scoped_refptr(new NetLogSourceParameter(
+          "source_dependency", connect_job_source)));
 }
 
 void ClientSocketPoolBaseHelper::CancelRequest(
     const std::string& group_name, ClientSocketHandle* handle) {
   PendingCallbackMap::iterator callback_it = pending_callback_map_.find(handle);
   if (callback_it != pending_callback_map_.end()) {
     int result = callback_it->second.result;
     pending_callback_map_.erase(callback_it);
     ClientSocket* socket = handle->release_socket();
     if (socket) {
@@ skipping 348 matching lines @@
       scoped_ptr<const Request> r(RemoveRequestFromQueue(
           group->mutable_pending_requests()->begin(), group));
       LogBoundConnectJobToRequest(job_log.source(), r.get());
       job->GetAdditionalErrorState(r->handle());
       RemoveConnectJob(job, group);
       if (socket.get()) {
         handed_out_socket = true;
         HandOutSocket(socket.release(), false /* unused socket */, r->handle(),
                       base::TimeDelta(), group, r->net_log());
       }
-      r->net_log().EndEvent(NetLog::TYPE_SOCKET_POOL,
-                            new NetLogIntegerParameter("net_error", result));
+      r->net_log().EndEvent(NetLog::TYPE_SOCKET_POOL, make_scoped_refptr(
+          new NetLogIntegerParameter("net_error", result)));
       InvokeUserCallbackLater(r->handle(), r->callback(), result);
     } else {
       RemoveConnectJob(job, group);
     }
     if (!handed_out_socket) {
       OnAvailableSocketSlot(group_name, group);
       CheckForStalledSocketGroups();
     }
   }
 }
@@ skipping 64 matching lines @@
     const BoundNetLog& net_log) {
   DCHECK(socket);
   handle->set_socket(socket);
   handle->set_is_reused(reused);
   handle->set_idle_time(idle_time);
   handle->set_pool_id(pool_generation_number_);
 
   if (reused) {
     net_log.AddEvent(
         NetLog::TYPE_SOCKET_POOL_REUSED_AN_EXISTING_SOCKET,
-        new NetLogIntegerParameter(
-            "idle_ms", static_cast<int>(idle_time.InMilliseconds())));
+        make_scoped_refptr(new NetLogIntegerParameter(
+            "idle_ms", static_cast<int>(idle_time.InMilliseconds()))));
   }
 
   net_log.AddEvent(NetLog::TYPE_SOCKET_POOL_BOUND_TO_SOCKET,
-                   new NetLogSourceParameter(
-                       "source_dependency", socket->NetLog().source()));
+                   make_scoped_refptr(new NetLogSourceParameter(
+                       "source_dependency", socket->NetLog().source())));
 
   handed_out_socket_count_++;
   group->IncrementActiveSocketCount();
 }
 
 void ClientSocketPoolBaseHelper::AddIdleSocket(
     ClientSocket* socket, Group* group) {
   DCHECK(socket);
   IdleSocket idle_socket;
   idle_socket.socket = socket;
@@ skipping 177 matching lines @@
   // Delete active jobs.
   STLDeleteElements(&jobs_);
 
   // Cancel pending backup job.
   method_factory_.RevokeAll();
 }
 
 }  // namespace internal
 
 }  // namespace net