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

components/proximity_auth/cryptauth/cryptauth_enrollment_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_enrollment_manager.h"
 
+#include <utility>
+
 #include "base/base64url.h"
 #include "base/macros.h"
 #include "base/memory/weak_ptr.h"
 #include "base/prefs/testing_pref_service.h"
 #include "base/test/simple_test_clock.h"
 #include "base/time/clock.h"
 #include "base/time/time.h"
 #include "components/proximity_auth/cryptauth/cryptauth_enroller.h"
 #include "components/proximity_auth/cryptauth/fake_cryptauth_gcm_manager.h"
 #include "components/proximity_auth/cryptauth/fake_secure_message_delegate.h"
@@ skipping 51 matching lines @@
 // Creates MockCryptAuthEnroller instances, and allows expecations to be set
 // before they are returned.
 class MockCryptAuthEnrollerFactory : public CryptAuthEnrollerFactory {
  public:
   MockCryptAuthEnrollerFactory()
       : next_cryptauth_enroller_(new NiceMock<MockCryptAuthEnroller>()) {}
   ~MockCryptAuthEnrollerFactory() override {}
 
   // CryptAuthEnrollerFactory:
   scoped_ptr<CryptAuthEnroller> CreateInstance() override {
-    auto passed_cryptauth_enroller = next_cryptauth_enroller_.Pass();
+    auto passed_cryptauth_enroller = std::move(next_cryptauth_enroller_);
     next_cryptauth_enroller_.reset(new NiceMock<MockCryptAuthEnroller>());
-    return passed_cryptauth_enroller.Pass();
+    return std::move(passed_cryptauth_enroller);
   }
 
   MockCryptAuthEnroller* next_cryptauth_enroller() {
     return next_cryptauth_enroller_.get();
   }
 
  private:
   // Stores the next CryptAuthEnroller to be created.
   // Ownership is passed to the caller of |CreateInstance()|.
   scoped_ptr<MockCryptAuthEnroller> next_cryptauth_enroller_;
 
   DISALLOW_COPY_AND_ASSIGN(MockCryptAuthEnrollerFactory);
 };
 
 // Harness for testing CryptAuthEnrollmentManager.
 class TestCryptAuthEnrollmentManager : public CryptAuthEnrollmentManager {
  public:
   TestCryptAuthEnrollmentManager(
       scoped_ptr<base::Clock> clock,
       scoped_ptr<CryptAuthEnrollerFactory> enroller_factory,
       scoped_ptr<SecureMessageDelegate> secure_message_delegate,
       const cryptauth::GcmDeviceInfo& device_info,
       CryptAuthGCMManager* gcm_manager,
       PrefService* pref_service)
-      : CryptAuthEnrollmentManager(clock.Pass(),
-                                   enroller_factory.Pass(),
-                                   secure_message_delegate.Pass(),
+      : CryptAuthEnrollmentManager(std::move(clock),
+                                   std::move(enroller_factory),
+                                   std::move(secure_message_delegate),
                                    device_info,
                                    gcm_manager,
                                    pref_service),
         scoped_sync_scheduler_(new NiceMock<MockSyncScheduler>()),
         weak_sync_scheduler_factory_(scoped_sync_scheduler_.get()) {}
 
   ~TestCryptAuthEnrollmentManager() 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 |CryptAuthEnrollmentManager| super class when
   // |CreateSyncScheduler()| is called.
   scoped_ptr<MockSyncScheduler> scoped_sync_scheduler_;
@@ skipping 88 matching lines @@
         *next_cryptauth_enroller(),
         Enroll(public_key_, private_key_, _, expected_invocation_reason, _))
         .WillOnce(SaveArg<4>(&completion_callback));
 
     auto sync_request = make_scoped_ptr(
         new SyncScheduler::SyncRequest(enrollment_manager_.GetSyncScheduler()));
     EXPECT_CALL(*this, OnEnrollmentStartedProxy());
 
     SyncScheduler::Delegate* delegate =
         static_cast<SyncScheduler::Delegate*>(&enrollment_manager_);
-    delegate->OnSyncRequested(sync_request.Pass());
+    delegate->OnSyncRequested(std::move(sync_request));
 
     return completion_callback;
   }
 
   MockSyncScheduler* sync_scheduler() {
     return enrollment_manager_.GetSyncScheduler().get();
   }
 
   MockCryptAuthEnroller* next_cryptauth_enroller() {
     return enroller_factory_->next_cryptauth_enroller();
@@ skipping 60 matching lines @@
 
 TEST_F(ProximityAuthCryptAuthEnrollmentManagerTest, 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;
   CryptAuthEnrollmentManager::RegisterPrefs(pref_service.registry());
 
   TestCryptAuthEnrollmentManager enrollment_manager(
-      clock.Pass(), make_scoped_ptr(new MockCryptAuthEnrollerFactory()),
+      std::move(clock), make_scoped_ptr(new MockCryptAuthEnrollerFactory()),
       make_scoped_ptr(new FakeSecureMessageDelegate()), device_info_,
       &gcm_manager_, &pref_service);
 
   EXPECT_CALL(
       *enrollment_manager.GetSyncScheduler(),
       Start(elapsed_time, SyncScheduler::Strategy::AGGRESSIVE_RECOVERY));
   enrollment_manager.Start();
 
   EXPECT_FALSE(enrollment_manager.IsEnrollmentValid());
   EXPECT_TRUE(enrollment_manager.GetLastEnrollmentTime().is_null());
@@ skipping 83 matching lines @@
   pref_service_.ClearPref(prefs::kCryptAuthEnrollmentUserPrivateKey);
   pref_service_.ClearPref(prefs::kCryptAuthEnrollmentLastEnrollmentTimeSeconds);
   enrollment_manager_.Start();
   EXPECT_FALSE(enrollment_manager_.IsEnrollmentValid());
 
   // Trigger a sync request.
   EXPECT_CALL(*this, OnEnrollmentStartedProxy());
   auto sync_request = make_scoped_ptr(
       new SyncScheduler::SyncRequest(enrollment_manager_.GetSyncScheduler()));
   static_cast<SyncScheduler::Delegate*>(&enrollment_manager_)
-      ->OnSyncRequested(sync_request.Pass());
+      ->OnSyncRequested(std::move(sync_request));
 
   // Complete GCM registration successfully, and expect an enrollment.
   CryptAuthEnroller::EnrollmentFinishedCallback enrollment_callback;
   EXPECT_CALL(*next_cryptauth_enroller(),
               Enroll(public_key_, private_key_, _,
                      cryptauth::INVOCATION_REASON_INITIALIZATION, _))
       .WillOnce(SaveArg<4>(&enrollment_callback));
   ASSERT_TRUE(gcm_manager_.registration_in_progress());
   gcm_manager_.CompleteRegistration(kGCMRegistrationId);
 
@@ skipping 15 matching lines @@
   ON_CALL(*sync_scheduler(), GetStrategy())
       .WillByDefault(Return(SyncScheduler::Strategy::PERIODIC_REFRESH));
   gcm_manager_.set_registration_id(std::string());
   enrollment_manager_.Start();
 
   // Trigger a sync request.
   EXPECT_CALL(*this, OnEnrollmentStartedProxy());
   auto sync_request = make_scoped_ptr(
       new SyncScheduler::SyncRequest(enrollment_manager_.GetSyncScheduler()));
   static_cast<SyncScheduler::Delegate*>(&enrollment_manager_)
-      ->OnSyncRequested(sync_request.Pass());
+      ->OnSyncRequested(std::move(sync_request));
 
   // Complete GCM registration with failure.
   EXPECT_CALL(*this, OnEnrollmentFinishedProxy(false));
   gcm_manager_.CompleteRegistration(std::string());
 }
 
 TEST_F(ProximityAuthCryptAuthEnrollmentManagerTest, ReenrollOnGCMPushMessage) {
   enrollment_manager_.Start();
 
   // Simulate receiving a GCM push message, forcing the device to re-enroll.
   gcm_manager_.PushReenrollMessage();
   auto completion_callback =
       FireSchedulerForEnrollment(cryptauth::INVOCATION_REASON_SERVER_INITIATED);
 
   EXPECT_CALL(*this, OnEnrollmentFinishedProxy(true));
   completion_callback.Run(true);
 }
 
 }  // namespace proximity_auth