Use the shared instance of base::Default{,Tick}Clock in //components/cryptauth

This CL changes the ownership of base::Clock and base::TickClock from
injectee-owned to injecter-owned. Before this CL, these instances are
owned by the owner of the injectee or one of the injectees themselves.
That makes the ownership complex.

After this CL, the clock instances are always un-owned by injectees.
Instead, an injecter owned one is used on testing, and the shared
instance is used on production path.

Bug: 789079
Change-Id: Iff3360eb8b4d08934882cd84afc8d4d0626b456e
Reviewed-on: https://chromium-review.googlesource.com/795403Reviewed-by: Kyle Horimoto <khorimoto@chromium.org>
Commit-Queue: Taiju Tsuiki <tzik@chromium.org>
Cr-Commit-Position: refs/heads/master@{#520234}

chrome/browser/cryptauth/chrome_cryptauth_service.cc

@@ -175,13 +175,13 @@ std::unique_ptr<ChromeCryptAuthService> ChromeCryptAuthService::Create(
 
   std::unique_ptr<cryptauth::CryptAuthDeviceManager> device_manager =
       base::MakeUnique<cryptauth::CryptAuthDeviceManager>(
-          base::MakeUnique<base::DefaultClock>(),
+          base::DefaultClock::GetInstance(),
           CreateCryptAuthClientFactoryImpl(profile), gcm_manager.get(),
           profile->GetPrefs());
 
   std::unique_ptr<cryptauth::CryptAuthEnrollmentManager> enrollment_manager =
       base::MakeUnique<cryptauth::CryptAuthEnrollmentManager>(
-          base::MakeUnique<base::DefaultClock>(),
+          base::DefaultClock::GetInstance(),
           base::MakeUnique<CryptAuthEnrollerFactoryImpl>(profile),
           CreateSecureMessageDelegateImpl(), GetGcmDeviceInfo(),
           gcm_manager.get(), profile->GetPrefs());

components/cryptauth/background_eid_generator.cc

@@ -44,15 +44,14 @@ const BeaconSeed* GetBeaconSeedForTimestamp(
 
 BackgroundEidGenerator::BackgroundEidGenerator()
     : BackgroundEidGenerator(base::MakeUnique<RawEidGeneratorImpl>(),
-                             base::MakeUnique<base::DefaultClock>()) {}
+                             base::DefaultClock::GetInstance()) {}
 
 BackgroundEidGenerator::~BackgroundEidGenerator() {}
 
 BackgroundEidGenerator::BackgroundEidGenerator(
     std::unique_ptr<RawEidGenerator> raw_eid_generator,
-    std::unique_ptr<base::Clock> clock)
-    : raw_eid_generator_(std::move(raw_eid_generator)),
-      clock_(std::move(clock)) {}
+    base::Clock* clock)
+    : raw_eid_generator_(std::move(raw_eid_generator)), clock_(clock) {}
 
 std::vector<DataWithTimestamp> BackgroundEidGenerator::GenerateNearestEids(
     const std::vector<BeaconSeed>& beacon_seeds) const {

components/cryptauth/background_eid_generator.h

@@ -40,7 +40,7 @@ class BackgroundEidGenerator {
  private:
   friend class CryptAuthBackgroundEidGeneratorTest;
   BackgroundEidGenerator(std::unique_ptr<RawEidGenerator> raw_eid_generator,
-                         std::unique_ptr<base::Clock> clock);
+                         base::Clock* clock);
 
   // Helper function to generate the EID for any |timestamp_ms|, properly
   // calculating the start of the period. Returns nullptr if |timestamp_ms| is
@@ -50,7 +50,7 @@ class BackgroundEidGenerator {
       const std::vector<BeaconSeed>& beacon_seeds) const;
 
   std::unique_ptr<RawEidGenerator> raw_eid_generator_;
-  std::unique_ptr<base::Clock> clock_;
+  base::Clock* clock_;
 
   DISALLOW_COPY_AND_ASSIGN(BackgroundEidGenerator);
 };

components/cryptauth/background_eid_generator_unittest.cc

@@ -91,23 +91,20 @@ class CryptAuthBackgroundEidGeneratorTest : public testing::Test {
   }
 
   void SetUp() override {
-    test_clock_ = new base::SimpleTestClock();
-
     SetTestTime(kCurrentTimeMs);
 
-    eid_generator_.reset(
-        new BackgroundEidGenerator(base::MakeUnique<TestRawEidGenerator>(),
-                                   base::WrapUnique(test_clock_)));
+    eid_generator_.reset(new BackgroundEidGenerator(
+        base::MakeUnique<TestRawEidGenerator>(), &test_clock_));
   }
 
   void SetTestTime(int64_t timestamp_ms) {
     base::Time time = base::Time::UnixEpoch() +
                       base::TimeDelta::FromMilliseconds(timestamp_ms);
-    test_clock_->SetNow(time);
+    test_clock_.SetNow(time);
   }
 
   std::unique_ptr<BackgroundEidGenerator> eid_generator_;
-  base::SimpleTestClock* test_clock_;
+  base::SimpleTestClock test_clock_;
   std::vector<BeaconSeed> beacon_seeds_;
 };
 

