Use the shared instance of base::Default{,Tick}Clock in previews

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: Ic91e3cbb16c8d66131936b6b4c6e74ed212602c2
Reviewed-on: https://chromium-review.googlesource.com/803154Reviewed-by: Tarun Bansal <tbansal@chromium.org>
Commit-Queue: Taiju Tsuiki <tzik@chromium.org>
Cr-Commit-Position: refs/heads/master@{#521191}

chrome/browser/net/spdyproxy/data_reduction_proxy_settings_unittest_android.cc

@@ -70,7 +70,7 @@ class TestDataReductionProxySettingsAndroid
 
 template <class C>
 void data_reduction_proxy::DataReductionProxySettingsTestBase::ResetSettings(
-    std::unique_ptr<base::Clock> clock) {
+    base::Clock* clock) {
   MockDataReductionProxySettings<C>* settings =
       new MockDataReductionProxySettings<C>();
   settings->config_ = test_context_->config();
@@ -86,9 +86,8 @@ void data_reduction_proxy::DataReductionProxySettingsTestBase::ResetSettings(
       test_context_->CreateDataReductionProxyService(settings_.get());
 }
 
-template void
-data_reduction_proxy::DataReductionProxySettingsTestBase::ResetSettings<
-    DataReductionProxyChromeSettings>(std::unique_ptr<base::Clock> clock);
+template void data_reduction_proxy::DataReductionProxySettingsTestBase::
+    ResetSettings<DataReductionProxyChromeSettings>(base::Clock* clock);
 
 namespace {
 

components/data_reduction_proxy/core/browser/data_reduction_proxy_delegate.cc

@@ -43,7 +43,7 @@ DataReductionProxyDelegate::DataReductionProxyDelegate(
       event_creator_(event_creator),
       bypass_stats_(bypass_stats),
       alternative_proxies_broken_(false),
-      tick_clock_(new base::DefaultTickClock()),
+      tick_clock_(base::DefaultTickClock::GetInstance()),
       first_data_saver_request_recorded_(false),
       io_data_(nullptr),
       net_log_(net_log) {
@@ -154,8 +154,8 @@ void DataReductionProxyDelegate::OnTunnelHeadersReceived(
 }
 
 void DataReductionProxyDelegate::SetTickClockForTesting(
-    std::unique_ptr<base::TickClock> tick_clock) {
-  tick_clock_ = std::move(tick_clock);
+    base::TickClock* tick_clock) {
+  tick_clock_ = tick_clock;
   // Update |last_network_change_time_| to the provided tick clock's current
   // time for testing.
   last_network_change_time_ = tick_clock_->NowTicks();

components/data_reduction_proxy/core/browser/data_reduction_proxy_delegate.h

@@ -70,7 +70,7 @@ class DataReductionProxyDelegate
       const net::HostPortPair& proxy_server,
       const net::HttpResponseHeaders& response_headers) override;
 
-  void SetTickClockForTesting(std::unique_ptr<base::TickClock> tick_clock);
+  void SetTickClockForTesting(base::TickClock* tick_clock);
 
  protected:
   // Protected so that these methods are accessible for testing.
@@ -112,7 +112,7 @@ class DataReductionProxyDelegate
   bool alternative_proxies_broken_;
 
   // Tick clock used for obtaining the current time.
-  std::unique_ptr<base::TickClock> tick_clock_;
+  base::TickClock* tick_clock_;
 
   // True if the metrics related to the first request whose resolved proxy was a
   // data saver proxy has been recorded. |first_data_saver_request_recorded_| is

components/data_reduction_proxy/core/browser/data_reduction_proxy_delegate_unittest.cc

@@ -838,10 +838,8 @@ TEST_F(DataReductionProxyDelegateTest, OnCompletedSizeFor200) {
 }
 
 TEST_F(DataReductionProxyDelegateTest, TimeToFirstHttpDataSaverRequest) {
-  std::unique_ptr<base::SimpleTestTickClock> tick_clock(
-      new base::SimpleTestTickClock());
-  base::SimpleTestTickClock* tick_clock_ptr = tick_clock.get();
-  proxy_delegate()->SetTickClockForTesting(std::move(tick_clock));
+  base::SimpleTestTickClock tick_clock;
+  proxy_delegate()->SetTickClockForTesting(&tick_clock);
 
   const char kResponseHeaders[] =
       "HTTP/1.1 200 OK\r\n"
@@ -852,7 +850,7 @@ TEST_F(DataReductionProxyDelegateTest, TimeToFirstHttpDataSaverRequest) {
   {
     base::HistogramTester histogram_tester;
     base::TimeDelta advance_time(base::TimeDelta::FromSeconds(1));
-    tick_clock_ptr->Advance(advance_time);
+    tick_clock.Advance(advance_time);
 
     FetchURLRequest(GURL("http://example.com/path/"), nullptr, kResponseHeaders,
                     10);
@@ -874,7 +872,7 @@ TEST_F(DataReductionProxyDelegateTest, TimeToFirstHttpDataSaverRequest) {
     net::NetworkChangeNotifier::NotifyObserversOfIPAddressChangeForTests();
     base::RunLoop().RunUntilIdle();
 
-    tick_clock_ptr->Advance(advance_time);
+    tick_clock.Advance(advance_time);
     FetchURLRequest(GURL("http://example.com/path/"), nullptr, kResponseHeaders,
                     10);
     histogram_tester.ExpectUniqueSample(

components/data_reduction_proxy/core/browser/data_reduction_proxy_settings.cc

@@ -54,7 +54,7 @@ DataReductionProxySettings::DataReductionProxySettings()
       data_reduction_proxy_enabled_pref_name_(),
       prefs_(nullptr),
       config_(nullptr),
-      clock_(new base::DefaultClock()) {}
+      clock_(base::DefaultClock::GetInstance()) {}
 
 DataReductionProxySettings::~DataReductionProxySettings() {
   spdy_proxy_auth_enabled_.Destroy();

components/data_reduction_proxy/core/browser/data_reduction_proxy_settings.h

@@ -265,7 +265,7 @@ class DataReductionProxySettings : public DataReductionProxyServiceObserver {
   SyntheticFieldTrialRegistrationCallback register_synthetic_field_trial_;
 
   // Should not be null.
-  std::unique_ptr<base::Clock> clock_;
+  base::Clock* clock_;
 
   base::ThreadChecker thread_checker_;
 

components/data_reduction_proxy/core/browser/data_reduction_proxy_settings_test_utils.cc

@@ -72,8 +72,7 @@ void DataReductionProxySettingsTestBase::SetUp() {
 }
 
 template <class C>
-void DataReductionProxySettingsTestBase::ResetSettings(
-    std::unique_ptr<base::Clock> clock) {
+void DataReductionProxySettingsTestBase::ResetSettings(base::Clock* clock) {
   MockDataReductionProxySettings<C>* settings =
       new MockDataReductionProxySettings<C>();
   settings->config_ = test_context_->config();
@@ -81,7 +80,7 @@ void DataReductionProxySettingsTestBase::ResetSettings(
   settings->data_reduction_proxy_service_ =
       test_context_->CreateDataReductionProxyService(settings);
   if (clock)
-    settings->clock_ = std::move(clock);
+    settings->clock_ = clock;
   EXPECT_CALL(*settings, GetOriginalProfilePrefs())
       .Times(AnyNumber())
       .WillRepeatedly(Return(test_context_->pref_service()));
@@ -93,7 +92,7 @@ void DataReductionProxySettingsTestBase::ResetSettings(
 
 // Explicitly generate required instantiations.
 template void DataReductionProxySettingsTestBase::ResetSettings<
-    DataReductionProxySettings>(std::unique_ptr<base::Clock> clock);
+    DataReductionProxySettings>(base::Clock* clock);
 
 void DataReductionProxySettingsTestBase::ExpectSetProxyPrefs(
     bool expected_enabled,

components/data_reduction_proxy/core/browser/data_reduction_proxy_settings_test_utils.h

@@ -50,8 +50,8 @@ class DataReductionProxySettingsTestBase : public testing::Test {
   void SetUp() override;
 
   template <class C>
-  void ResetSettings(std::unique_ptr<base::Clock> clock);
-  virtual void ResetSettings(std::unique_ptr<base::Clock> clock) = 0;
+  void ResetSettings(base::Clock* clock);
+  virtual void ResetSettings(base::Clock* clock) = 0;
 
   void ExpectSetProxyPrefs(bool expected_enabled,
                            bool expected_at_startup);
@@ -84,9 +84,8 @@ class ConcreteDataReductionProxySettingsTest
     : public DataReductionProxySettingsTestBase {
  public:
   typedef MockDataReductionProxySettings<C> MockSettings;
-  void ResetSettings(std::unique_ptr<base::Clock> clock) override {
-    return DataReductionProxySettingsTestBase::ResetSettings<C>(
-        std::move(clock));
+  void ResetSettings(base::Clock* clock) override {
+    return DataReductionProxySettingsTestBase::ResetSettings<C>(clock);
   }
 };
 

components/data_reduction_proxy/core/browser/data_reduction_proxy_settings_unittest.cc

@@ -385,12 +385,11 @@ TEST_F(DataReductionProxySettingsTest, TestSettingsEnabledStateHistograms) {
 // enables the data reduction proxy.
 TEST_F(DataReductionProxySettingsTest, TestDaysSinceEnabledWithTestClock) {
   const char kUMAEnabledState[] = "DataReductionProxy.DaysSinceEnabled";
-  std::unique_ptr<base::SimpleTestClock> clock(new base::SimpleTestClock());
-  base::SimpleTestClock* clock_ptr = clock.get();
-  clock_ptr->Advance(base::TimeDelta::FromDays(1));
-  ResetSettings(std::move(clock));
+  base::SimpleTestClock clock;
+  clock.Advance(base::TimeDelta::FromDays(1));
+  ResetSettings(&clock);
 
-  base::Time last_enabled_time = clock_ptr->Now();
+  base::Time last_enabled_time = clock.Now();
 
   InitPrefMembers();
   {
@@ -405,7 +404,7 @@ TEST_F(DataReductionProxySettingsTest, TestDaysSinceEnabledWithTestClock) {
     settings_->SetDataReductionProxyEnabled(true /* enabled */);
     test_context_->RunUntilIdle();
 
-    last_enabled_time = clock_ptr->Now();
+    last_enabled_time = clock.Now();
 
     EXPECT_EQ(
         last_enabled_time,
@@ -418,9 +417,9 @@ TEST_F(DataReductionProxySettingsTest, TestDaysSinceEnabledWithTestClock) {
     // Simulate turning off and on of data reduction proxy while Chromium is
     // running.
     settings_->SetDataReductionProxyEnabled(false /* enabled */);
-    clock_ptr->Advance(base::TimeDelta::FromDays(1));
+    clock.Advance(base::TimeDelta::FromDays(1));
     base::HistogramTester histogram_tester;
-    last_enabled_time = clock_ptr->Now();
+    last_enabled_time = clock.Now();
 
     settings_->spdy_proxy_auth_enabled_.SetValue(true);
     settings_->MaybeActivateDataReductionProxy(false);
@@ -435,7 +434,7 @@ TEST_F(DataReductionProxySettingsTest, TestDaysSinceEnabledWithTestClock) {
   {
     // Advance clock by a random number of days.
     int advance_clock_days = 42;
-    clock_ptr->Advance(base::TimeDelta::FromDays(advance_clock_days));
+    clock.Advance(base::TimeDelta::FromDays(advance_clock_days));
     base::HistogramTester histogram_tester;
     // Simulate Chromium start up. Data reduction proxy was enabled
     // |advance_clock_days| ago.
@@ -469,22 +468,21 @@ TEST_F(DataReductionProxySettingsTest, TestDaysSinceEnabledExistingUser) {
 }
 
 TEST_F(DataReductionProxySettingsTest, TestDaysSinceSavingsCleared) {
-  std::unique_ptr<base::SimpleTestClock> clock(new base::SimpleTestClock());
-  base::SimpleTestClock* clock_ptr = clock.get();
-  clock_ptr->Advance(base::TimeDelta::FromDays(1));
-  ResetSettings(std::move(clock));
+  base::SimpleTestClock clock;
+  clock.Advance(base::TimeDelta::FromDays(1));
+  ResetSettings(&clock);
 
   InitPrefMembers();
   base::HistogramTester histogram_tester;
   test_context_->pref_service()->SetInt64(
       prefs::kDataReductionProxySavingsClearedNegativeSystemClock,
-      clock_ptr->Now().ToInternalValue());
+      clock.Now().ToInternalValue());
 
   settings_->data_reduction_proxy_service_->SetIOData(
       test_context_->io_data()->GetWeakPtr());
   test_context_->RunUntilIdle();
 
-  clock_ptr->Advance(base::TimeDelta::FromDays(100));
+  clock.Advance(base::TimeDelta::FromDays(100));
 
   // Simulate Chromium startup with data reduction proxy already enabled.
   settings_->spdy_proxy_auth_enabled_.SetValue(true);

components/previews/content/previews_io_data.cc

@@ -133,7 +133,7 @@ void PreviewsIOData::InitializeOnIOThread(
   DCHECK(io_task_runner_->BelongsToCurrentThread());
   previews_black_list_.reset(
       new PreviewsBlackList(std::move(previews_opt_out_store),
-                            base::MakeUnique<base::DefaultClock>(), this));
+                            base::DefaultClock::GetInstance(), this));
   ui_task_runner_->PostTask(
       FROM_HERE, base::Bind(&PreviewsUIService::SetIOData, previews_ui_service_,
                             weak_factory_.GetWeakPtr()));

components/previews/content/previews_io_data_unittest.cc

@@ -77,7 +77,7 @@ class TestPreviewsBlackList : public PreviewsBlackList {
   TestPreviewsBlackList(PreviewsEligibilityReason status,
                         PreviewsBlacklistDelegate* blacklist_delegate)
       : PreviewsBlackList(nullptr,
-                          base::MakeUnique<base::DefaultClock>(),
+                          base::DefaultClock::GetInstance(),
                           blacklist_delegate),
         status_(status) {}
   ~TestPreviewsBlackList() override {}

components/previews/core/previews_black_list.cc

@@ -54,11 +54,11 @@ PreviewsBlackListItem* GetBlackListItemFromMap(
 
 PreviewsBlackList::PreviewsBlackList(
     std::unique_ptr<PreviewsOptOutStore> opt_out_store,
-    std::unique_ptr<base::Clock> clock,
+    base::Clock* clock,
     PreviewsBlacklistDelegate* blacklist_delegate)
     : loaded_(false),
       opt_out_store_(std::move(opt_out_store)),
-      clock_(std::move(clock)),
+      clock_(clock),
       blacklist_delegate_(blacklist_delegate),
       weak_factory_(this) {
   DCHECK(blacklist_delegate_);

components/previews/core/previews_black_list.h

@@ -82,7 +82,7 @@ class PreviewsBlackList {
   // |blacklist_delegate| is a single object listening for blacklist events, and
   // it is guaranteed to overlive the life time of |this|.
   PreviewsBlackList(std::unique_ptr<PreviewsOptOutStore> opt_out_store,
-                    std::unique_ptr<base::Clock> clock,
+                    base::Clock* clock,
                     PreviewsBlacklistDelegate* blacklist_delegate);
   virtual ~PreviewsBlackList();
 
@@ -165,7 +165,7 @@ class PreviewsBlackList {
   // completed.
   base::queue<base::Closure> pending_callbacks_;
 
-  std::unique_ptr<base::Clock> clock_;
+  base::Clock* clock_;
 
   // The delegate listening to this blacklist. |blacklist_delegate_| lifetime is
   // guaranteed to overlive |this|.

components/previews/core/previews_black_list_unittest.cc

@@ -157,15 +157,12 @@ class PreviewsBlackListTest : public testing::Test {
                                                          "Enabled"));
       params_.clear();
     }
-    std::unique_ptr<base::SimpleTestClock> test_clock =
-        base::MakeUnique<base::SimpleTestClock>();
-    test_clock_ = test_clock.get();
     std::unique_ptr<TestPreviewsOptOutStore> opt_out_store =
         null_opt_out ? nullptr : base::MakeUnique<TestPreviewsOptOutStore>();
     opt_out_store_ = opt_out_store.get();
     black_list_ = base::MakeUnique<PreviewsBlackList>(
-        std::move(opt_out_store), std::move(test_clock), &blacklist_delegate_);
-    start_ = test_clock_->Now();
+        std::move(opt_out_store), &test_clock_, &blacklist_delegate_);
+    start_ = test_clock_.Now();
   }
 
   void SetHostHistoryParam(size_t host_history) {
@@ -216,13 +213,13 @@ class PreviewsBlackListTest : public testing::Test {
 
     StartTest(false /* null_opt_out */);
     if (!short_time)
-      test_clock_->Advance(
+      test_clock_.Advance(
           base::TimeDelta::FromSeconds(single_opt_out_duration));
 
     black_list_->AddPreviewNavigation(url, true /* opt_out */,
                                       PreviewsType::OFFLINE);
-    test_clock_->Advance(base::TimeDelta::FromSeconds(1));
-    black_list_->ClearBlackList(start_, test_clock_->Now());
+    test_clock_.Advance(base::TimeDelta::FromSeconds(1));
+    black_list_->ClearBlackList(start_, test_clock_.Now());
     base::RunLoop().RunUntilIdle();
   }
 
@@ -232,8 +229,7 @@ class PreviewsBlackListTest : public testing::Test {
   // Observer to |black_list_|.
   TestPreviewsBlacklistDelegate blacklist_delegate_;
 
-  // Unowned raw pointers tied to the lifetime of |black_list_|.
-  base::SimpleTestClock* test_clock_;
+  base::SimpleTestClock test_clock_;
   TestPreviewsOptOutStore* opt_out_store_;
   base::Time start_;
   std::map<std::string, std::string> params_;
@@ -263,7 +259,7 @@ TEST_F(PreviewsBlackListTest, PerHostBlackListNoStore) {
 
   StartTest(true /* null_opt_out */);
 
-  test_clock_->Advance(base::TimeDelta::FromSeconds(1));
+  test_clock_.Advance(base::TimeDelta::FromSeconds(1));
 
   EXPECT_EQ(PreviewsEligibilityReason::ALLOWED,
             black_list_->IsLoadedAndAllowed(url_a, PreviewsType::OFFLINE));
@@ -271,9 +267,9 @@ TEST_F(PreviewsBlackListTest, PerHostBlackListNoStore) {
             black_list_->IsLoadedAndAllowed(url_b, PreviewsType::OFFLINE));
 
   black_list_->AddPreviewNavigation(url_a, true, PreviewsType::OFFLINE);
-  test_clock_->Advance(base::TimeDelta::FromSeconds(1));
+  test_clock_.Advance(base::TimeDelta::FromSeconds(1));
   black_list_->AddPreviewNavigation(url_a, true, PreviewsType::OFFLINE);
-  test_clock_->Advance(base::TimeDelta::FromSeconds(1));
+  test_clock_.Advance(base::TimeDelta::FromSeconds(1));
 
   EXPECT_EQ(PreviewsEligibilityReason::HOST_BLACKLISTED,
             black_list_->IsLoadedAndAllowed(url_a, PreviewsType::OFFLINE));
@@ -281,9 +277,9 @@ TEST_F(PreviewsBlackListTest, PerHostBlackListNoStore) {
             black_list_->IsLoadedAndAllowed(url_b, PreviewsType::OFFLINE));
 
   black_list_->AddPreviewNavigation(url_b, true, PreviewsType::OFFLINE);
-  test_clock_->Advance(base::TimeDelta::FromSeconds(1));
+  test_clock_.Advance(base::TimeDelta::FromSeconds(1));
   black_list_->AddPreviewNavigation(url_b, true, PreviewsType::OFFLINE);
-  test_clock_->Advance(base::TimeDelta::FromSeconds(1));
+  test_clock_.Advance(base::TimeDelta::FromSeconds(1));
 
   EXPECT_EQ(PreviewsEligibilityReason::HOST_BLACKLISTED,
             black_list_->IsLoadedAndAllowed(url_a, PreviewsType::OFFLINE));
@@ -291,18 +287,18 @@ TEST_F(PreviewsBlackListTest, PerHostBlackListNoStore) {
             black_list_->IsLoadedAndAllowed(url_b, PreviewsType::OFFLINE));
 
   black_list_->AddPreviewNavigation(url_b, false, PreviewsType::OFFLINE);
-  test_clock_->Advance(base::TimeDelta::FromSeconds(1));
+  test_clock_.Advance(base::TimeDelta::FromSeconds(1));
   black_list_->AddPreviewNavigation(url_b, false, PreviewsType::OFFLINE);
-  test_clock_->Advance(base::TimeDelta::FromSeconds(1));
+  test_clock_.Advance(base::TimeDelta::FromSeconds(1));
   black_list_->AddPreviewNavigation(url_b, false, PreviewsType::OFFLINE);
-  test_clock_->Advance(base::TimeDelta::FromSeconds(1));
+  test_clock_.Advance(base::TimeDelta::FromSeconds(1));
 
   EXPECT_EQ(PreviewsEligibilityReason::HOST_BLACKLISTED,
             black_list_->IsLoadedAndAllowed(url_a, PreviewsType::OFFLINE));
   EXPECT_EQ(PreviewsEligibilityReason::ALLOWED,
             black_list_->IsLoadedAndAllowed(url_b, PreviewsType::OFFLINE));
 
-  black_list_->ClearBlackList(start_, test_clock_->Now());
+  black_list_->ClearBlackList(start_, test_clock_.Now());
 
   EXPECT_EQ(PreviewsEligibilityReason::ALLOWED,
             black_list_->IsLoadedAndAllowed(url_a, PreviewsType::OFFLINE));
@@ -329,7 +325,7 @@ TEST_F(PreviewsBlackListTest, PerHostBlackListWithStore) {
 
   StartTest(false /* null_opt_out */);
 
-  test_clock_->Advance(base::TimeDelta::FromSeconds(1));
+  test_clock_.Advance(base::TimeDelta::FromSeconds(1));
 
   EXPECT_EQ(PreviewsEligibilityReason::BLACKLIST_DATA_NOT_LOADED,
             black_list_->IsLoadedAndAllowed(url_a1, PreviewsType::OFFLINE));
@@ -348,9 +344,9 @@ TEST_F(PreviewsBlackListTest, PerHostBlackListWithStore) {
             black_list_->IsLoadedAndAllowed(url_b, PreviewsType::OFFLINE));
 
   black_list_->AddPreviewNavigation(url_a1, true, PreviewsType::OFFLINE);
-  test_clock_->Advance(base::TimeDelta::FromSeconds(1));
+  test_clock_.Advance(base::TimeDelta::FromSeconds(1));
   black_list_->AddPreviewNavigation(url_a1, true, PreviewsType::OFFLINE);
-  test_clock_->Advance(base::TimeDelta::FromSeconds(1));
+  test_clock_.Advance(base::TimeDelta::FromSeconds(1));
 
   EXPECT_EQ(PreviewsEligibilityReason::HOST_BLACKLISTED,
             black_list_->IsLoadedAndAllowed(url_a1, PreviewsType::OFFLINE));
@@ -360,9 +356,9 @@ TEST_F(PreviewsBlackListTest, PerHostBlackListWithStore) {
             black_list_->IsLoadedAndAllowed(url_b, PreviewsType::OFFLINE));
 
   black_list_->AddPreviewNavigation(url_b, true, PreviewsType::OFFLINE);
-  test_clock_->Advance(base::TimeDelta::FromSeconds(1));
+  test_clock_.Advance(base::TimeDelta::FromSeconds(1));
   black_list_->AddPreviewNavigation(url_b, true, PreviewsType::OFFLINE);
-  test_clock_->Advance(base::TimeDelta::FromSeconds(1));
+  test_clock_.Advance(base::TimeDelta::FromSeconds(1));
 
   EXPECT_EQ(PreviewsEligibilityReason::HOST_BLACKLISTED,
             black_list_->IsLoadedAndAllowed(url_a1, PreviewsType::OFFLINE));
@@ -372,11 +368,11 @@ TEST_F(PreviewsBlackListTest, PerHostBlackListWithStore) {
             black_list_->IsLoadedAndAllowed(url_b, PreviewsType::OFFLINE));
 
   black_list_->AddPreviewNavigation(url_b, false, PreviewsType::OFFLINE);
-  test_clock_->Advance(base::TimeDelta::FromSeconds(1));
+  test_clock_.Advance(base::TimeDelta::FromSeconds(1));
   black_list_->AddPreviewNavigation(url_b, false, PreviewsType::OFFLINE);
-  test_clock_->Advance(base::TimeDelta::FromSeconds(1));
+  test_clock_.Advance(base::TimeDelta::FromSeconds(1));
   black_list_->AddPreviewNavigation(url_b, false, PreviewsType::OFFLINE);
-  test_clock_->Advance(base::TimeDelta::FromSeconds(1));
+  test_clock_.Advance(base::TimeDelta::FromSeconds(1));
 
   EXPECT_EQ(PreviewsEligibilityReason::HOST_BLACKLISTED,
             black_list_->IsLoadedAndAllowed(url_a1, PreviewsType::OFFLINE));
@@ -427,7 +423,7 @@ TEST_F(PreviewsBlackListTest, HostIndifferentBlackList) {
   SetSingleOptOutDurationParam(0);
 
   StartTest(true /* null_opt_out */);
-  test_clock_->Advance(base::TimeDelta::FromSeconds(1));
+  test_clock_.Advance(base::TimeDelta::FromSeconds(1));
 
   EXPECT_EQ(PreviewsEligibilityReason::ALLOWED,
             black_list_->IsLoadedAndAllowed(urls[0], PreviewsType::OFFLINE));
@@ -443,7 +439,7 @@ TEST_F(PreviewsBlackListTest, HostIndifferentBlackList) {
     EXPECT_EQ(i != 3 ? PreviewsEligibilityReason::ALLOWED
                      : PreviewsEligibilityReason::USER_BLACKLISTED,
               black_list_->IsLoadedAndAllowed(urls[0], PreviewsType::OFFLINE));
-    test_clock_->Advance(base::TimeDelta::FromSeconds(1));
+    test_clock_.Advance(base::TimeDelta::FromSeconds(1));
   }
 
   EXPECT_EQ(PreviewsEligibilityReason::USER_BLACKLISTED,
@@ -456,7 +452,7 @@ TEST_F(PreviewsBlackListTest, HostIndifferentBlackList) {
             black_list_->IsLoadedAndAllowed(urls[3], PreviewsType::OFFLINE));
 
   black_list_->AddPreviewNavigation(urls[3], false, PreviewsType::OFFLINE);
-  test_clock_->Advance(base::TimeDelta::FromSeconds(1));
+  test_clock_.Advance(base::TimeDelta::FromSeconds(1));
 
   // New non-opt-out entry will cause these to be allowed now.
   EXPECT_EQ(PreviewsEligibilityReason::ALLOWED,
@@ -493,9 +489,9 @@ TEST_F(PreviewsBlackListTest, QueueBehavior) {
     EXPECT_EQ(PreviewsEligibilityReason::BLACKLIST_DATA_NOT_LOADED,
               black_list_->IsLoadedAndAllowed(url, PreviewsType::OFFLINE));
     black_list_->AddPreviewNavigation(url, opt_out, PreviewsType::OFFLINE);
-    test_clock_->Advance(base::TimeDelta::FromSeconds(1));
+    test_clock_.Advance(base::TimeDelta::FromSeconds(1));
     black_list_->AddPreviewNavigation(url, opt_out, PreviewsType::OFFLINE);
-    test_clock_->Advance(base::TimeDelta::FromSeconds(1));
+    test_clock_.Advance(base::TimeDelta::FromSeconds(1));
     EXPECT_EQ(PreviewsEligibilityReason::BLACKLIST_DATA_NOT_LOADED,
               black_list_->IsLoadedAndAllowed(url, PreviewsType::OFFLINE));
     base::RunLoop().RunUntilIdle();
@@ -503,17 +499,17 @@ TEST_F(PreviewsBlackListTest, QueueBehavior) {
                       : PreviewsEligibilityReason::ALLOWED,
               black_list_->IsLoadedAndAllowed(url, PreviewsType::OFFLINE));
     black_list_->AddPreviewNavigation(url, opt_out, PreviewsType::OFFLINE);
-    test_clock_->Advance(base::TimeDelta::FromSeconds(1));
+    test_clock_.Advance(base::TimeDelta::FromSeconds(1));
     black_list_->AddPreviewNavigation(url, opt_out, PreviewsType::OFFLINE);
-    test_clock_->Advance(base::TimeDelta::FromSeconds(1));
+    test_clock_.Advance(base::TimeDelta::FromSeconds(1));
     EXPECT_EQ(0, opt_out_store_->clear_blacklist_count());
     black_list_->ClearBlackList(
-        start_, test_clock_->Now() + base::TimeDelta::FromSeconds(1));
+        start_, test_clock_.Now() + base::TimeDelta::FromSeconds(1));
     EXPECT_EQ(1, opt_out_store_->clear_blacklist_count());
     black_list_->AddPreviewNavigation(url2, opt_out, PreviewsType::OFFLINE);
-    test_clock_->Advance(base::TimeDelta::FromSeconds(1));
+    test_clock_.Advance(base::TimeDelta::FromSeconds(1));
     black_list_->AddPreviewNavigation(url2, opt_out, PreviewsType::OFFLINE);
-    test_clock_->Advance(base::TimeDelta::FromSeconds(1));
+    test_clock_.Advance(base::TimeDelta::FromSeconds(1));
     base::RunLoop().RunUntilIdle();
     EXPECT_EQ(1, opt_out_store_->clear_blacklist_count());
 
@@ -550,9 +546,9 @@ TEST_F(PreviewsBlackListTest, MaxHosts) {
   StartTest(true /* null_opt_out */);
 
   black_list_->AddPreviewNavigation(url_a, true, PreviewsType::OFFLINE);
-  test_clock_->Advance(base::TimeDelta::FromSeconds(1));
+  test_clock_.Advance(base::TimeDelta::FromSeconds(1));
   black_list_->AddPreviewNavigation(url_b, false, PreviewsType::OFFLINE);
-  test_clock_->Advance(base::TimeDelta::FromSeconds(1));
+  test_clock_.Advance(base::TimeDelta::FromSeconds(1));
   black_list_->AddPreviewNavigation(url_c, false, PreviewsType::OFFLINE);
   // url_a should stay in the map, since it has an opt out time.
   EXPECT_EQ(PreviewsEligibilityReason::HOST_BLACKLISTED,
@@ -562,9 +558,9 @@ TEST_F(PreviewsBlackListTest, MaxHosts) {
   EXPECT_EQ(PreviewsEligibilityReason::ALLOWED,
             black_list_->IsLoadedAndAllowed(url_c, PreviewsType::OFFLINE));
 
-  test_clock_->Advance(base::TimeDelta::FromSeconds(1));
+  test_clock_.Advance(base::TimeDelta::FromSeconds(1));
   black_list_->AddPreviewNavigation(url_d, true, PreviewsType::OFFLINE);
-  test_clock_->Advance(base::TimeDelta::FromSeconds(1));
+  test_clock_.Advance(base::TimeDelta::FromSeconds(1));
   black_list_->AddPreviewNavigation(url_e, true, PreviewsType::OFFLINE);
   // url_d and url_e should remain in the map, but url_a should be evicted.
   EXPECT_EQ(PreviewsEligibilityReason::ALLOWED,
@@ -602,7 +598,7 @@ TEST_F(PreviewsBlackListTest, SingleOptOut) {
   EXPECT_EQ(PreviewsEligibilityReason::ALLOWED,
             black_list_->IsLoadedAndAllowed(url_c, PreviewsType::OFFLINE));
 
-  test_clock_->Advance(
+  test_clock_.Advance(
       base::TimeDelta::FromSeconds(single_opt_out_duration + 1));
 
   black_list_->AddPreviewNavigation(url_b, true, PreviewsType::OFFLINE);
@@ -611,7 +607,7 @@ TEST_F(PreviewsBlackListTest, SingleOptOut) {
   EXPECT_EQ(PreviewsEligibilityReason::USER_RECENTLY_OPTED_OUT,
             black_list_->IsLoadedAndAllowed(url_c, PreviewsType::OFFLINE));
 
-  test_clock_->Advance(
+  test_clock_.Advance(
       base::TimeDelta::FromSeconds(single_opt_out_duration - 1));
 
   EXPECT_EQ(PreviewsEligibilityReason::USER_RECENTLY_OPTED_OUT,
@@ -619,7 +615,7 @@ TEST_F(PreviewsBlackListTest, SingleOptOut) {
   EXPECT_EQ(PreviewsEligibilityReason::USER_RECENTLY_OPTED_OUT,
             black_list_->IsLoadedAndAllowed(url_c, PreviewsType::OFFLINE));
 
-  test_clock_->Advance(
+  test_clock_.Advance(
       base::TimeDelta::FromSeconds(single_opt_out_duration + 1));
 
   EXPECT_EQ(PreviewsEligibilityReason::ALLOWED,
@@ -686,22 +682,22 @@ TEST_F(PreviewsBlackListTest, ObserverIsNotifiedOnHostBlacklisted) {
             black_list_->IsLoadedAndAllowed(url_, PreviewsType::OFFLINE));
 
   // Observer is not notified as blacklisted when the threshold does not met.
-  test_clock_->Advance(base::TimeDelta::FromSeconds(1));
+  test_clock_.Advance(base::TimeDelta::FromSeconds(1));
   black_list_->AddPreviewNavigation(url_, true, PreviewsType::OFFLINE);
   base::RunLoop().RunUntilIdle();
   EXPECT_THAT(blacklist_delegate_.blacklisted_hosts(), ::testing::SizeIs(0));
 
   // Observer is notified as blacklisted when the threshold is met.
-  test_clock_->Advance(base::TimeDelta::FromSeconds(1));
+  test_clock_.Advance(base::TimeDelta::FromSeconds(1));
   black_list_->AddPreviewNavigation(url_, true, PreviewsType::OFFLINE);
   base::RunLoop().RunUntilIdle();
-  const base::Time blacklisted_time = test_clock_->Now();
+  const base::Time blacklisted_time = test_clock_.Now();
   EXPECT_THAT(blacklist_delegate_.blacklisted_hosts(), ::testing::SizeIs(1));
   EXPECT_EQ(blacklisted_time,
             blacklist_delegate_.blacklisted_hosts().find(url_.host())->second);
 
   // Observer is not notified when the host is already blacklisted.
-  test_clock_->Advance(base::TimeDelta::FromSeconds(1));
+  test_clock_.Advance(base::TimeDelta::FromSeconds(1));
   black_list_->AddPreviewNavigation(url_, true, PreviewsType::OFFLINE);
   base::RunLoop().RunUntilIdle();
   EXPECT_THAT(blacklist_delegate_.blacklisted_hosts(), ::testing::SizeIs(1));
@@ -711,12 +707,12 @@ TEST_F(PreviewsBlackListTest, ObserverIsNotifiedOnHostBlacklisted) {
   // Observer is notified when blacklist is cleared.
   EXPECT_FALSE(blacklist_delegate_.blacklist_cleared());
 
-  test_clock_->Advance(base::TimeDelta::FromSeconds(1));
-  black_list_->ClearBlackList(start_, test_clock_->Now());
+  test_clock_.Advance(base::TimeDelta::FromSeconds(1));
+  black_list_->ClearBlackList(start_, test_clock_.Now());
   base::RunLoop().RunUntilIdle();
 
   EXPECT_TRUE(blacklist_delegate_.blacklist_cleared());
-  EXPECT_EQ(test_clock_->Now(), blacklist_delegate_.blacklist_cleared_time());
+  EXPECT_EQ(test_clock_.Now(), blacklist_delegate_.blacklist_cleared_time());
 }
 
 TEST_F(PreviewsBlackListTest, ObserverIsNotifiedOnUserBlacklisted) {
@@ -745,7 +741,7 @@ TEST_F(PreviewsBlackListTest, ObserverIsNotifiedOnUserBlacklisted) {
   EXPECT_FALSE(blacklist_delegate_.user_blacklisted());
 
   for (size_t i = 0; i < host_indifferent_threshold; ++i) {
-    test_clock_->Advance(base::TimeDelta::FromSeconds(1));
+    test_clock_.Advance(base::TimeDelta::FromSeconds(1));
     black_list_->AddPreviewNavigation(urls[i], true, PreviewsType::OFFLINE);
     base::RunLoop().RunUntilIdle();
 
@@ -757,7 +753,7 @@ TEST_F(PreviewsBlackListTest, ObserverIsNotifiedOnUserBlacklisted) {
   }
 
   // Observer is notified when the user is no longer blacklisted.
-  test_clock_->Advance(base::TimeDelta::FromSeconds(1));
+  test_clock_.Advance(base::TimeDelta::FromSeconds(1));
   black_list_->AddPreviewNavigation(urls[3], false, PreviewsType::OFFLINE);
   base::RunLoop().RunUntilIdle();
 
@@ -784,12 +780,11 @@ TEST_F(PreviewsBlackListTest, ObserverIsNotifiedWhenLoadBlacklistDone) {
 
   std::unique_ptr<PreviewsBlackListItem> host_indifferent_item =
       PreviewsBlackList::CreateHostIndifferentBlackListItem();
-  std::unique_ptr<base::SimpleTestClock> test_clock =
-      base::MakeUnique<base::SimpleTestClock>();
+  base::SimpleTestClock test_clock;
 
   for (size_t i = 0; i < host_indifferent_threshold; ++i) {
-    test_clock->Advance(base::TimeDelta::FromSeconds(1));
-    host_indifferent_item->AddPreviewNavigation(true, test_clock->Now());
+    test_clock.Advance(base::TimeDelta::FromSeconds(1));
+    host_indifferent_item->AddPreviewNavigation(true, test_clock.Now());
   }
 
   std::unique_ptr<TestPreviewsOptOutStore> opt_out_store =
@@ -799,7 +794,7 @@ TEST_F(PreviewsBlackListTest, ObserverIsNotifiedWhenLoadBlacklistDone) {
 
   EXPECT_FALSE(blacklist_delegate_.user_blacklisted());
   auto black_list = base::MakeUnique<PreviewsBlackList>(
-      std::move(opt_out_store), std::move(test_clock), &blacklist_delegate_);
+      std::move(opt_out_store), &test_clock, &blacklist_delegate_);
   base::RunLoop().RunUntilIdle();
   EXPECT_TRUE(blacklist_delegate_.user_blacklisted());
 }
@@ -822,8 +817,7 @@ TEST_F(PreviewsBlackListTest, ObserverIsNotifiedOfHistoricalBlacklistedHosts) {
 
   StartTest(false /* null_opt_out */);
 
-  std::unique_ptr<base::SimpleTestClock> test_clock =
-      base::MakeUnique<base::SimpleTestClock>();
+  base::SimpleTestClock test_clock;
 
   PreviewsBlackListItem* item_a = new PreviewsBlackListItem(
       params::MaxStoredHistoryLengthForPerHostBlackList(),
@@ -835,18 +829,18 @@ TEST_F(PreviewsBlackListTest, ObserverIsNotifiedOfHistoricalBlacklistedHosts) {
       params::PerHostBlackListDuration());
 
   // Host |url_a| is blacklisted.
-  test_clock->Advance(base::TimeDelta::FromSeconds(1));
-  item_a->AddPreviewNavigation(true, test_clock->Now());
-  test_clock->Advance(base::TimeDelta::FromSeconds(1));
-  item_a->AddPreviewNavigation(true, test_clock->Now());
-  base::Time blacklisted_time = test_clock->Now();
+  test_clock.Advance(base::TimeDelta::FromSeconds(1));
+  item_a->AddPreviewNavigation(true, test_clock.Now());
+  test_clock.Advance(base::TimeDelta::FromSeconds(1));
+  item_a->AddPreviewNavigation(true, test_clock.Now());
+  base::Time blacklisted_time = test_clock.Now();
 
   base::RunLoop().RunUntilIdle();
-  EXPECT_TRUE(item_a->IsBlackListed(test_clock->Now()));
+  EXPECT_TRUE(item_a->IsBlackListed(test_clock.Now()));
 
   // Host |url_b| is not blacklisted.
-  test_clock->Advance(base::TimeDelta::FromSeconds(1));
-  item_b->AddPreviewNavigation(true, test_clock->Now());
+  test_clock.Advance(base::TimeDelta::FromSeconds(1));
+  item_b->AddPreviewNavigation(true, test_clock.Now());
 
   std::unique_ptr<BlackListItemMap> item_map =
       base::MakeUnique<BlackListItemMap>();
@@ -858,7 +852,7 @@ TEST_F(PreviewsBlackListTest, ObserverIsNotifiedOfHistoricalBlacklistedHosts) {
   opt_out_store->SetBlacklistItemMap(std::move(item_map));
 
   auto black_list = base::MakeUnique<PreviewsBlackList>(
-      std::move(opt_out_store), std::move(test_clock), &blacklist_delegate_);
+      std::move(opt_out_store), &test_clock, &blacklist_delegate_);
   base::RunLoop().RunUntilIdle();
 
   ASSERT_THAT(blacklist_delegate_.blacklisted_hosts(), ::testing::SizeIs(1));