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

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/ptr_util.h"
 #include "base/memory/weak_ptr.h"
 #include "base/strings/stringprintf.h"
 #include "base/test/simple_test_clock.h"
 #include "components/prefs/scoped_user_pref_update.h"
 #include "components/prefs/testing_pref_service.h"
 #include "components/proximity_auth/cryptauth/fake_cryptauth_gcm_manager.h"
 #include "components/proximity_auth/cryptauth/mock_cryptauth_client.h"
 #include "components/proximity_auth/cryptauth/mock_sync_scheduler.h"
 #include "components/proximity_auth/cryptauth/pref_names.h"
 #include "testing/gmock/include/gmock/gmock.h"
@@ skipping 84 matching lines @@
     EXPECT_EQ(expected_unlock_key.friendly_device_name(), device_name);
     EXPECT_EQ(expected_unlock_key.bluetooth_address(), bluetooth_address);
     EXPECT_TRUE(expected_unlock_key.unlock_key());
     EXPECT_FALSE(expected_unlock_key.unlockable());
   }
 }
 
 // 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)
+  TestCryptAuthDeviceManager(
+      std::unique_ptr<base::Clock> clock,
+      std::unique_ptr<CryptAuthClientFactory> client_factory,
+      CryptAuthGCMManager* gcm_manager,
+      PrefService* pref_service)
       : 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 {
+  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 |CryptAuthDeviceManager| 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 TestCryptAuthDeviceManager object.
   base::WeakPtrFactory<MockSyncScheduler> weak_sync_scheduler_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(TestCryptAuthDeviceManager);
 };
 
@@ skipping 23 matching lines @@
     CryptAuthDeviceManager::RegisterPrefs(pref_service_.registry());
     pref_service_.SetUserPref(
         prefs::kCryptAuthDeviceSyncIsRecoveringFromFailure,
         new base::FundamentalValue(false));
     pref_service_.SetUserPref(prefs::kCryptAuthDeviceSyncLastSyncTimeSeconds,
                               new base::FundamentalValue(kLastSyncTimeSeconds));
     pref_service_.SetUserPref(
         prefs::kCryptAuthDeviceSyncReason,
         new base::FundamentalValue(cryptauth::INVOCATION_REASON_UNKNOWN));
 
-    scoped_ptr<base::DictionaryValue> unlock_key_dictionary(
+    std::unique_ptr<base::DictionaryValue> unlock_key_dictionary(
         new base::DictionaryValue());
 
     std::string public_key_b64, device_name_b64, bluetooth_address_b64;
     base::Base64UrlEncode(kStoredPublicKey,
                           base::Base64UrlEncodePolicy::INCLUDE_PADDING,
                           &public_key_b64);
     base::Base64UrlEncode(kStoredDeviceName,
                           base::Base64UrlEncodePolicy::INCLUDE_PADDING,
                           &device_name_b64);
     base::Base64UrlEncode(kStoredBluetoothAddress,
                           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(std::move(unlock_key_dictionary));
     }
 
     device_manager_.reset(new TestCryptAuthDeviceManager(
-        make_scoped_ptr(clock_), make_scoped_ptr(client_factory_),
+        base::WrapUnique(clock_), base::WrapUnique(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);
     unlock_key.set_bluetooth_address(kBluetoothAddress1);
     unlock_key.set_unlock_key(true);
     unlock_key.set_unlockable(false);
 
@@ skipping 25 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());
 
-    scoped_ptr<SyncScheduler::SyncRequest> sync_request = make_scoped_ptr(
+    std::unique_ptr<SyncScheduler::SyncRequest> sync_request = base::WrapUnique(
         new 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) !=
@@ skipping 16 matching lines @@
   // Owned by |device_manager_|.
   base::SimpleTestClock* clock_;
 
   // Owned by |device_manager_|.
   MockCryptAuthClientFactory* client_factory_;
 
   TestingPrefServiceSimple pref_service_;
 
   FakeCryptAuthGCMManager gcm_manager_;
 
-  scoped_ptr<TestCryptAuthDeviceManager> device_manager_;
+  std::unique_ptr<TestCryptAuthDeviceManager> device_manager_;
 
   cryptauth::GetMyDevicesResponse get_my_devices_response_;
 
   cryptauth::GetMyDevicesRequest get_my_devices_request_;
 
   CryptAuthClient::GetMyDevicesCallback success_callback_;
 
   CryptAuthClient::ErrorCallback error_callback_;
 
   DISALLOW_COPY_AND_ASSIGN(ProximityAuthCryptAuthDeviceManagerTest);
@@ skipping 30 matching lines @@
   ON_CALL(*sync_scheduler(), GetSyncState())
       .WillByDefault(Return(SyncScheduler::SyncState::SYNC_IN_PROGRESS));
   EXPECT_TRUE(device_manager_->IsSyncInProgress());
 
   ON_CALL(*sync_scheduler(), GetSyncState())
       .WillByDefault(Return(SyncScheduler::SyncState::WAITING_FOR_REFRESH));
   EXPECT_FALSE(device_manager_->IsSyncInProgress());
 }
 
 TEST_F(ProximityAuthCryptAuthDeviceManagerTest, 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;
   CryptAuthDeviceManager::RegisterPrefs(pref_service.registry());
 
   TestCryptAuthDeviceManager device_manager(
       std::move(clock),
-      make_scoped_ptr(new MockCryptAuthClientFactory(
+      base::WrapUnique(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 232 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