Convert Pass()→std::move() in //net

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>
 
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/memory/weak_ptr.h"
 #include "base/run_loop.h"
 #include "base/single_thread_task_runner.h"
 #include "base/thread_task_runner_handle.h"
 #include "net/base/ip_endpoint.h"
 #include "net/base/load_timing_info.h"
@@ skipping 178 matching lines @@
   }
 
   static scoped_ptr<StreamSocket> MakeMockPendingClientSocket(
       const AddressList& addrlist,
       bool should_connect,
       net::NetLog* net_log) {
     scoped_ptr<MockTriggerableClientSocket> socket(
         new MockTriggerableClientSocket(addrlist, should_connect, net_log));
     base::ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE,
                                                   socket->GetConnectCallback());
-    return socket.Pass();
+    return std::move(socket);
   }
 
   static scoped_ptr<StreamSocket> MakeMockDelayedClientSocket(
       const AddressList& addrlist,
       bool should_connect,
       const base::TimeDelta& delay,
       net::NetLog* net_log) {
     scoped_ptr<MockTriggerableClientSocket> socket(
         new MockTriggerableClientSocket(addrlist, should_connect, net_log));
     base::ThreadTaskRunnerHandle::Get()->PostDelayedTask(
         FROM_HERE, socket->GetConnectCallback(), delay);
-    return socket.Pass();
+    return std::move(socket);
   }
 
   static scoped_ptr<StreamSocket> MakeMockStalledClientSocket(
       const AddressList& addrlist,
       net::NetLog* net_log,
       bool failing) {
     scoped_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 socket.Pass();
+    return std::move(socket);
   }
 
   // StreamSocket implementation.
   int Connect(const CompletionCallback& callback) override {
     DCHECK(callback_.is_null());
     callback_ = callback;
     return ERR_IO_PENDING;
   }
 
   void Disconnect() override {}
@@ skipping 172 matching lines @@
     case MOCK_TRIGGERABLE_CLIENT_SOCKET: {
       scoped_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 rv.Pass();
+      return std::move(rv);
     }
     default:
       NOTREACHED();
       return scoped_ptr<StreamSocket>(
           new MockConnectClientSocket(addresses, net_log_));
   }
 }
 
 scoped_ptr<SSLClientSocket>
 MockTransportClientSocketFactory::CreateSSLClientSocket(
@@ skipping 25 matching lines @@
     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