Fix some uses of scoped_ptr.release() in net/ such that the return value is not ignored.

net/socket/client_socket_pool_base.h

 // 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.
 //
 // A ClientSocketPoolBase is used to restrict the number of sockets open at
 // a time.  It also maintains a list of idle persistent sockets for reuse.
 // Subclasses of ClientSocketPool should compose ClientSocketPoolBase to handle
 // the core logic of (1) restricting the number of active (connected or
 // connecting) sockets per "group" (generally speaking, the hostname), (2)
 // maintaining a per-group list of idle, persistent sockets for reuse, and (3)
@@ skipping 158 matching lines @@
 
   ClientSocketPoolBaseHelper(
       int max_sockets,
       int max_sockets_per_group,
       base::TimeDelta unused_idle_socket_timeout,
       base::TimeDelta used_idle_socket_timeout,
       ConnectJobFactory* connect_job_factory,
       NetworkChangeNotifier* network_change_notifier);
 
   // See ClientSocketPool::RequestSocket for documentation on this function.
-  // Note that |request| must be heap allocated.  If ERR_IO_PENDING is returned,
-  // then ClientSocketPoolBaseHelper takes ownership of |request|.
+  // ClientSocketPoolBaseHelper takes ownership of |request|, which must be
+  // heap allocated.
   int RequestSocket(const std::string& group_name, const Request* request);
 
   // See ClientSocketPool::CancelRequest for documentation on this function.
   void CancelRequest(const std::string& group_name,
                      const ClientSocketHandle* handle);
 
   // See ClientSocketPool::ReleaseSocket for documentation on this function.
   void ReleaseSocket(const std::string& group_name,
                      ClientSocket* socket);
 
@@ skipping 328 matching lines @@
 
   // RequestSocket bundles up the parameters into a Request and then forwards to
   // ClientSocketPoolBaseHelper::RequestSocket().  Note that the memory
   // ownership is transferred in the asynchronous (ERR_IO_PENDING) case.
   int RequestSocket(const std::string& group_name,
                     const SocketParams& params,
                     RequestPriority priority,
                     ClientSocketHandle* handle,
                     CompletionCallback* callback,
                     const BoundNetLog& net_log) {
-    scoped_ptr<Request> request(
-        new Request(handle, callback, priority, params, net_log));
-    int rv = helper_->RequestSocket(group_name, request.get());
-    if (rv == ERR_IO_PENDING)
-      request.release();
-    return rv;
+    Request* request = new Request(handle, callback, priority, params, net_log);
+    return helper_->RequestSocket(group_name, request);
   }
 
   void CancelRequest(const std::string& group_name,
                      const ClientSocketHandle* handle) {
     return helper_->CancelRequest(group_name, handle);
   }
 
   void ReleaseSocket(const std::string& group_name, ClientSocket* socket) {
     return helper_->ReleaseSocket(group_name, socket);
   }
@@ skipping 79 matching lines @@
   // the posting of the task and the execution, then we'll hit the DCHECK that
   // |ClientSocketPoolBaseHelper::group_map_| is empty.
   scoped_refptr<internal::ClientSocketPoolBaseHelper> helper_;
 
   DISALLOW_COPY_AND_ASSIGN(ClientSocketPoolBase);
 };
 
 }  // namespace net
 
 #endif  // NET_SOCKET_CLIENT_SOCKET_POOL_BASE_H_