Re-write many calls to WrapUnique() with MakeUnique()

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"
@@ skipping 203 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 = base::WrapUnique(
-        new SyncScheduler::SyncRequest(enrollment_manager_.GetSyncScheduler()));
+    auto sync_request = base::MakeUnique<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;
   }
 
   MockSyncScheduler* sync_scheduler() {
@@ skipping 65 matching lines @@
 
 TEST_F(ProximityAuthCryptAuthEnrollmentManagerTest, InitWithDefaultPrefs) {
   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), base::WrapUnique(new MockCryptAuthEnrollerFactory()),
-      base::WrapUnique(new FakeSecureMessageDelegate()), device_info_,
+      std::move(clock), base::MakeUnique<MockCryptAuthEnrollerFactory>(),
+      base::MakeUnique<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 = base::WrapUnique(
-      new SyncScheduler::SyncRequest(enrollment_manager_.GetSyncScheduler()));
+  auto sync_request = base::MakeUnique<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));
   ASSERT_TRUE(gcm_manager_.registration_in_progress());
@@ skipping 14 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 = base::WrapUnique(
-      new SyncScheduler::SyncRequest(enrollment_manager_.GetSyncScheduler()));
+  auto sync_request = base::MakeUnique<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