Replace base::MockTimer with behavior-specific timers

This CL replaces most MockTimer with MockOneShotTimer or
MockRepeatingTimer as a preparation of OnceCallback support of
base::Timer.

Bug: 850247
Cq-Include-Trybots: luci.chromium.try:android_optional_gpu_tests_rel;luci.chromium.try:ios-simulator-full-configs;luci.chromium.try:linux_mojo;luci.chromium.try:linux_optional_gpu_tests_rel;luci.chromium.try:linux_vr;luci.chromium.try:mac_optional_gpu_tests_rel;luci.chromium.try:win_optional_gpu_tests_rel;master.tryserver.chromium.mac:ios-simulator-cronet
Change-Id: I949bc78c5e103baa610a8a2d1197901ceb090c50
Reviewed-on: https://chromium-review.googlesource.com/1105812
Commit-Queue: Taiju Tsuiki <tzik@chromium.org>
Reviewed-by: Kentaro Hara <haraken@chromium.org>
Reviewed-by: Yutaka Hirano <yhirano@chromium.org>
Reviewed-by: Joshua Bell <jsbell@chromium.org>
Reviewed-by: Gabriel Charette <gab@chromium.org>
Reviewed-by: Lambros Lambrou <lambroslambrou@chromium.org>
Cr-Commit-Position: refs/heads/master@{#572509}

base/files/important_file_writer_unittest.cc

@@ -231,7 +231,7 @@ TEST_F(ImportantFileWriterTest, CallbackRunsOnWriterThread) {
 
 TEST_F(ImportantFileWriterTest, ScheduleWrite) {
   constexpr TimeDelta kCommitInterval = TimeDelta::FromSeconds(12345);
-  MockTimer timer(true, false);
+  MockOneShotTimer timer;
   ImportantFileWriter writer(file_, ThreadTaskRunnerHandle::Get(),
                              kCommitInterval);
   writer.SetTimerForTesting(&timer);
@@ -250,7 +250,7 @@ TEST_F(ImportantFileWriterTest, ScheduleWrite) {
 }
 
 TEST_F(ImportantFileWriterTest, DoScheduledWrite) {
-  MockTimer timer(true, false);
+  MockOneShotTimer timer;
   ImportantFileWriter writer(file_, ThreadTaskRunnerHandle::Get());
   writer.SetTimerForTesting(&timer);
   EXPECT_FALSE(writer.HasPendingWrite());
@@ -265,7 +265,7 @@ TEST_F(ImportantFileWriterTest, DoScheduledWrite) {
 }
 
 TEST_F(ImportantFileWriterTest, BatchingWrites) {
-  MockTimer timer(true, false);
+  MockOneShotTimer timer;
   ImportantFileWriter writer(file_, ThreadTaskRunnerHandle::Get());
   writer.SetTimerForTesting(&timer);
   DataSerializer foo("foo"), bar("bar"), baz("baz");
@@ -280,7 +280,7 @@ TEST_F(ImportantFileWriterTest, BatchingWrites) {
 }
 
 TEST_F(ImportantFileWriterTest, ScheduleWrite_FailToSerialize) {
-  MockTimer timer(true, false);
+  MockOneShotTimer timer;
   ImportantFileWriter writer(file_, ThreadTaskRunnerHandle::Get());
   writer.SetTimerForTesting(&timer);
   EXPECT_FALSE(writer.HasPendingWrite());
@@ -295,7 +295,7 @@ TEST_F(ImportantFileWriterTest, ScheduleWrite_FailToSerialize) {
 }
 
 TEST_F(ImportantFileWriterTest, ScheduleWrite_WriteNow) {
-  MockTimer timer(true, false);
+  MockOneShotTimer timer;
   ImportantFileWriter writer(file_, ThreadTaskRunnerHandle::Get());
   writer.SetTimerForTesting(&timer);
   EXPECT_FALSE(writer.HasPendingWrite());
@@ -312,7 +312,7 @@ TEST_F(ImportantFileWriterTest, ScheduleWrite_WriteNow) {
 }
 
 TEST_F(ImportantFileWriterTest, DoScheduledWrite_FailToSerialize) {
-  MockTimer timer(true, false);
+  MockOneShotTimer timer;
   ImportantFileWriter writer(file_, ThreadTaskRunnerHandle::Get());
   writer.SetTimerForTesting(&timer);
   EXPECT_FALSE(writer.HasPendingWrite());

base/timer/mock_timer_unittest.cc

@@ -15,7 +15,7 @@ void CallMeMaybe(int *number) {
 
 TEST(MockTimerTest, FiresOnce) {
   int calls = 0;
-  base::MockTimer timer(false, false);
+  base::MockOneShotTimer timer;
   base::TimeDelta delay = base::TimeDelta::FromSeconds(2);
   timer.Start(FROM_HERE, delay,
               base::Bind(&CallMeMaybe,
@@ -29,7 +29,7 @@ TEST(MockTimerTest, FiresOnce) {
 
 TEST(MockTimerTest, FiresRepeatedly) {
   int calls = 0;
-  base::MockTimer timer(true, true);
+  base::MockRepeatingTimer timer;
   base::TimeDelta delay = base::TimeDelta::FromSeconds(2);
   timer.Start(FROM_HERE, delay,
               base::Bind(&CallMeMaybe,
@@ -44,7 +44,7 @@ TEST(MockTimerTest, FiresRepeatedly) {
 
 TEST(MockTimerTest, Stops) {
   int calls = 0;
-  base::MockTimer timer(true, true);
+  base::MockRepeatingTimer timer;
   base::TimeDelta delay = base::TimeDelta::FromSeconds(2);
   timer.Start(FROM_HERE, delay,
               base::Bind(&CallMeMaybe,
@@ -66,7 +66,7 @@ class HasWeakPtr : public base::SupportsWeakPtr<HasWeakPtr> {
 TEST(MockTimerTest, DoesNotRetainClosure) {
   HasWeakPtr *has_weak_ptr = new HasWeakPtr();
   base::WeakPtr<HasWeakPtr> weak_ptr(has_weak_ptr->AsWeakPtr());
-  base::MockTimer timer(false, false);
+  base::MockOneShotTimer timer;
   base::TimeDelta delay = base::TimeDelta::FromSeconds(2);
   ASSERT_TRUE(weak_ptr.get());
   timer.Start(FROM_HERE, delay,

content/browser/indexed_db/indexed_db_pre_close_task_queue_unittest.cc

@@ -80,7 +80,7 @@ TEST_F(IndexedDBPreCloseTaskQueueTest, NoTasks) {
   bool done_called = false;
   bool metadata_called = false;
 
-  base::MockTimer* fake_timer = new base::MockTimer(true, false);
+  base::MockOneShotTimer* fake_timer = new base::MockOneShotTimer;
   IndexedDBPreCloseTaskQueue queue(
       std::list<std::unique_ptr<PreCloseTask>>(),
       base::BindOnce(&SetBoolValue, &done_called, true), kTestMaxRunTime,
@@ -104,7 +104,7 @@ TEST_F(IndexedDBPreCloseTaskQueueTest, TaskOneRound) {
   EXPECT_CALL(*task,
               SetMetadata(testing::Pointee(testing::ContainerEq(metadata_))));
 
-  base::MockTimer* fake_timer = new base::MockTimer(true, false);
+  base::MockOneShotTimer* fake_timer = new base::MockOneShotTimer;
   std::list<std::unique_ptr<PreCloseTask>> tasks;
   tasks.push_back(base::WrapUnique(task));
   IndexedDBPreCloseTaskQueue queue(
@@ -134,7 +134,7 @@ TEST_F(IndexedDBPreCloseTaskQueueTest, TaskTwoRounds) {
   EXPECT_CALL(*task,
               SetMetadata(testing::Pointee(testing::ContainerEq(metadata_))));
 
-  base::MockTimer* fake_timer = new base::MockTimer(true, false);
+  base::MockOneShotTimer* fake_timer = new base::MockOneShotTimer;
   std::list<std::unique_ptr<PreCloseTask>> tasks;
   tasks.push_back(base::WrapUnique(task));
   IndexedDBPreCloseTaskQueue queue(
@@ -178,7 +178,7 @@ TEST_F(IndexedDBPreCloseTaskQueueTest, TwoTasks) {
   EXPECT_CALL(*task1,
               SetMetadata(testing::Pointee(testing::ContainerEq(metadata_))));
 
-  base::MockTimer* fake_timer = new base::MockTimer(true, false);
+  base::MockOneShotTimer* fake_timer = new base::MockOneShotTimer;
   std::list<std::unique_ptr<PreCloseTask>> tasks;
   tasks.push_back(base::WrapUnique(task1));
   tasks.push_back(base::WrapUnique(task2));
@@ -227,7 +227,7 @@ TEST_F(IndexedDBPreCloseTaskQueueTest, StopForNewConnectionBeforeStart) {
   EXPECT_CALL(*task1,
               SetMetadata(testing::Pointee(testing::ContainerEq(metadata_))));
 
-  base::MockTimer* fake_timer = new base::MockTimer(true, false);
+  base::MockOneShotTimer* fake_timer = new base::MockOneShotTimer;
   std::list<std::unique_ptr<PreCloseTask>> tasks;
   tasks.push_back(base::WrapUnique(task1));
   tasks.push_back(base::WrapUnique(task2));
@@ -260,7 +260,7 @@ TEST_F(IndexedDBPreCloseTaskQueueTest, StopForNewConnectionAfterRound) {
   EXPECT_CALL(*task,
               SetMetadata(testing::Pointee(testing::ContainerEq(metadata_))));
 
-  base::MockTimer* fake_timer = new base::MockTimer(true, false);
+  base::MockOneShotTimer* fake_timer = new base::MockOneShotTimer;
   std::list<std::unique_ptr<PreCloseTask>> tasks;
   tasks.push_back(base::WrapUnique(task));
   IndexedDBPreCloseTaskQueue queue(
@@ -301,7 +301,7 @@ TEST_F(IndexedDBPreCloseTaskQueueTest, StopForNewConnectionAfterTaskCompletes) {
   EXPECT_CALL(*task1,
               SetMetadata(testing::Pointee(testing::ContainerEq(metadata_))));
 
-  base::MockTimer* fake_timer = new base::MockTimer(true, false);
+  base::MockOneShotTimer* fake_timer = new base::MockOneShotTimer;
   std::list<std::unique_ptr<PreCloseTask>> tasks;
   tasks.push_back(base::WrapUnique(task1));
   tasks.push_back(base::WrapUnique(task2));
@@ -345,7 +345,7 @@ TEST_F(IndexedDBPreCloseTaskQueueTest, StopForTimout) {
   EXPECT_CALL(*task1,
               SetMetadata(testing::Pointee(testing::ContainerEq(metadata_))));
 
-  base::MockTimer* fake_timer = new base::MockTimer(true, false);
+  base::MockOneShotTimer* fake_timer = new base::MockOneShotTimer;
   std::list<std::unique_ptr<PreCloseTask>> tasks;
   tasks.push_back(base::WrapUnique(task1));
   tasks.push_back(base::WrapUnique(task2));
@@ -387,7 +387,7 @@ TEST_F(IndexedDBPreCloseTaskQueueTest, MetadataError) {
   MockPreCloseTask* task1 = new testing::StrictMock<MockPreCloseTask>();
   MockPreCloseTask* task2 = new testing::StrictMock<MockPreCloseTask>();
 
-  base::MockTimer* fake_timer = new base::MockTimer(true, false);
+  base::MockOneShotTimer* fake_timer = new base::MockOneShotTimer;
   std::list<std::unique_ptr<PreCloseTask>> tasks;
   tasks.push_back(base::WrapUnique(task1));
   tasks.push_back(base::WrapUnique(task2));

remoting/host/backoff_timer_unittest.cc

@@ -19,7 +19,7 @@ void IncrementCounter(int* counter) {
 }  // namespace
 
 TEST(BackoffTimer, Basic) {
-  base::MockTimer* mock_timer = new base::MockTimer(false, false);
+  base::MockOneShotTimer* mock_timer = new base::MockOneShotTimer();
   BackoffTimer backoff_timer;
   backoff_timer.SetTimerForTest(base::WrapUnique(mock_timer));
   ASSERT_FALSE(backoff_timer.IsRunning());

remoting/protocol/capture_scheduler_unittest.cc

@@ -32,7 +32,7 @@ class CaptureSchedulerTest : public testing::Test {
     scheduler_->set_minimum_interval(
         base::TimeDelta::FromMilliseconds(kMinumumFrameIntervalMs));
     scheduler_->SetTickClockForTest(&tick_clock_);
-    capture_timer_ = new base::MockTimer(false, false);
+    capture_timer_ = new base::MockOneShotTimer();
     scheduler_->SetTimerForTest(base::WrapUnique(capture_timer_));
     scheduler_->Start();
   }
@@ -79,7 +79,7 @@ class CaptureSchedulerTest : public testing::Test {
   base::SimpleTestTickClock tick_clock_;
 
   // Owned by |scheduler_|.
-  base::MockTimer* capture_timer_;
+  base::MockOneShotTimer* capture_timer_;
 
   bool capture_called_;
 };

services/network/resource_scheduler_unittest.cc

@@ -23,7 +23,6 @@
 #include "base/test/mock_entropy_provider.h"
 #include "base/test/scoped_feature_list.h"
 #include "base/test/test_mock_time_task_runner.h"
-#include "base/timer/mock_timer.h"
 #include "base/timer/timer.h"
 #include "net/base/host_port_pair.h"
 #include "net/base/request_priority.h"
@@ -171,8 +170,7 @@ class ResourceSchedulerTest : public testing::Test {
   void InitializeScheduler(bool enabled = true) {
     CleanupScheduler();
 
-    // Destroys previous scheduler, also destroys any previously created
-    // mock_timer_.
+    // Destroys previous scheduler.
     scheduler_.reset(new ResourceScheduler(enabled));
 
     scheduler()->SetResourceSchedulerParamsManagerForTests(
@@ -292,11 +290,6 @@ class ResourceSchedulerTest : public testing::Test {
     request->ChangePriority(new_priority, intra_priority);
   }
 
-  void FireCoalescingTimer() {
-    EXPECT_TRUE(mock_timer_->IsRunning());
-    mock_timer_->Fire();
-  }
-
   void RequestLimitOverrideConfigTestHelper(bool experiment_status) {
     InitializeThrottleDelayableExperiment(experiment_status, 0.0);
 
@@ -440,7 +433,6 @@ class ResourceSchedulerTest : public testing::Test {
 
   base::MessageLoop message_loop_;
   std::unique_ptr<ResourceScheduler> scheduler_;
-  base::MockTimer* mock_timer_;
   net::HttpServerPropertiesImpl http_server_properties_;
   net::TestNetworkQualityEstimator network_quality_estimator_;
   net::TestURLRequestContext context_;

services/resource_coordinator/observers/ipc_volume_reporter_unittest.cc

@@ -17,10 +17,10 @@ namespace resource_coordinator {
 class TestIPCVolumeReporter : public IPCVolumeReporter {
  public:
   TestIPCVolumeReporter()
-      : IPCVolumeReporter(std::make_unique<base::MockTimer>(false, false)) {}
+      : IPCVolumeReporter(std::make_unique<base::MockOneShotTimer>()) {}
 
-  base::MockTimer* mock_timer() const {
-    return reinterpret_cast<base::MockTimer*>(timer());
+  base::MockOneShotTimer* mock_timer() const {
+    return static_cast<base::MockOneShotTimer*>(timer());
   }
 };