Convert //components/proximity_auth from scoped_ptr to std::unique_ptr

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/ptr_util.h"
 #include "base/memory/weak_ptr.h"
 #include "base/test/simple_test_clock.h"
 #include "base/time/clock.h"
 #include "base/time/time.h"
 #include "components/prefs/testing_pref_service.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"
 #include "components/proximity_auth/cryptauth/mock_sync_scheduler.h"
 #include "components/proximity_auth/cryptauth/pref_names.h"
@@ skipping 48 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 {
+  std::unique_ptr<CryptAuthEnroller> CreateInstance() override {
     auto passed_cryptauth_enroller = std::move(next_cryptauth_enroller_);
     next_cryptauth_enroller_.reset(new NiceMock<MockCryptAuthEnroller>());
     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_;
+  std::unique_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,
+      std::unique_ptr<base::Clock> clock,
+      std::unique_ptr<CryptAuthEnrollerFactory> enroller_factory,
+      std::unique_ptr<SecureMessageDelegate> secure_message_delegate,
       const cryptauth::GcmDeviceInfo& device_info,
       CryptAuthGCMManager* gcm_manager,
       PrefService* pref_service)
       : 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 {
+  std::unique_ptr<SyncScheduler> CreateSyncScheduler() override {
     EXPECT_TRUE(scoped_sync_scheduler_);
     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_;
+  std::unique_ptr<MockSyncScheduler> scoped_sync_scheduler_;
 
   // Stores the pointer of |scoped_sync_scheduler_| after ownership is passed to
   // the super class.
   // This should be safe because the life-time this SyncScheduler will always be
   // within the life of the TestCryptAuthEnrollmentManager object.
   base::WeakPtrFactory<MockSyncScheduler> weak_sync_scheduler_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(TestCryptAuthEnrollmentManager);
 };
 
 }  // namespace
 
 class ProximityAuthCryptAuthEnrollmentManagerTest
     : public testing::Test,
       public CryptAuthEnrollmentManager::Observer {
  protected:
   ProximityAuthCryptAuthEnrollmentManagerTest()
       : public_key_(kUserPublicKey),
         clock_(new base::SimpleTestClock()),
         enroller_factory_(new MockCryptAuthEnrollerFactory()),
         secure_message_delegate_(new FakeSecureMessageDelegate()),
         gcm_manager_(kGCMRegistrationId),
-        enrollment_manager_(make_scoped_ptr(clock_),
-                            make_scoped_ptr(enroller_factory_),
-                            make_scoped_ptr(secure_message_delegate_),
+        enrollment_manager_(base::WrapUnique(clock_),
+                            base::WrapUnique(enroller_factory_),
+                            base::WrapUnique(secure_message_delegate_),
                             device_info_,
                             &gcm_manager_,
                             &pref_service_) {}
 
   // testing::Test:
   void SetUp() override {
     clock_->SetNow(base::Time::FromDoubleT(kInitialTimeNowSeconds));
     enrollment_manager_.AddObserver(this);
 
     private_key_ =
@@ skipping 47 matching lines @@
 
   // Simulates firing the SyncScheduler to trigger an enrollment attempt.
   CryptAuthEnroller::EnrollmentFinishedCallback FireSchedulerForEnrollment(
       cryptauth::InvocationReason expected_invocation_reason) {
     CryptAuthEnroller::EnrollmentFinishedCallback completion_callback;
     EXPECT_CALL(
         *next_cryptauth_enroller(),
         Enroll(public_key_, private_key_, _, expected_invocation_reason, _))
         .WillOnce(SaveArg<4>(&completion_callback));
 
-    auto sync_request = make_scoped_ptr(
+    auto sync_request = base::WrapUnique(
         new SyncScheduler::SyncRequest(enrollment_manager_.GetSyncScheduler()));
     EXPECT_CALL(*this, OnEnrollmentStartedProxy());
 
     SyncScheduler::Delegate* delegate =
         static_cast<SyncScheduler::Delegate*>(&enrollment_manager_);
     delegate->OnSyncRequested(std::move(sync_request));
 
     return completion_callback;
   }
 
@@ skipping 58 matching lines @@
   ON_CALL(*sync_scheduler(), GetSyncState())
       .WillByDefault(Return(SyncScheduler::SyncState::SYNC_IN_PROGRESS));
   EXPECT_TRUE(enrollment_manager_.IsEnrollmentInProgress());
 
   ON_CALL(*sync_scheduler(), GetSyncState())
       .WillByDefault(Return(SyncScheduler::SyncState::WAITING_FOR_REFRESH));
   EXPECT_FALSE(enrollment_manager_.IsEnrollmentInProgress());
 }
 
 TEST_F(ProximityAuthCryptAuthEnrollmentManagerTest, InitWithDefaultPrefs) {
-  scoped_ptr<base::SimpleTestClock> clock(new base::SimpleTestClock());
+  std::unique_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(
-      std::move(clock), make_scoped_ptr(new MockCryptAuthEnrollerFactory()),
-      make_scoped_ptr(new FakeSecureMessageDelegate()), device_info_,
+      std::move(clock), base::WrapUnique(new MockCryptAuthEnrollerFactory()),
+      base::WrapUnique(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 79 matching lines @@
       .WillByDefault(Return(SyncScheduler::Strategy::PERIODIC_REFRESH));
   gcm_manager_.set_registration_id(std::string());
   pref_service_.ClearPref(prefs::kCryptAuthEnrollmentUserPublicKey);
   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(
+  auto sync_request = base::WrapUnique(
       new SyncScheduler::SyncRequest(enrollment_manager_.GetSyncScheduler()));
   static_cast<SyncScheduler::Delegate*>(&enrollment_manager_)
       ->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));
@@ skipping 15 matching lines @@
 
 TEST_F(ProximityAuthCryptAuthEnrollmentManagerTest, GCMRegistrationFails) {
   // Initialize |enrollment_manager_|.
   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(
+  auto sync_request = base::WrapUnique(
       new SyncScheduler::SyncRequest(enrollment_manager_.GetSyncScheduler()));
   static_cast<SyncScheduler::Delegate*>(&enrollment_manager_)
       ->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