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

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>
 
@@ skipping 238 matching lines @@
   MOCK_METHOD2(OnSyncFinishedProxy,
                void(CryptAuthDeviceManager::SyncResult,
                     CryptAuthDeviceManager::DeviceChangeResult));
 
   // 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());
 
-    std::unique_ptr<SyncScheduler::SyncRequest> sync_request = base::WrapUnique(
-        new SyncScheduler::SyncRequest(device_manager_->GetSyncScheduler()));
+    std::unique_ptr<SyncScheduler::SyncRequest> sync_request =
+        base::MakeUnique<SyncScheduler::SyncRequest>(
+            device_manager_->GetSyncScheduler());
     EXPECT_CALL(*this, OnSyncStartedProxy());
     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;
@@ skipping 75 matching lines @@
 TEST_F(ProximityAuthCryptAuthDeviceManagerTest, 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;
   CryptAuthDeviceManager::RegisterPrefs(pref_service.registry());
 
   TestCryptAuthDeviceManager device_manager(
       std::move(clock),
-      base::WrapUnique(new MockCryptAuthClientFactory(
-          MockCryptAuthClientFactory::MockType::MAKE_STRICT_MOCKS)),
+      base::MakeUnique<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 231 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