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

net/quic/p2p/quic_p2p_session_test.cc

 // Copyright 2015 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/quic/p2p/quic_p2p_session.h"
 
+#include <utility>
+
 #include "base/callback_helpers.h"
 #include "base/location.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/io_buffer.h"
 #include "net/base/net_errors.h"
 #include "net/quic/crypto/quic_random.h"
@@ skipping 206 matching lines @@
   void CreateSessions() {
     scoped_ptr<FakeP2PDatagramSocket> socket1(new FakeP2PDatagramSocket());
     scoped_ptr<FakeP2PDatagramSocket> socket2(new FakeP2PDatagramSocket());
     socket1->ConnectWith(socket2.get());
 
     socket1_ = socket1->GetWeakPtr();
     socket2_ = socket2->GetWeakPtr();
 
     QuicP2PCryptoConfig crypto_config(kTestSharedKey);
 
-    session1_ =
-        CreateP2PSession(socket1.Pass(), crypto_config, Perspective::IS_SERVER);
-    session2_ =
-        CreateP2PSession(socket2.Pass(), crypto_config, Perspective::IS_CLIENT);
+    session1_ = CreateP2PSession(std::move(socket1), crypto_config,
+                                 Perspective::IS_SERVER);
+    session2_ = CreateP2PSession(std::move(socket2), crypto_config,
+                                 Perspective::IS_CLIENT);
   }
 
   scoped_ptr<QuicP2PSession> CreateP2PSession(scoped_ptr<Socket> socket,
                                               QuicP2PCryptoConfig crypto_config,
                                               Perspective perspective) {
     DefaultPacketWriterFactory writer_factory(socket.get());
     net::IPAddressNumber ip(net::kIPv4AddressSize, 0);
     scoped_ptr<QuicConnection> quic_connection1(new QuicConnection(
         0, net::IPEndPoint(ip, 0), &quic_helper_, writer_factory,
         true /* owns_writer */, perspective, QuicSupportedVersions()));
 
-    scoped_ptr<QuicP2PSession> result(new QuicP2PSession(
-        config_, crypto_config, quic_connection1.Pass(), socket.Pass()));
+    scoped_ptr<QuicP2PSession> result(
+        new QuicP2PSession(config_, crypto_config, std::move(quic_connection1),
+                           std::move(socket)));
     result->Initialize();
-    return result.Pass();
+    return result;
   }
 
   void TestStreamConnection(QuicP2PSession* from_session,
                             QuicP2PSession* to_session,
                             QuicStreamId expected_stream_id);
 
   QuicClock quic_clock_;
   QuicConnectionHelper quic_helper_;
   QuicConfig config_;
 
@@ skipping 124 matching lines @@
   EXPECT_TRUE(stream_delegate.is_closed());
   EXPECT_EQ(QUIC_PACKET_READ_ERROR, stream_delegate.error());
   EXPECT_TRUE(session_delegate.is_closed());
   EXPECT_EQ(QUIC_PACKET_READ_ERROR, session_delegate.error());
 
   // Verify that the socket was destroyed.
   EXPECT_FALSE(socket1_);
 }
 
 }  // namespace net