Convert Pass()→std::move() in //components/[n-z]*

components/policy/core/common/remote_commands/remote_commands_service_unittest.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 <stddef.h>
 
 #include <queue>
 #include <string>
 #include <utility>
 
@@ skipping 129 matching lines @@
         base::TimeDelta::FromSeconds(
             kTestClientServerCommunicationDelayInSeconds));
   }
 
   void DoFetchRemoteCommands(
       scoped_ptr<RemoteCommandJob::UniqueIDType> last_command_id,
       const std::vector<em::RemoteCommandResult>& command_results,
       const RemoteCommandCallback& callback,
       const FetchCallExpectation& fetch_call_expectation) {
     const std::vector<em::RemoteCommand> fetched_commands =
-        server_->FetchCommands(last_command_id.Pass(), command_results);
+        server_->FetchCommands(std::move(last_command_id), command_results);
 
     EXPECT_EQ(fetch_call_expectation.expected_command_results,
               command_results.size());
     EXPECT_EQ(fetch_call_expectation.expected_fetched_commands,
               fetched_commands.size());
 
     if (!fetch_call_expectation.commands_fetched_callback.is_null())
       fetch_call_expectation.commands_fetched_callback.Run();
 
     // Simulate delay from DMServer back to client.
@@ skipping 79 matching lines @@
 
 // Base class for unit tests regarding remote commands service.
 class RemoteCommandsServiceTest : public testing::Test {
  protected:
   RemoteCommandsServiceTest()
       : task_runner_(new ScopedMockTimeTaskRunner()),
         runner_handle_(task_runner_) {}
 
   void SetUp() override {
     server_.reset(new TestingRemoteCommandsServer());
-    server_->SetClock(task_runner_->GetMockTickClock().Pass());
+    server_->SetClock(task_runner_->GetMockTickClock());
     cloud_policy_client_.reset(
         new TestingCloudPolicyClientForRemoteCommands(server_.get()));
   }
 
   void TearDown() override {
     remote_commands_service_.reset();
     cloud_policy_client_.reset();
     server_.reset();
   }
 
   void StartService(scoped_ptr<RemoteCommandsFactory> factory) {
-    remote_commands_service_.reset(
-        new RemoteCommandsService(factory.Pass(), cloud_policy_client_.get()));
+    remote_commands_service_.reset(new RemoteCommandsService(
+        std::move(factory), cloud_policy_client_.get()));
     remote_commands_service_->SetClockForTesting(
         task_runner_->GetMockTickClock());
   }
 
   void FlushAllTasks() {
     task_runner_->FastForwardUntilNoTasksRemain();
   }
 
   scoped_ptr<TestingRemoteCommandsServer> server_;
   scoped_ptr<TestingCloudPolicyClientForRemoteCommands> cloud_policy_client_;
   scoped_ptr<RemoteCommandsService> remote_commands_service_;
 
   scoped_refptr<ScopedMockTimeTaskRunner> task_runner_;
 
  private:
   bool service_started_ = false;
 
   base::ThreadTaskRunnerHandle runner_handle_;
 
   DISALLOW_COPY_AND_ASSIGN(RemoteCommandsServiceTest);
 };
 
 // Tests that no command will be fetched if no commands is issued.
 TEST_F(RemoteCommandsServiceTest, NoCommands) {
   scoped_ptr<MockTestRemoteCommandFactory> factory(
       new MockTestRemoteCommandFactory());
   EXPECT_CALL(*factory, BuildTestCommand()).Times(0);
 
-  StartService(factory.Pass());
+  StartService(std::move(factory));
 
   // A fetch requst should get nothing from server.
   cloud_policy_client_->ExpectFetchCommands(0u, 0u, base::Closure());
   EXPECT_TRUE(remote_commands_service_->FetchRemoteCommands());
 
   FlushAllTasks();
 }
 
 // Tests that existing commands issued before service started will be fetched.
 TEST_F(RemoteCommandsServiceTest, ExistingCommand) {
   scoped_ptr<MockTestRemoteCommandFactory> factory(
       new MockTestRemoteCommandFactory());
   EXPECT_CALL(*factory, BuildTestCommand()).Times(1);
 
   {
     ScopedMockTimeTaskRunner::ScopedRunner scoped_runner(task_runner_);
 
     // Issue a command before service started.
     server_->IssueCommand(em::RemoteCommand_Type_COMMAND_ECHO_TEST,
                           kTestPayload,
                           base::Bind(&ExpectSucceededJob, kTestPayload), false);
 
     // Start the service, run until the command is fetched.
     cloud_policy_client_->ExpectFetchCommands(0u, 1u,
                                               scoped_runner.QuitClosure());
-    StartService(factory.Pass());
+    StartService(std::move(factory));
     EXPECT_TRUE(remote_commands_service_->FetchRemoteCommands());
 
     scoped_runner.Run();
   }
 
   // And run again so that the result can be reported.
   cloud_policy_client_->ExpectFetchCommands(1u, 0u, base::Closure());
 
   FlushAllTasks();
 
   EXPECT_EQ(0u, server_->NumberOfCommandsPendingResult());
 }
 
 // Tests that commands issued after service started will be fetched.
 TEST_F(RemoteCommandsServiceTest, NewCommand) {
   scoped_ptr<MockTestRemoteCommandFactory> factory(
       new MockTestRemoteCommandFactory());
   EXPECT_CALL(*factory, BuildTestCommand()).Times(1);
 
-  StartService(factory.Pass());
+  StartService(std::move(factory));
 
   // Set up expectations on fetch commands calls. The first request will fetch
   // one command, and the second will fetch none but provide result for the
   // previous command instead.
   cloud_policy_client_->ExpectFetchCommands(0u, 1u, base::Closure());
   cloud_policy_client_->ExpectFetchCommands(1u, 0u, base::Closure());
 
   // Issue a command and manually start a command fetch.
   server_->IssueCommand(em::RemoteCommand_Type_COMMAND_ECHO_TEST, kTestPayload,
                         base::Bind(&ExpectSucceededJob, kTestPayload), false);
   EXPECT_TRUE(remote_commands_service_->FetchRemoteCommands());
 
   FlushAllTasks();
 
   EXPECT_EQ(0u, server_->NumberOfCommandsPendingResult());
 }
 
 // Tests that commands issued after service started will be fetched, even if
 // the command is issued when a fetch request is ongoing.
 TEST_F(RemoteCommandsServiceTest, NewCommandFollwingFetch) {
   scoped_ptr<MockTestRemoteCommandFactory> factory(
       new MockTestRemoteCommandFactory());
   EXPECT_CALL(*factory, BuildTestCommand()).Times(1);
 
-  StartService(factory.Pass());
+  StartService(std::move(factory));
 
   {
     ScopedMockTimeTaskRunner::ScopedRunner scoped_runner(task_runner_);
 
     // Add a command which will be issued after first fetch.
     server_->IssueCommand(em::RemoteCommand_Type_COMMAND_ECHO_TEST,
                           kTestPayload,
                           base::Bind(&ExpectSucceededJob, kTestPayload), true);
 
     cloud_policy_client_->ExpectFetchCommands(0u, 0u,
@@ skipping 23 matching lines @@
   cloud_policy_client_->ExpectFetchCommands(1u, 0u, base::Closure());
 
   // No further fetch request is made, but the new issued command should be
   // fetched and executed.
   FlushAllTasks();
 
   EXPECT_EQ(0u, server_->NumberOfCommandsPendingResult());
 }
 
 }  // namespace policy