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

components/proximity_auth/cryptauth/cryptauth_device_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 "components/proximity_auth/cryptauth/cryptauth_device_manager.h"
 
 #include <stddef.h>
+#include <utility>
 
 #include "base/base64url.h"
 #include "base/macros.h"
 #include "base/memory/weak_ptr.h"
 #include "base/prefs/scoped_user_pref_update.h"
 #include "base/prefs/testing_pref_service.h"
 #include "base/strings/stringprintf.h"
 #include "base/test/simple_test_clock.h"
 #include "components/proximity_auth/cryptauth/fake_cryptauth_gcm_manager.h"
 #include "components/proximity_auth/cryptauth/mock_cryptauth_client.h"
@@ skipping 91 matching lines @@
   }
 }
 
 // Harness for testing CryptAuthDeviceManager.
 class TestCryptAuthDeviceManager : public CryptAuthDeviceManager {
  public:
   TestCryptAuthDeviceManager(scoped_ptr<base::Clock> clock,
                              scoped_ptr<CryptAuthClientFactory> client_factory,
                              CryptAuthGCMManager* gcm_manager,
                              PrefService* pref_service)
-      : CryptAuthDeviceManager(clock.Pass(),
-                               client_factory.Pass(),
+      : CryptAuthDeviceManager(std::move(clock),
+                               std::move(client_factory),
                                gcm_manager,
                                pref_service),
         scoped_sync_scheduler_(new NiceMock<MockSyncScheduler>()),
         weak_sync_scheduler_factory_(scoped_sync_scheduler_.get()) {}
 
   ~TestCryptAuthDeviceManager() override {}
 
   scoped_ptr<SyncScheduler> CreateSyncScheduler() override {
     EXPECT_TRUE(scoped_sync_scheduler_);
-    return scoped_sync_scheduler_.Pass();
+    return std::move(scoped_sync_scheduler_);
   }
 
   base::WeakPtr<MockSyncScheduler> GetSyncScheduler() {
     return weak_sync_scheduler_factory_.GetWeakPtr();
   }
 
  private:
   // Ownership is passed to |CryptAuthDeviceManager| super class when
   // |CreateSyncScheduler()| is called.
   scoped_ptr<MockSyncScheduler> scoped_sync_scheduler_;
@@ skipping 54 matching lines @@
                           base::Base64UrlEncodePolicy::INCLUDE_PADDING,
                           &bluetooth_address_b64);
 
     unlock_key_dictionary->SetString("public_key", public_key_b64);
     unlock_key_dictionary->SetString("device_name", device_name_b64);
     unlock_key_dictionary->SetString("bluetooth_address",
                                      bluetooth_address_b64);
     {
       ListPrefUpdate update(&pref_service_,
                             prefs::kCryptAuthDeviceSyncUnlockKeys);
-      update.Get()->Append(unlock_key_dictionary.Pass());
+      update.Get()->Append(std::move(unlock_key_dictionary));
     }
 
     device_manager_.reset(new TestCryptAuthDeviceManager(
         make_scoped_ptr(clock_), make_scoped_ptr(client_factory_),
         &gcm_manager_, &pref_service_));
     device_manager_->AddObserver(this);
 
     cryptauth::ExternalDeviceInfo unlock_key;
     unlock_key.set_public_key(kPublicKey1);
     unlock_key.set_friendly_device_name(kDeviceName1);
@@ skipping 32 matching lines @@
 
   // Simulates firing the SyncScheduler to trigger a device sync attempt.
   void FireSchedulerForSync(
       cryptauth::InvocationReason expected_invocation_reason) {
     SyncScheduler::Delegate* delegate =
         static_cast<SyncScheduler::Delegate*>(device_manager_.get());
 
     scoped_ptr<SyncScheduler::SyncRequest> sync_request = make_scoped_ptr(
         new SyncScheduler::SyncRequest(device_manager_->GetSyncScheduler()));
     EXPECT_CALL(*this, OnSyncStartedProxy());
-    delegate->OnSyncRequested(sync_request.Pass());
+    delegate->OnSyncRequested(std::move(sync_request));
 
     EXPECT_EQ(expected_invocation_reason,
               get_my_devices_request_.invocation_reason());
 
     // The allow_stale_read flag is set if the sync was not forced.
     bool allow_stale_read =
         pref_service_.GetInteger(prefs::kCryptAuthDeviceSyncReason) !=
         cryptauth::INVOCATION_REASON_UNKNOWN;
     EXPECT_EQ(allow_stale_read, get_my_devices_request_.allow_stale_read());
   }
@@ skipping 72 matching lines @@
 
 TEST_F(ProximityAuthCryptAuthDeviceManagerTest, InitWithDefaultPrefs) {
   scoped_ptr<base::SimpleTestClock> clock(new base::SimpleTestClock);
   clock->SetNow(base::Time::FromDoubleT(kInitialTimeNowSeconds));
   base::TimeDelta elapsed_time = clock->Now() - base::Time::FromDoubleT(0);
 
   TestingPrefServiceSimple pref_service;
   CryptAuthDeviceManager::RegisterPrefs(pref_service.registry());
 
   TestCryptAuthDeviceManager device_manager(
-      clock.Pass(),
+      std::move(clock),
       make_scoped_ptr(new MockCryptAuthClientFactory(
           MockCryptAuthClientFactory::MockType::MAKE_STRICT_MOCKS)),
       &gcm_manager_, &pref_service);
 
   EXPECT_CALL(
       *(device_manager.GetSyncScheduler()),
       Start(elapsed_time, SyncScheduler::Strategy::AGGRESSIVE_RECOVERY));
   device_manager.Start();
   EXPECT_TRUE(device_manager.GetLastSyncTime().is_null());
   EXPECT_EQ(0u, device_manager.unlock_keys().size());
@@ skipping 233 matching lines @@
                          CryptAuthDeviceManager::DeviceChangeResult::CHANGED));
   success_callback_.Run(get_my_devices_response_);
 
   ExpectUnlockKeysAndPrefAreEqual(std::vector<cryptauth::ExternalDeviceInfo>(
                                       1, get_my_devices_response_.devices(0)),
                                   device_manager_->unlock_keys(),
                                   pref_service_);
 }
 
 }  // namespace proximity_auth