components/cryptauth/cryptauth_device_manager.cc

@@ -325,11 +325,11 @@ std::unique_ptr<SyncSchedulerImpl> CreateSyncScheduler(
 }  // namespace
 
 CryptAuthDeviceManager::CryptAuthDeviceManager(
-    std::unique_ptr<base::Clock> clock,
+    base::Clock* clock,
     std::unique_ptr<CryptAuthClientFactory> client_factory,
     CryptAuthGCMManager* gcm_manager,
     PrefService* pref_service)
-    : clock_(std::move(clock)),
+    : clock_(clock),
       client_factory_(std::move(client_factory)),
       gcm_manager_(gcm_manager),
       pref_service_(pref_service),

components/cryptauth/cryptauth_device_manager.h

@@ -65,7 +65,7 @@ class CryptAuthDeviceManager : public SyncScheduler::Delegate,
   // |pref_service|: Stores syncing metadata and unlock key information to
   //                 persist across browser restarts. Must already be registered
   //                 with RegisterPrefs().
-  CryptAuthDeviceManager(std::unique_ptr<base::Clock> clock,
+  CryptAuthDeviceManager(base::Clock* clock,
                          std::unique_ptr<CryptAuthClientFactory> client_factory,
                          CryptAuthGCMManager* gcm_manager,
                          PrefService* pref_service);
@@ -149,7 +149,7 @@ class CryptAuthDeviceManager : public SyncScheduler::Delegate,
   void OnGetMyDevicesFailure(const std::string& error);
 
   // Used to determine the time.
-  std::unique_ptr<base::Clock> clock_;
+  base::Clock* clock_;
 
   // Creates CryptAuthClient instances for each sync attempt.
   std::unique_ptr<CryptAuthClientFactory> client_factory_;

components/cryptauth/cryptauth_device_manager_unittest.cc

@@ -293,11 +293,11 @@ void ExpectSyncedDevicesAndPrefAreEqual(
 class TestCryptAuthDeviceManager : public CryptAuthDeviceManager {
  public:
   TestCryptAuthDeviceManager(
-      std::unique_ptr<base::Clock> clock,
+      base::Clock* clock,
       std::unique_ptr<CryptAuthClientFactory> client_factory,
       CryptAuthGCMManager* gcm_manager,
       PrefService* pref_service)
-      : CryptAuthDeviceManager(std::move(clock),
+      : CryptAuthDeviceManager(clock,
                                std::move(client_factory),
                                gcm_manager,
                                pref_service),
@@ -334,8 +334,7 @@ class CryptAuthDeviceManagerTest
       public MockCryptAuthClientFactory::Observer {
  protected:
   CryptAuthDeviceManagerTest()
-      : clock_(new base::SimpleTestClock()),
-        client_factory_(new MockCryptAuthClientFactory(
+      : client_factory_(new MockCryptAuthClientFactory(
             MockCryptAuthClientFactory::MockType::MAKE_STRICT_MOCKS)),
         gcm_manager_("existing gcm registration id") {
     client_factory_->AddObserver(this);
@@ -384,7 +383,7 @@ class CryptAuthDeviceManagerTest
 
   // testing::Test:
   void SetUp() override {
-    clock_->SetNow(base::Time::FromDoubleT(kInitialTimeNowSeconds));
+    clock_.SetNow(base::Time::FromDoubleT(kInitialTimeNowSeconds));
 
     CryptAuthDeviceManager::RegisterPrefs(pref_service_.registry());
     pref_service_.SetUserPref(
@@ -427,8 +426,8 @@ class CryptAuthDeviceManagerTest
     }
 
     device_manager_.reset(new TestCryptAuthDeviceManager(
-        base::WrapUnique(clock_), base::WrapUnique(client_factory_),
-        &gcm_manager_, &pref_service_));
+        &clock_, base::WrapUnique(client_factory_), &gcm_manager_,
+        &pref_service_));
     device_manager_->AddObserver(this);
 
     get_my_devices_response_.add_devices()->CopyFrom(devices_in_response_[0]);
@@ -488,8 +487,7 @@ class CryptAuthDeviceManagerTest
     return device_manager_->GetSyncScheduler().get();
   }
 
-  // Owned by |device_manager_|.
-  base::SimpleTestClock* clock_;
+  base::SimpleTestClock clock_;
 
   // Owned by |device_manager_|.
   MockCryptAuthClientFactory* client_factory_;
@@ -551,15 +549,15 @@ TEST_F(CryptAuthDeviceManagerTest, GetSyncState) {
 }
 
 TEST_F(CryptAuthDeviceManagerTest, 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);
+  base::SimpleTestClock clock;
+  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),
+      &clock,
       base::MakeUnique<MockCryptAuthClientFactory>(
           MockCryptAuthClientFactory::MockType::MAKE_STRICT_MOCKS),
       &gcm_manager_, &pref_service);
@@ -575,7 +573,7 @@ TEST_F(CryptAuthDeviceManagerTest, InitWithDefaultPrefs) {
 TEST_F(CryptAuthDeviceManagerTest, InitWithExistingPrefs) {
   EXPECT_CALL(
       *sync_scheduler(),
-      Start(clock_->Now() - base::Time::FromDoubleT(kLastSyncTimeSeconds),
+      Start(clock_.Now() - base::Time::FromDoubleT(kLastSyncTimeSeconds),
             SyncScheduler::Strategy::PERIODIC_REFRESH));
 
   device_manager_->Start();
@@ -598,13 +596,13 @@ TEST_F(CryptAuthDeviceManagerTest, SyncSucceedsForFirstTime) {
   FireSchedulerForSync(INVOCATION_REASON_INITIALIZATION);
   ASSERT_FALSE(success_callback_.is_null());
 
-  clock_->SetNow(base::Time::FromDoubleT(kLaterTimeNowSeconds));
+  clock_.SetNow(base::Time::FromDoubleT(kLaterTimeNowSeconds));
   EXPECT_CALL(*this, OnSyncFinishedProxy(
                          CryptAuthDeviceManager::SyncResult::SUCCESS,
                          CryptAuthDeviceManager::DeviceChangeResult::CHANGED));
 
   success_callback_.Run(get_my_devices_response_);
-  EXPECT_EQ(clock_->Now(), device_manager_->GetLastSyncTime());
+  EXPECT_EQ(clock_.Now(), device_manager_->GetLastSyncTime());
 
   ExpectSyncedDevicesAndPrefAreEqual(devices_in_response_,
                                      device_manager_->GetSyncedDevices(),
@@ -619,12 +617,12 @@ TEST_F(CryptAuthDeviceManagerTest, ForceSync) {
 
   FireSchedulerForSync(INVOCATION_REASON_MANUAL);
 
-  clock_->SetNow(base::Time::FromDoubleT(kLaterTimeNowSeconds));
+  clock_.SetNow(base::Time::FromDoubleT(kLaterTimeNowSeconds));
   EXPECT_CALL(*this, OnSyncFinishedProxy(
                          CryptAuthDeviceManager::SyncResult::SUCCESS,
                          CryptAuthDeviceManager::DeviceChangeResult::CHANGED));
   success_callback_.Run(get_my_devices_response_);
-  EXPECT_EQ(clock_->Now(), device_manager_->GetLastSyncTime());
+  EXPECT_EQ(clock_.Now(), device_manager_->GetLastSyncTime());
 
   ExpectSyncedDevicesAndPrefAreEqual(devices_in_response_,
                                      device_manager_->GetSyncedDevices(),
@@ -641,7 +639,7 @@ TEST_F(CryptAuthDeviceManagerTest, ForceSyncFailsThenSucceeds) {
   EXPECT_CALL(*sync_scheduler(), ForceSync());
   device_manager_->ForceSyncNow(INVOCATION_REASON_MANUAL);
   FireSchedulerForSync(INVOCATION_REASON_MANUAL);
-  clock_->SetNow(base::Time::FromDoubleT(kLaterTimeNowSeconds));
+  clock_.SetNow(base::Time::FromDoubleT(kLaterTimeNowSeconds));
   EXPECT_CALL(*this,
               OnSyncFinishedProxy(
                   CryptAuthDeviceManager::SyncResult::FAILURE,
@@ -657,19 +655,19 @@ TEST_F(CryptAuthDeviceManagerTest, ForceSyncFailsThenSucceeds) {
   ON_CALL(*sync_scheduler(), GetStrategy())
       .WillByDefault(Return(SyncScheduler::Strategy::AGGRESSIVE_RECOVERY));
   FireSchedulerForSync(INVOCATION_REASON_MANUAL);
-  clock_->SetNow(base::Time::FromDoubleT(kLaterTimeNowSeconds + 30));
+  clock_.SetNow(base::Time::FromDoubleT(kLaterTimeNowSeconds + 30));
   EXPECT_CALL(*this, OnSyncFinishedProxy(
                          CryptAuthDeviceManager::SyncResult::SUCCESS,
                          CryptAuthDeviceManager::DeviceChangeResult::CHANGED));
   success_callback_.Run(get_my_devices_response_);
-  EXPECT_EQ(clock_->Now(), device_manager_->GetLastSyncTime());
+  EXPECT_EQ(clock_.Now(), device_manager_->GetLastSyncTime());
 
   ExpectSyncedDevicesAndPrefAreEqual(devices_in_response_,
                                      device_manager_->GetSyncedDevices(),
                                      pref_service_);
 
   EXPECT_FLOAT_EQ(
-      clock_->Now().ToDoubleT(),
+      clock_.Now().ToDoubleT(),
       pref_service_.GetDouble(prefs::kCryptAuthDeviceSyncLastSyncTimeSeconds));
   EXPECT_EQ(static_cast<int>(INVOCATION_REASON_UNKNOWN),
             pref_service_.GetInteger(prefs::kCryptAuthDeviceSyncReason));
@@ -683,7 +681,7 @@ TEST_F(CryptAuthDeviceManagerTest, PeriodicSyncFailsThenSucceeds) {
 
   // The first periodic sync fails.
   FireSchedulerForSync(INVOCATION_REASON_PERIODIC);
-  clock_->SetNow(base::Time::FromDoubleT(kLaterTimeNowSeconds));
+  clock_.SetNow(base::Time::FromDoubleT(kLaterTimeNowSeconds));
   EXPECT_CALL(*this,
               OnSyncFinishedProxy(
                   CryptAuthDeviceManager::SyncResult::FAILURE,
@@ -697,19 +695,19 @@ TEST_F(CryptAuthDeviceManagerTest, PeriodicSyncFailsThenSucceeds) {
   ON_CALL(*sync_scheduler(), GetStrategy())
       .WillByDefault(Return(SyncScheduler::Strategy::AGGRESSIVE_RECOVERY));
   FireSchedulerForSync(INVOCATION_REASON_FAILURE_RECOVERY);
-  clock_->SetNow(base::Time::FromDoubleT(kLaterTimeNowSeconds + 30));
+  clock_.SetNow(base::Time::FromDoubleT(kLaterTimeNowSeconds + 30));
   EXPECT_CALL(*this, OnSyncFinishedProxy(
                          CryptAuthDeviceManager::SyncResult::SUCCESS,
                          CryptAuthDeviceManager::DeviceChangeResult::CHANGED));
   success_callback_.Run(get_my_devices_response_);
-  EXPECT_EQ(clock_->Now(), device_manager_->GetLastSyncTime());
+  EXPECT_EQ(clock_.Now(), device_manager_->GetLastSyncTime());
 
   ExpectSyncedDevicesAndPrefAreEqual(devices_in_response_,
                                      device_manager_->GetSyncedDevices(),
                                      pref_service_);
 
   EXPECT_FLOAT_EQ(
-      clock_->Now().ToDoubleT(),
+      clock_.Now().ToDoubleT(),
       pref_service_.GetDouble(prefs::kCryptAuthDeviceSyncLastSyncTimeSeconds));
   EXPECT_FALSE(pref_service_.GetBoolean(
       prefs::kCryptAuthDeviceSyncIsRecoveringFromFailure));

components/cryptauth/cryptauth_enrollment_manager.cc

@@ -53,13 +53,13 @@ std::unique_ptr<SyncScheduler> CreateSyncScheduler(
 }  // namespace
 
 CryptAuthEnrollmentManager::CryptAuthEnrollmentManager(
-    std::unique_ptr<base::Clock> clock,
+    base::Clock* clock,
     std::unique_ptr<CryptAuthEnrollerFactory> enroller_factory,
     std::unique_ptr<SecureMessageDelegate> secure_message_delegate,
     const GcmDeviceInfo& device_info,
     CryptAuthGCMManager* gcm_manager,
     PrefService* pref_service)
-    : clock_(std::move(clock)),
+    : clock_(clock),
       enroller_factory_(std::move(enroller_factory)),
       secure_message_delegate_(std::move(secure_message_delegate)),
       device_info_(device_info),

components/cryptauth/cryptauth_enrollment_manager.h

@@ -62,7 +62,7 @@ class CryptAuthEnrollmentManager : public SyncScheduler::Delegate,
   // |pref_service|: Contains preferences across browser restarts, and should
   //                 have been registered through RegisterPrefs().
   CryptAuthEnrollmentManager(
-      std::unique_ptr<base::Clock> clock,
+      base::Clock* clock,
       std::unique_ptr<CryptAuthEnrollerFactory> enroller_factory,
       std::unique_ptr<SecureMessageDelegate> secure_message_delegate,
       const GcmDeviceInfo& device_info,
@@ -143,7 +143,7 @@ class CryptAuthEnrollmentManager : public SyncScheduler::Delegate,
   void OnEnrollmentFinished(bool success);
 
   // Used to determine the time.
-  std::unique_ptr<base::Clock> clock_;
+  base::Clock* clock_;
 
   // Creates CryptAuthEnroller instances for each enrollment attempt.
   std::unique_ptr<CryptAuthEnrollerFactory> enroller_factory_;

components/cryptauth/cryptauth_enrollment_manager_unittest.cc

@@ -99,13 +99,13 @@ class MockCryptAuthEnrollerFactory : public CryptAuthEnrollerFactory {
 class TestCryptAuthEnrollmentManager : public CryptAuthEnrollmentManager {
  public:
   TestCryptAuthEnrollmentManager(
-      std::unique_ptr<base::Clock> clock,
+      base::Clock* clock,
       std::unique_ptr<CryptAuthEnrollerFactory> enroller_factory,
       std::unique_ptr<SecureMessageDelegate> secure_message_delegate,
       const GcmDeviceInfo& device_info,
       CryptAuthGCMManager* gcm_manager,
       PrefService* pref_service)
-      : CryptAuthEnrollmentManager(std::move(clock),
+      : CryptAuthEnrollmentManager(clock,
                                    std::move(enroller_factory),
                                    std::move(secure_message_delegate),
                                    device_info,
@@ -144,11 +144,10 @@ class CryptAuthEnrollmentManagerTest
  protected:
   CryptAuthEnrollmentManagerTest()
       : public_key_(kUserPublicKey),
-        clock_(new base::SimpleTestClock()),
         enroller_factory_(new MockCryptAuthEnrollerFactory()),
         secure_message_delegate_(new FakeSecureMessageDelegate()),
         gcm_manager_(kGCMRegistrationId),
-        enrollment_manager_(base::WrapUnique(clock_),
+        enrollment_manager_(&clock_,
                             base::WrapUnique(enroller_factory_),
                             base::WrapUnique(secure_message_delegate_),
                             device_info_,
@@ -157,7 +156,7 @@ class CryptAuthEnrollmentManagerTest
 
   // testing::Test:
   void SetUp() override {
-    clock_->SetNow(base::Time::FromDoubleT(kInitialTimeNowSeconds));
+    clock_.SetNow(base::Time::FromDoubleT(kInitialTimeNowSeconds));
     enrollment_manager_.AddObserver(this);
 
     private_key_ =
@@ -241,8 +240,7 @@ class CryptAuthEnrollmentManagerTest
   std::string public_key_;
   std::string private_key_;
 
-  // Owned by |enrollment_manager_|.
-  base::SimpleTestClock* clock_;
+  base::SimpleTestClock clock_;
 
   // Owned by |enrollment_manager_|.
   MockCryptAuthEnrollerFactory* enroller_factory_;
@@ -297,15 +295,15 @@ TEST_F(CryptAuthEnrollmentManagerTest, GetEnrollmentState) {
 }
 
 TEST_F(CryptAuthEnrollmentManagerTest, 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);
+  base::SimpleTestClock clock;
+  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::MakeUnique<MockCryptAuthEnrollerFactory>(),
+      &clock, base::MakeUnique<MockCryptAuthEnrollerFactory>(),
       base::MakeUnique<FakeSecureMessageDelegate>(), device_info_,
       &gcm_manager_, &pref_service);
 
@@ -321,7 +319,7 @@ TEST_F(CryptAuthEnrollmentManagerTest, InitWithDefaultPrefs) {
 TEST_F(CryptAuthEnrollmentManagerTest, InitWithExistingPrefs) {
   EXPECT_CALL(
       *sync_scheduler(),
-      Start(clock_->Now() - base::Time::FromDoubleT(kLastEnrollmentTimeSeconds),
+      Start(clock_.Now() - base::Time::FromDoubleT(kLastEnrollmentTimeSeconds),
             SyncScheduler::Strategy::PERIODIC_REFRESH));
 
   enrollment_manager_.Start();
@@ -336,8 +334,8 @@ TEST_F(CryptAuthEnrollmentManagerTest, InitWithExpiredEnrollment) {
       base::MakeUnique<base::Value>(kLastExpiredEnrollmentTimeSeconds));
 
   EXPECT_CALL(*sync_scheduler(),
-              Start(clock_->Now() - base::Time::FromDoubleT(
-                                        kLastExpiredEnrollmentTimeSeconds),
+              Start(clock_.Now() - base::Time::FromDoubleT(
+                                       kLastExpiredEnrollmentTimeSeconds),
                     SyncScheduler::Strategy::AGGRESSIVE_RECOVERY));
 
   enrollment_manager_.Start();
@@ -356,10 +354,10 @@ TEST_F(CryptAuthEnrollmentManagerTest, ForceEnrollment) {
   auto completion_callback =
       FireSchedulerForEnrollment(INVOCATION_REASON_SERVER_INITIATED);
 
-  clock_->SetNow(base::Time::FromDoubleT(kLaterTimeNow));
+  clock_.SetNow(base::Time::FromDoubleT(kLaterTimeNow));
   EXPECT_CALL(*this, OnEnrollmentFinishedProxy(true));
   completion_callback.Run(true);
-  EXPECT_EQ(clock_->Now(), enrollment_manager_.GetLastEnrollmentTime());
+  EXPECT_EQ(clock_.Now(), enrollment_manager_.GetLastEnrollmentTime());
 }
 
 TEST_F(CryptAuthEnrollmentManagerTest,
@@ -372,7 +370,7 @@ TEST_F(CryptAuthEnrollmentManagerTest,
       .WillByDefault(Return(SyncScheduler::Strategy::PERIODIC_REFRESH));
   auto completion_callback =
       FireSchedulerForEnrollment(INVOCATION_REASON_PERIODIC);
-  clock_->SetNow(base::Time::FromDoubleT(kLaterTimeNow));
+  clock_.SetNow(base::Time::FromDoubleT(kLaterTimeNow));
   EXPECT_CALL(*this, OnEnrollmentFinishedProxy(false));
   completion_callback.Run(false);
   EXPECT_EQ(old_enrollment_time, enrollment_manager_.GetLastEnrollmentTime());
@@ -384,10 +382,10 @@ TEST_F(CryptAuthEnrollmentManagerTest,
       .WillByDefault(Return(SyncScheduler::Strategy::AGGRESSIVE_RECOVERY));
   completion_callback =
       FireSchedulerForEnrollment(INVOCATION_REASON_FAILURE_RECOVERY);
-  clock_->SetNow(base::Time::FromDoubleT(kLaterTimeNow + 30));
+  clock_.SetNow(base::Time::FromDoubleT(kLaterTimeNow + 30));
   EXPECT_CALL(*this, OnEnrollmentFinishedProxy(true));
   completion_callback.Run(true);
-  EXPECT_EQ(clock_->Now(), enrollment_manager_.GetLastEnrollmentTime());
+  EXPECT_EQ(clock_.Now(), enrollment_manager_.GetLastEnrollmentTime());
   EXPECT_FALSE(pref_service_.GetBoolean(
       prefs::kCryptAuthEnrollmentIsRecoveringFromFailure));
 }
@@ -422,10 +420,10 @@ TEST_F(CryptAuthEnrollmentManagerTest,
 
   // Complete CryptAuth enrollment.
   ASSERT_FALSE(enrollment_callback.is_null());
-  clock_->SetNow(base::Time::FromDoubleT(kLaterTimeNow));
+  clock_.SetNow(base::Time::FromDoubleT(kLaterTimeNow));
   EXPECT_CALL(*this, OnEnrollmentFinishedProxy(true));
   enrollment_callback.Run(true);
-  EXPECT_EQ(clock_->Now(), enrollment_manager_.GetLastEnrollmentTime());
+  EXPECT_EQ(clock_.Now(), enrollment_manager_.GetLastEnrollmentTime());
   EXPECT_TRUE(enrollment_manager_.IsEnrollmentValid());
 
   // Check that CryptAuthEnrollmentManager returns the expected key-pair.

components/cryptauth/foreground_eid_generator.cc

@@ -59,13 +59,12 @@ std::string ForegroundEidGenerator::EidData::DataInHex() const {
 
 ForegroundEidGenerator::ForegroundEidGenerator()
     : ForegroundEidGenerator(base::MakeUnique<RawEidGeneratorImpl>(),
-                             base::MakeUnique<base::DefaultClock>()) {}
+                             base::DefaultClock::GetInstance()) {}
 
 ForegroundEidGenerator::ForegroundEidGenerator(
     std::unique_ptr<RawEidGenerator> raw_eid_generator,
-    std::unique_ptr<base::Clock> clock)
-    : clock_(std::move(clock)),
-      raw_eid_generator_(std::move(raw_eid_generator)) {}
+    base::Clock* clock)
+    : clock_(clock), raw_eid_generator_(std::move(raw_eid_generator)) {}
 
 ForegroundEidGenerator::~ForegroundEidGenerator() {}
 

components/cryptauth/foreground_eid_generator.h

@@ -105,7 +105,7 @@ class ForegroundEidGenerator {
   };
 
   ForegroundEidGenerator(std::unique_ptr<RawEidGenerator> raw_eid_generator,
-                         std::unique_ptr<base::Clock> clock);
+                         base::Clock* clock);
 
   std::unique_ptr<DataWithTimestamp> GenerateAdvertisement(
       const std::string& advertising_device_public_key,
@@ -148,7 +148,7 @@ class ForegroundEidGenerator {
       const int64_t end_of_period_timestamp_ms,
       const int64_t current_timestamp_ms);
 
-  std::unique_ptr<base::Clock> clock_;
+  base::Clock* clock_;
 
   std::unique_ptr<RawEidGenerator> raw_eid_generator_;
 

components/cryptauth/foreground_eid_generator_unittest.cc

@@ -136,24 +136,21 @@ class CryptAuthForegroundEidGeneratorTest : public testing::Test {
   };
 
   void SetUp() override {
-    test_clock_ = new base::SimpleTestClock();
-
     SetTestTime(kDefaultCurrentTime);
 
-    eid_generator_.reset(
-        new ForegroundEidGenerator(base::MakeUnique<TestRawEidGenerator>(),
-                                   base::WrapUnique(test_clock_)));
+    eid_generator_.reset(new ForegroundEidGenerator(
+        base::MakeUnique<TestRawEidGenerator>(), &test_clock_));
   }
 
   // TODO(khorimoto): Is there an easier way to do this?
   void SetTestTime(int64_t timestamp_ms) {
     base::Time time = base::Time::UnixEpoch() +
                       base::TimeDelta::FromMilliseconds(timestamp_ms);
-    test_clock_->SetNow(time);
+    test_clock_.SetNow(time);
   }
 
   std::unique_ptr<ForegroundEidGenerator> eid_generator_;
-  base::SimpleTestClock* test_clock_;
+  base::SimpleTestClock test_clock_;
   std::vector<BeaconSeed> scanning_device_beacon_seeds_;
 };
 
@@ -340,12 +337,11 @@ TEST_F(CryptAuthForegroundEidGeneratorTest,
 
 TEST_F(CryptAuthForegroundEidGeneratorTest,
        GenerateBackgroundScanFilter_UsingRealEids) {
-  test_clock_ = new base::SimpleTestClock();
   SetTestTime(kDefaultCurrentTime);
 
   // Use real RawEidGenerator implementation instead of test version.
   eid_generator_.reset(new ForegroundEidGenerator(
-      base::MakeUnique<RawEidGeneratorImpl>(), base::WrapUnique(test_clock_)));
+      base::MakeUnique<RawEidGeneratorImpl>(), &test_clock_));
 
   std::unique_ptr<ForegroundEidGenerator::EidData> data =
       eid_generator_->GenerateBackgroundScanFilter(