Use std::move() instead of .Pass() in remoting/host

remoting/host/setup/me2me_native_messaging_host_unittest.cc

 // Copyright 2013 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 "remoting/host/setup/me2me_native_messaging_host.h"
 
 #include "base/basictypes.h"
 #include "base/compiler_specific.h"
 #include "base/json/json_reader.h"
 #include "base/json/json_writer.h"
@@ skipping 306 matching lines @@
 
   daemon_controller_delegate_ = new MockDaemonControllerDelegate();
   scoped_refptr<DaemonController> daemon_controller(
       new DaemonController(make_scoped_ptr(daemon_controller_delegate_)));
 
   scoped_refptr<PairingRegistry> pairing_registry =
       new SynchronousPairingRegistry(
           make_scoped_ptr(new MockPairingRegistryDelegate()));
 
   scoped_ptr<extensions::NativeMessagingChannel> channel(
-      new PipeMessagingChannel(input_read_file.Pass(),
-                               output_write_file.Pass()));
+      new PipeMessagingChannel(std::move(input_read_file),
+                               std::move(output_write_file)));
 
   scoped_ptr<OAuthClient> oauth_client(
       new MockOAuthClient("fake_user_email", "fake_refresh_token"));
 
-  host_.reset(new Me2MeNativeMessagingHost(false, 0, channel.Pass(),
+  host_.reset(new Me2MeNativeMessagingHost(false, 0, std::move(channel),
                                            daemon_controller, pairing_registry,
-                                           oauth_client.Pass()));
+                                           std::move(oauth_client)));
   host_->Start(base::Bind(&Me2MeNativeMessagingHostTest::StopHost,
                           base::Unretained(this)));
 
   // Notify the test that the host has finished starting up.
   test_message_loop_->task_runner()->PostTask(
       FROM_HERE, test_run_loop_->QuitClosure());
 }
 
 void Me2MeNativeMessagingHostTest::StopHost() {
   DCHECK(host_task_runner_->RunsTasksOnCurrentThread());
@@ skipping 85 matching lines @@
   good_message.SetString("type", "hello");
 
   // This test currently relies on synchronous processing of hello messages and
   // message parameters verification.
   WriteMessageToInputPipe(good_message);
   WriteMessageToInputPipe(message);
   WriteMessageToInputPipe(good_message);
 
   // Read from output pipe, and verify responses.
   scoped_ptr<base::DictionaryValue> response = ReadMessageFromOutputPipe();
-  VerifyHelloResponse(response.Pass());
+  VerifyHelloResponse(std::move(response));
 
   response = ReadMessageFromOutputPipe();
   EXPECT_FALSE(response);
 }
 
 // TODO (weitaosu): crbug.com/323306. Re-enable these tests.
 // Test all valid request-types.
 TEST_F(Me2MeNativeMessagingHostTest, All) {
   int next_id = 0;
   base::DictionaryValue message;
@@ skipping 72 matching lines @@
   for (int i = 0; i < next_id; ++i) {
     scoped_ptr<base::DictionaryValue> response = ReadMessageFromOutputPipe();
 
     // Make sure that id is available and is in the range.
     int id;
     ASSERT_TRUE(response->GetInteger("id", &id));
     ASSERT_TRUE(0 <= id && id < next_id);
 
     // Call the verification routine corresponding to the message id.
     ASSERT_TRUE(verify_routines[id]);
-    verify_routines[id](response.Pass());
+    verify_routines[id](std::move(response));
 
     // Clear the pointer so that the routine cannot be called the second time.
     verify_routines[id] = nullptr;
   }
 }
 
 // Verify that response ID matches request ID.
 TEST_F(Me2MeNativeMessagingHostTest, Id) {
   base::DictionaryValue message;
   message.SetString("type", "hello");
@@ skipping 73 matching lines @@
 }
 
 // Verify rejection if getCredentialsFromAuthCode has no auth code.
 TEST_F(Me2MeNativeMessagingHostTest, GetCredentialsFromAuthCodeNoAuthCode) {
   base::DictionaryValue message;
   message.SetString("type", "getCredentialsFromAuthCode");
   TestBadRequest(message);
 }
 
 }  // namespace remoting