Convert Pass()→std::move() in //content/browser

content/browser/background_sync/background_sync_manager_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 "content/browser/background_sync/background_sync_manager.h"
 
 #include <stdint.h>
+#include <utility>
 
 #include "base/files/scoped_temp_dir.h"
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/metrics/field_trial.h"
 #include "base/power_monitor/power_monitor.h"
 #include "base/power_monitor/power_monitor_source.h"
 #include "base/run_loop.h"
 #include "base/single_thread_task_runner.h"
@@ skipping 315 matching lines @@
     // power_monitor_ takes ownership of power_monitor_source.
     power_monitor_.reset(new base::PowerMonitor(
         scoped_ptr<base::PowerMonitorSource>(power_monitor_source_)));
 
     SetOnBatteryPower(false);
 
     scoped_ptr<TestBackgroundSyncController> background_sync_controller(
         new TestBackgroundSyncController());
     test_controller_ = background_sync_controller.get();
     helper_->browser_context()->SetBackgroundSyncController(
-        background_sync_controller.Pass());
+        std::move(background_sync_controller));
 
     SetMaxSyncAttemptsAndRestartManager(1);
 
     // Wait for storage to finish initializing before registering service
     // workers.
     base::RunLoop().RunUntilIdle();
     RegisterServiceWorkers();
   }
 
   void TearDown() override {
@@ skipping 47 matching lines @@
     power_monitor_source_->GeneratePowerStateEvent(on_battery_power);
     base::RunLoop().RunUntilIdle();
   }
 
   void StatusAndRegistrationCallback(
       bool* was_called,
       BackgroundSyncStatus status,
       scoped_ptr<BackgroundSyncRegistrationHandle> registration_handle) {
     *was_called = true;
     callback_status_ = status;
-    callback_registration_handle_ = registration_handle.Pass();
+    callback_registration_handle_ = std::move(registration_handle);
   }
 
   void StatusAndRegistrationsCallback(
       bool* was_called,
       BackgroundSyncStatus status,
       scoped_ptr<ScopedVector<BackgroundSyncRegistrationHandle>>
           registration_handles) {
     *was_called = true;
     callback_status_ = status;
-    callback_registration_handles_ = registration_handles.Pass();
+    callback_registration_handles_ = std::move(registration_handles);
   }
 
   void StatusCallback(bool* was_called, BackgroundSyncStatus status) {
     *was_called = true;
     callback_status_ = status;
   }
 
  protected:
   void CreateBackgroundSyncManager() {
     ClearRegistrationHandles();
@@ skipping 282 matching lines @@
 
 TEST_F(BackgroundSyncManagerTest, RegisterWithoutActiveSWRegistration) {
   sw_registration_1_->UnsetVersion(sw_registration_1_->active_version());
   EXPECT_FALSE(Register(sync_options_1_));
   EXPECT_EQ(BACKGROUND_SYNC_STATUS_NO_SERVICE_WORKER, callback_status_);
 }
 
 TEST_F(BackgroundSyncManagerTest, RegisterOverwrites) {
   EXPECT_TRUE(Register(sync_options_1_));
   scoped_ptr<BackgroundSyncRegistrationHandle> first_registration_handle =
-      callback_registration_handle_.Pass();
+      std::move(callback_registration_handle_);
 
   sync_options_1_.min_period = 100;
   EXPECT_TRUE(Register(sync_options_1_));
   EXPECT_LT(first_registration_handle->handle_id(),
             callback_registration_handle_->handle_id());
   EXPECT_FALSE(first_registration_handle->options()->Equals(
       *callback_registration_handle_->options()));
 }
 
 TEST_F(BackgroundSyncManagerTest, RegisterOverlappingPeriodicAndOneShotTags) {
@@ skipping 153 matching lines @@
   EXPECT_TRUE(Unregister(callback_registration_handle_.get()));
 
   sync_options_1_.tag = std::string(MaxTagLength() + 1, 'a');
   EXPECT_FALSE(Register(sync_options_1_));
   EXPECT_EQ(BACKGROUND_SYNC_STATUS_NOT_ALLOWED, callback_status_);
 }
 
 TEST_F(BackgroundSyncManagerTest, RegistrationIncreasesId) {
   EXPECT_TRUE(Register(sync_options_1_));
   scoped_ptr<BackgroundSyncRegistrationHandle> registered_handle =
-      callback_registration_handle_.Pass();
+      std::move(callback_registration_handle_);
   BackgroundSyncRegistration::RegistrationId cur_id =
       registered_handle->handle_id();
 
   EXPECT_TRUE(GetRegistration(sync_options_1_));
   EXPECT_TRUE(Register(sync_options_2_));
   EXPECT_LT(cur_id, callback_registration_handle_->handle_id());
   cur_id = callback_registration_handle_->handle_id();
 
   EXPECT_TRUE(Unregister(registered_handle.get()));
   EXPECT_TRUE(Register(sync_options_1_));
@@ skipping 481 matching lines @@
 
 TEST_F(BackgroundSyncManagerTest, OverwritePendingRegistration) {
   // An overwritten pending registration should complete with
   // BACKGROUND_SYNC_STATE_UNREGISTERED.
   sync_options_1_.power_state = POWER_STATE_AVOID_DRAINING;
   EXPECT_TRUE(Register(sync_options_1_));
   EXPECT_TRUE(GetRegistration(sync_options_1_));
   EXPECT_EQ(POWER_STATE_AVOID_DRAINING,
             callback_registration_handle_->options()->power_state);
   scoped_ptr<BackgroundSyncRegistrationHandle> original_handle =
-      callback_registration_handle_.Pass();
+      std::move(callback_registration_handle_);
 
   // Overwrite the pending registration.
   sync_options_1_.power_state = POWER_STATE_AUTO;
   EXPECT_TRUE(Register(sync_options_1_));
   EXPECT_TRUE(GetRegistration(sync_options_1_));
   EXPECT_EQ(POWER_STATE_AUTO,
             callback_registration_handle_->options()->power_state);
 
   EXPECT_TRUE(NotifyWhenFinished(original_handle.get()));
   EXPECT_EQ(BACKGROUND_SYNC_STATE_UNREGISTERED, FinishedState());
   EXPECT_EQ(0, sync_events_called_);
 }
 
 TEST_F(BackgroundSyncManagerTest, OverwriteFiringRegistrationWhichSucceeds) {
   // An overwritten pending registration should complete with
   // BACKGROUND_SYNC_STATE_SUCCESS if firing completes successfully.
   InitDelayedSyncEventTest();
 
   sync_options_1_.power_state = POWER_STATE_AVOID_DRAINING;
   RegisterAndVerifySyncEventDelayed(sync_options_1_);
   scoped_ptr<BackgroundSyncRegistrationHandle> original_handle =
-      callback_registration_handle_.Pass();
+      std::move(callback_registration_handle_);
 
   // The next registration won't block.
   InitSyncEventTest();
 
   // Overwrite the firing registration.
   sync_options_1_.power_state = POWER_STATE_AUTO;
   EXPECT_TRUE(Register(sync_options_1_));
   EXPECT_FALSE(NotifyWhenFinished(original_handle.get()));
 
   // Successfully finish the first event.
   sync_fired_callback_.Run(SERVICE_WORKER_OK);
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(BACKGROUND_SYNC_STATE_SUCCESS, FinishedState());
 }
 
 TEST_F(BackgroundSyncManagerTest, OverwriteFiringRegistrationWhichFails) {
   // An overwritten pending registration should complete with
   // BACKGROUND_SYNC_STATE_FAILED if firing fails.
   InitDelayedSyncEventTest();
 
   sync_options_1_.power_state = POWER_STATE_AVOID_DRAINING;
   RegisterAndVerifySyncEventDelayed(sync_options_1_);
   scoped_ptr<BackgroundSyncRegistrationHandle> original_handle =
-      callback_registration_handle_.Pass();
+      std::move(callback_registration_handle_);
 
   // The next registration won't block.
   InitSyncEventTest();
 
   // Overwrite the firing registration.
   sync_options_1_.power_state = POWER_STATE_AUTO;
   EXPECT_TRUE(Register(sync_options_1_));
   EXPECT_FALSE(NotifyWhenFinished(original_handle.get()));
 
   // Fail the first event.
@@ skipping 570 matching lines @@
   // Run it again.
   test_clock_->Advance(test_background_sync_manager_->delayed_task_delta());
   test_background_sync_manager_->delayed_task().Run();
   base::RunLoop().RunUntilIdle();
   EXPECT_FALSE(GetRegistration(sync_options_1_));
   EXPECT_EQ(BACKGROUND_SYNC_EVENT_LAST_CHANCE_IS_LAST_CHANCE,
             test_background_sync_manager_->last_chance());
 }
 
 }  // namespace content