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

remoting/host/it2me/it2me_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/it2me/it2me_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 56 matching lines @@
 
 }  // namespace
 
 class MockIt2MeHost : public It2MeHost {
  public:
   MockIt2MeHost(scoped_ptr<ChromotingHostContext> context,
                 scoped_ptr<PolicyWatcher> policy_watcher,
                 base::WeakPtr<It2MeHost::Observer> observer,
                 const XmppSignalStrategy::XmppServerConfig& xmpp_server_config,
                 const std::string& directory_bot_jid)
-      : It2MeHost(context.Pass(),
-                  policy_watcher.Pass(),
+      : It2MeHost(std::move(context),
+                  std::move(policy_watcher),
                   nullptr,
                   observer,
                   xmpp_server_config,
                   directory_bot_jid) {}
 
   // It2MeHost overrides
   void Connect() override;
   void Disconnect() override;
   void RequestNatPolicy() override;
 
@@ skipping 60 matching lines @@
 }
 
 class MockIt2MeHostFactory : public It2MeHostFactory {
  public:
   MockIt2MeHostFactory() : It2MeHostFactory() {}
   scoped_refptr<It2MeHost> CreateIt2MeHost(
       scoped_ptr<ChromotingHostContext> context,
       base::WeakPtr<It2MeHost::Observer> observer,
       const XmppSignalStrategy::XmppServerConfig& xmpp_server_config,
       const std::string& directory_bot_jid) override {
-    return new MockIt2MeHost(context.Pass(), nullptr, observer,
+    return new MockIt2MeHost(std::move(context), nullptr, observer,
                              xmpp_server_config, directory_bot_jid);
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(MockIt2MeHostFactory);
 };  // MockIt2MeHostFactory
 
 class It2MeNativeMessagingHostTest : public testing::Test {
  public:
   It2MeNativeMessagingHostTest() {}
@@ skipping 132 matching lines @@
   base::JSONWriter::Write(message, &message_json);
 
   uint32 length = message_json.length();
   input_write_file_.WriteAtCurrentPos(reinterpret_cast<char*>(&length),
                                       sizeof(length));
   input_write_file_.WriteAtCurrentPos(message_json.data(), length);
 }
 
 void It2MeNativeMessagingHostTest::VerifyHelloResponse(int request_id) {
   scoped_ptr<base::DictionaryValue> response = ReadMessageFromOutputPipe();
-  VerifyCommonProperties(response.Pass(), "helloResponse", request_id);
+  VerifyCommonProperties(std::move(response), "helloResponse", request_id);
 }
 
 void It2MeNativeMessagingHostTest::VerifyErrorResponse() {
   scoped_ptr<base::DictionaryValue> response = ReadMessageFromOutputPipe();
-  VerifyStringProperty(response.Pass(), "type", "error");
+  VerifyStringProperty(std::move(response), "type", "error");
 }
 
 void It2MeNativeMessagingHostTest::VerifyConnectResponses(int request_id) {
   bool connect_response_received = false;
   bool starting_received = false;
   bool requestedAccessCode_received = false;
   bool receivedAccessCode_received = false;
   bool connected_received = false;
 
   // We expect a total of 5 messages: 1 connectResponse and 4 hostStateChanged.
   for (int i = 0; i < 5; ++i) {
     scoped_ptr<base::DictionaryValue> response = ReadMessageFromOutputPipe();
     ASSERT_TRUE(response);
 
     std::string type;
     ASSERT_TRUE(response->GetString("type", &type));
 
     if (type == "connectResponse") {
       EXPECT_FALSE(connect_response_received);
       connect_response_received = true;
-      VerifyId(response.Pass(), request_id);
+      VerifyId(std::move(response), request_id);
     } else if (type == "hostStateChanged") {
       std::string state;
       ASSERT_TRUE(response->GetString("state", &state));
 
       std::string value;
       if (state == It2MeNativeMessagingHost::HostStateToString(kStarting)) {
         EXPECT_FALSE(starting_received);
         starting_received = true;
       } else if (state == It2MeNativeMessagingHost::HostStateToString(
                               kRequestedAccessCode)) {
@@ skipping 35 matching lines @@
   for (int i = 0; i < 2; ++i) {
     scoped_ptr<base::DictionaryValue> response = ReadMessageFromOutputPipe();
     ASSERT_TRUE(response);
 
     std::string type;
     ASSERT_TRUE(response->GetString("type", &type));
 
     if (type == "disconnectResponse") {
       EXPECT_FALSE(disconnect_response_received);
       disconnect_response_received = true;
-      VerifyId(response.Pass(), request_id);
+      VerifyId(std::move(response), request_id);
     } else if (type == "hostStateChanged") {
       std::string state;
       ASSERT_TRUE(response->GetString("state", &state));
       if (state == It2MeNativeMessagingHost::HostStateToString(kDisconnected)) {
         EXPECT_FALSE(disconnected_received);
         disconnected_received = true;
       } else {
         ADD_FAILURE() << "Unexpected host state: " << state;
       }
     } else {
@@ skipping 26 matching lines @@
 
   base::File input_read_file;
   base::File output_write_file;
 
   ASSERT_TRUE(MakePipe(&input_read_file, &input_write_file_));
   ASSERT_TRUE(MakePipe(&output_read_file_, &output_write_file));
 
   pipe_.reset(new NativeMessagingPipe());
 
   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)));
 
   // Creating a native messaging host with a mock It2MeHostFactory.
   scoped_ptr<extensions::NativeMessageHost> it2me_host(
       new It2MeNativeMessagingHost(
           ChromotingHostContext::Create(host_task_runner_),
           make_scoped_ptr(new MockIt2MeHostFactory())));
   it2me_host->Start(pipe_.get());
 
-  pipe_->Start(it2me_host.Pass(), channel.Pass());
+  pipe_->Start(std::move(it2me_host), std::move(channel));
 
   // Notify the test that the host has finished starting up.
   test_message_loop_->task_runner()->PostTask(
       FROM_HERE, test_run_loop_->QuitClosure());
 }
 
 void It2MeNativeMessagingHostTest::ExitTest() {
   if (!test_message_loop_->task_runner()->RunsTasksOnCurrentThread()) {
     test_message_loop_->task_runner()->PostTask(
         FROM_HERE,
@@ skipping 80 matching lines @@
 }
 
 // Verify rejection if type is unrecognized.
 TEST_F(It2MeNativeMessagingHostTest, InvalidType) {
   base::DictionaryValue message;
   message.SetString("type", "xxx");
   TestBadRequest(message, true);
 }
 
 }  // namespace remoting