Change scoped_ptr to std::unique_ptr in //net/socket.

net/socket/transport_client_socket_pool_test_util.cc

 // Copyright 2014 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/transport_client_socket_pool_test_util.h"
 
 #include <stdint.h>
 #include <string>
 #include <utility>
 
@@ skipping 172 matching lines @@
         weak_factory_(this) {}
 
   // Call this method to get a closure which will trigger the connect callback
   // when called. The closure can be called even after the socket is deleted; it
   // will safely do nothing.
   base::Closure GetConnectCallback() {
     return base::Bind(&MockTriggerableClientSocket::DoCallback,
                       weak_factory_.GetWeakPtr());
   }
 
-  static scoped_ptr<StreamSocket> MakeMockPendingClientSocket(
+  static std::unique_ptr<StreamSocket> MakeMockPendingClientSocket(
       const AddressList& addrlist,
       bool should_connect,
       net::NetLog* net_log) {
-    scoped_ptr<MockTriggerableClientSocket> socket(
+    std::unique_ptr<MockTriggerableClientSocket> socket(
         new MockTriggerableClientSocket(addrlist, should_connect, net_log));
     base::ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE,
                                                   socket->GetConnectCallback());
     return std::move(socket);
   }
 
-  static scoped_ptr<StreamSocket> MakeMockDelayedClientSocket(
+  static std::unique_ptr<StreamSocket> MakeMockDelayedClientSocket(
       const AddressList& addrlist,
       bool should_connect,
       const base::TimeDelta& delay,
       net::NetLog* net_log) {
-    scoped_ptr<MockTriggerableClientSocket> socket(
+    std::unique_ptr<MockTriggerableClientSocket> socket(
         new MockTriggerableClientSocket(addrlist, should_connect, net_log));
     base::ThreadTaskRunnerHandle::Get()->PostDelayedTask(
         FROM_HERE, socket->GetConnectCallback(), delay);
     return std::move(socket);
   }
 
-  static scoped_ptr<StreamSocket> MakeMockStalledClientSocket(
+  static std::unique_ptr<StreamSocket> MakeMockStalledClientSocket(
       const AddressList& addrlist,
       net::NetLog* net_log,
       bool failing) {
-    scoped_ptr<MockTriggerableClientSocket> socket(
+    std::unique_ptr<MockTriggerableClientSocket> socket(
         new MockTriggerableClientSocket(addrlist, true, net_log));
     if (failing) {
       DCHECK_LE(1u, addrlist.size());
       ConnectionAttempts attempts;
       attempts.push_back(ConnectionAttempt(addrlist[0], ERR_CONNECTION_FAILED));
       socket->AddConnectionAttempts(attempts);
     }
     return std::move(socket);
   }
 
@@ skipping 121 matching lines @@
       allocation_count_(0),
       client_socket_type_(MOCK_CLIENT_SOCKET),
       client_socket_types_(NULL),
       client_socket_index_(0),
       client_socket_index_max_(0),
       delay_(base::TimeDelta::FromMilliseconds(
           ClientSocketPool::kMaxConnectRetryIntervalMs)) {}
 
 MockTransportClientSocketFactory::~MockTransportClientSocketFactory() {}
 
-scoped_ptr<DatagramClientSocket>
+std::unique_ptr<DatagramClientSocket>
 MockTransportClientSocketFactory::CreateDatagramClientSocket(
     DatagramSocket::BindType bind_type,
     const RandIntCallback& rand_int_cb,
     NetLog* net_log,
     const NetLog::Source& source) {
   NOTREACHED();
-  return scoped_ptr<DatagramClientSocket>();
+  return std::unique_ptr<DatagramClientSocket>();
 }
 
-scoped_ptr<StreamSocket>
+std::unique_ptr<StreamSocket>
 MockTransportClientSocketFactory::CreateTransportClientSocket(
     const AddressList& addresses,
-    scoped_ptr<SocketPerformanceWatcher> /* socket_performance_watcher */,
+    std::unique_ptr<SocketPerformanceWatcher> /* socket_performance_watcher */,
     NetLog* /* net_log */,
     const NetLog::Source& /* source */) {
   allocation_count_++;
 
   ClientSocketType type = client_socket_type_;
   if (client_socket_types_ && client_socket_index_ < client_socket_index_max_) {
     type = client_socket_types_[client_socket_index_++];
   }
 
   switch (type) {
     case MOCK_CLIENT_SOCKET:
-      return scoped_ptr<StreamSocket>(
+      return std::unique_ptr<StreamSocket>(
           new MockConnectClientSocket(addresses, net_log_));
     case MOCK_FAILING_CLIENT_SOCKET:
-      return scoped_ptr<StreamSocket>(
+      return std::unique_ptr<StreamSocket>(
           new MockFailingClientSocket(addresses, net_log_));
     case MOCK_PENDING_CLIENT_SOCKET:
       return MockTriggerableClientSocket::MakeMockPendingClientSocket(
           addresses, true, net_log_);
     case MOCK_PENDING_FAILING_CLIENT_SOCKET:
       return MockTriggerableClientSocket::MakeMockPendingClientSocket(
           addresses, false, net_log_);
     case MOCK_DELAYED_CLIENT_SOCKET:
       return MockTriggerableClientSocket::MakeMockDelayedClientSocket(
           addresses, true, delay_, net_log_);
     case MOCK_DELAYED_FAILING_CLIENT_SOCKET:
       return MockTriggerableClientSocket::MakeMockDelayedClientSocket(
           addresses, false, delay_, net_log_);
     case MOCK_STALLED_CLIENT_SOCKET:
       return MockTriggerableClientSocket::MakeMockStalledClientSocket(
           addresses, net_log_, false);
     case MOCK_STALLED_FAILING_CLIENT_SOCKET:
       return MockTriggerableClientSocket::MakeMockStalledClientSocket(
           addresses, net_log_, true);
     case MOCK_TRIGGERABLE_CLIENT_SOCKET: {
-      scoped_ptr<MockTriggerableClientSocket> rv(
+      std::unique_ptr<MockTriggerableClientSocket> rv(
           new MockTriggerableClientSocket(addresses, true, net_log_));
       triggerable_sockets_.push(rv->GetConnectCallback());
       // run_loop_quit_closure_ behaves like a condition variable. It will
       // wake up WaitForTriggerableSocketCreation() if it is sleeping. We
       // don't need to worry about atomicity because this code is
       // single-threaded.
       if (!run_loop_quit_closure_.is_null())
         run_loop_quit_closure_.Run();
       return std::move(rv);
     }
     default:
       NOTREACHED();
-      return scoped_ptr<StreamSocket>(
+      return std::unique_ptr<StreamSocket>(
           new MockConnectClientSocket(addresses, net_log_));
   }
 }
 
-scoped_ptr<SSLClientSocket>
+std::unique_ptr<SSLClientSocket>
 MockTransportClientSocketFactory::CreateSSLClientSocket(
-    scoped_ptr<ClientSocketHandle> transport_socket,
+    std::unique_ptr<ClientSocketHandle> transport_socket,
     const HostPortPair& host_and_port,
     const SSLConfig& ssl_config,
     const SSLClientSocketContext& context) {
   NOTIMPLEMENTED();
-  return scoped_ptr<SSLClientSocket>();
+  return std::unique_ptr<SSLClientSocket>();
 }
 
 void MockTransportClientSocketFactory::ClearSSLSessionCache() {
   NOTIMPLEMENTED();
 }
 
 void MockTransportClientSocketFactory::set_client_socket_types(
     ClientSocketType* type_list,
     int num_types) {
   DCHECK_GT(num_types, 0);
   client_socket_types_ = type_list;
   client_socket_index_ = 0;
   client_socket_index_max_ = num_types;
 }
 
 base::Closure
 MockTransportClientSocketFactory::WaitForTriggerableSocketCreation() {
   while (triggerable_sockets_.empty()) {
     base::RunLoop run_loop;
     run_loop_quit_closure_ = run_loop.QuitClosure();
     run_loop.Run();
     run_loop_quit_closure_.Reset();
   }
   base::Closure trigger = triggerable_sockets_.front();
   triggerable_sockets_.pop();
   return trigger;
 }
 
 }  // namespace net