Introduce MockTimeDomain to replace VirtualTimeDomain in tests.

Since scheduler/base is getting moved to //base/task/sequence_manager
we don't want to explicitly support the concept of virtual time
because it might be confused with the existing mechanism to override
a TickClock in //base. So we can't move VirtualTimeDomain to //base.
It was used in some tests in scheduler/base as a mock time domain,
so this CL makes it explicit and test-only.

Bug: 783309
Change-Id: I0a11e565de94fce06af4aff288427b6bc78e890b
Reviewed-on: https://chromium-review.googlesource.com/1120257Reviewed-by: Alexander Timin <altimin@chromium.org>
Commit-Queue: Greg Kraynov <kraynov@chromium.org>
Cr-Commit-Position: refs/heads/master@{#571562}

base/task/sequence_manager/time_domain.h

@@ -85,7 +85,7 @@ class PLATFORM_EXPORT TimeDomain {
  private:
   friend class internal::TaskQueueImpl;
   friend class TaskQueueManagerImpl;
-  friend class MockTimeDomain;
+  friend class TestTimeDomain;
 
   // Called when the TimeDomain is registered.
   // TODO(kraynov): Pass SequenceManager in the constructor.

third_party/blink/renderer/platform/scheduler/BUILD.gn

@@ -157,6 +157,8 @@ jumbo_source_set("test_support") {
   testonly = true
 
   sources = [
+    "base/test/mock_time_domain.cc",
+    "base/test/mock_time_domain.h",
     "base/test/task_queue_manager_for_test.cc",
     "base/test/task_queue_manager_for_test.h",
     "base/test/test_count_uses_time_source.cc",

third_party/blink/renderer/platform/scheduler/base/task_queue_manager_impl_unittest.cc

@@ -27,12 +27,12 @@
 #include "third_party/blink/renderer/platform/scheduler/base/real_time_domain.h"
 #include "third_party/blink/renderer/platform/scheduler/base/task_queue_impl_forward.h"
 #include "third_party/blink/renderer/platform/scheduler/base/task_queue_selector.h"
+#include "third_party/blink/renderer/platform/scheduler/base/test/mock_time_domain.h"
 #include "third_party/blink/renderer/platform/scheduler/base/test/task_queue_manager_for_test.h"
 #include "third_party/blink/renderer/platform/scheduler/base/test/test_count_uses_time_source.h"
 #include "third_party/blink/renderer/platform/scheduler/base/test/test_task_queue.h"
 #include "third_party/blink/renderer/platform/scheduler/base/test/test_task_time_observer.h"
 #include "third_party/blink/renderer/platform/scheduler/base/thread_controller_impl.h"
-#include "third_party/blink/renderer/platform/scheduler/base/virtual_time_domain.h"
 #include "third_party/blink/renderer/platform/scheduler/base/work_queue.h"
 #include "third_party/blink/renderer/platform/scheduler/base/work_queue_sets.h"
 
@@ -1609,10 +1609,10 @@ TEST_F(TaskQueueManagerTest, TimeDomainsAreIndependant) {
   CreateTaskQueues(2u);
 
   TimeTicks start_time_ticks = manager_->NowTicks();
-  std::unique_ptr<VirtualTimeDomain> domain_a(
-      new VirtualTimeDomain(start_time_ticks));
-  std::unique_ptr<VirtualTimeDomain> domain_b(
-      new VirtualTimeDomain(start_time_ticks));
+  std::unique_ptr<MockTimeDomain> domain_a =
+      std::make_unique<MockTimeDomain>(start_time_ticks);
+  std::unique_ptr<MockTimeDomain> domain_b =
+      std::make_unique<MockTimeDomain>(start_time_ticks);
   manager_->RegisterTimeDomain(domain_a.get());
   manager_->RegisterTimeDomain(domain_b.get());
   runners_[0]->SetTimeDomain(domain_a.get());
@@ -1633,13 +1633,13 @@ TEST_F(TaskQueueManagerTest, TimeDomainsAreIndependant) {
   runners_[1]->PostDelayedTask(FROM_HERE, BindOnce(&TestTask, 6, &run_order),
                                TimeDelta::FromMilliseconds(30));
 
-  domain_b->AdvanceNowTo(start_time_ticks + TimeDelta::FromMilliseconds(50));
+  domain_b->SetNowTicks(start_time_ticks + TimeDelta::FromMilliseconds(50));
   manager_->MaybeScheduleImmediateWork(FROM_HERE);
 
   RunLoop().RunUntilIdle();
   EXPECT_THAT(run_order, ElementsAre(4u, 5u, 6u));
 
-  domain_a->AdvanceNowTo(start_time_ticks + TimeDelta::FromMilliseconds(50));
+  domain_a->SetNowTicks(start_time_ticks + TimeDelta::FromMilliseconds(50));
   manager_->MaybeScheduleImmediateWork(FROM_HERE);
 
   RunLoop().RunUntilIdle();
@@ -1656,8 +1656,8 @@ TEST_F(TaskQueueManagerTest, TimeDomainMigration) {
   CreateTaskQueues(1u);
 
   TimeTicks start_time_ticks = manager_->NowTicks();
-  std::unique_ptr<VirtualTimeDomain> domain_a(
-      new VirtualTimeDomain(start_time_ticks));
+  std::unique_ptr<MockTimeDomain> domain_a =
+      std::make_unique<MockTimeDomain>(start_time_ticks);
   manager_->RegisterTimeDomain(domain_a.get());
   runners_[0]->SetTimeDomain(domain_a.get());
 
@@ -1671,17 +1671,17 @@ TEST_F(TaskQueueManagerTest, TimeDomainMigration) {
   runners_[0]->PostDelayedTask(FROM_HERE, BindOnce(&TestTask, 4, &run_order),
                                TimeDelta::FromMilliseconds(40));
 
-  domain_a->AdvanceNowTo(start_time_ticks + TimeDelta::FromMilliseconds(20));
+  domain_a->SetNowTicks(start_time_ticks + TimeDelta::FromMilliseconds(20));
   manager_->MaybeScheduleImmediateWork(FROM_HERE);
   RunLoop().RunUntilIdle();
   EXPECT_THAT(run_order, ElementsAre(1u, 2u));
 
-  std::unique_ptr<VirtualTimeDomain> domain_b(
-      new VirtualTimeDomain(start_time_ticks));
+  std::unique_ptr<MockTimeDomain> domain_b =
+      std::make_unique<MockTimeDomain>(start_time_ticks);
   manager_->RegisterTimeDomain(domain_b.get());
   runners_[0]->SetTimeDomain(domain_b.get());
 
-  domain_b->AdvanceNowTo(start_time_ticks + TimeDelta::FromMilliseconds(50));
+  domain_b->SetNowTicks(start_time_ticks + TimeDelta::FromMilliseconds(50));
   manager_->MaybeScheduleImmediateWork(FROM_HERE);
 
   RunLoop().RunUntilIdle();
@@ -1697,10 +1697,10 @@ TEST_F(TaskQueueManagerTest, TimeDomainMigrationWithIncomingImmediateTasks) {
   CreateTaskQueues(1u);
 
   TimeTicks start_time_ticks = manager_->NowTicks();
-  std::unique_ptr<VirtualTimeDomain> domain_a(
-      new VirtualTimeDomain(start_time_ticks));
-  std::unique_ptr<VirtualTimeDomain> domain_b(
-      new VirtualTimeDomain(start_time_ticks));
+  std::unique_ptr<MockTimeDomain> domain_a =
+      std::make_unique<MockTimeDomain>(start_time_ticks);
+  std::unique_ptr<MockTimeDomain> domain_b =
+      std::make_unique<MockTimeDomain>(start_time_ticks);
   manager_->RegisterTimeDomain(domain_a.get());
   manager_->RegisterTimeDomain(domain_b.get());
 
@@ -2837,8 +2837,8 @@ TEST_F(TaskQueueManagerTest, SetTimeDomainForDisabledQueue) {
   // We should not get a notification for a disabled queue.
   EXPECT_CALL(observer, OnQueueNextWakeUpChanged(_, _)).Times(0);
 
-  std::unique_ptr<VirtualTimeDomain> domain(
-      new VirtualTimeDomain(manager_->NowTicks()));
+  std::unique_ptr<MockTimeDomain> domain =
+      std::make_unique<MockTimeDomain>(manager_->NowTicks());
   manager_->RegisterTimeDomain(domain.get());
   runners_[0]->SetTimeDomain(domain.get());
 

third_party/blink/renderer/platform/scheduler/base/task_queue_manager_perftest.cc

@@ -19,28 +19,29 @@
 #include "testing/perf/perf_test.h"
 #include "third_party/blink/renderer/platform/scheduler/base/task_queue_impl_forward.h"
 #include "third_party/blink/renderer/platform/scheduler/base/task_queue_selector.h"
+#include "third_party/blink/renderer/platform/scheduler/base/test/mock_time_domain.h"
 #include "third_party/blink/renderer/platform/scheduler/base/test/task_queue_manager_for_test.h"
 #include "third_party/blink/renderer/platform/scheduler/base/test/test_task_queue.h"
 #include "third_party/blink/renderer/platform/scheduler/base/test/test_task_time_observer.h"
-#include "third_party/blink/renderer/platform/scheduler/base/virtual_time_domain.h"
 #include "third_party/blink/renderer/platform/scheduler/base/work_queue_sets.h"
 
 namespace base {
 namespace sequence_manager {
 
-// To reduce noise related to the OS timer, we use a virtual time domain to
+// To reduce noise related to the OS timer, we use a mock time domain to
 // fast forward the timers.
-class PerfTestTimeDomain : public VirtualTimeDomain {
+class PerfTestTimeDomain : public MockTimeDomain {
  public:
-  PerfTestTimeDomain() : VirtualTimeDomain(TimeTicks::Now()) {}
+  PerfTestTimeDomain() : MockTimeDomain(TimeTicks::Now()) {}
   ~PerfTestTimeDomain() override = default;
 
   Optional<TimeDelta> DelayTillNextTask(LazyNow* lazy_now) override {
     Optional<TimeTicks> run_time = NextScheduledRunTime();
     if (!run_time)
       return nullopt;
-    AdvanceNowTo(*run_time);
-    return TimeDelta();  // Makes DoWork post an immediate continuation.
+    SetNowTicks(*run_time);
+    // Makes SequenceManager to continue immediately.
+    return TimeDelta();
   }
 
   void SetNextDelayedDoWork(LazyNow* lazy_now, TimeTicks run_time) override {
@@ -49,8 +50,7 @@ class PerfTestTimeDomain : public VirtualTimeDomain {
       RequestDoWork();
   }
 
-  const char* GetName() const override { return "PerfTestTimeDomain"; }
-
+ private:
   DISALLOW_COPY_AND_ASSIGN(PerfTestTimeDomain);
 };
 
@@ -70,7 +70,7 @@ class TaskQueueManagerPerfTest : public testing::Test {
 
   void TearDown() override {
     queues_.clear();
-    manager_->UnregisterTimeDomain(virtual_time_domain_.get());
+    manager_->UnregisterTimeDomain(time_domain_.get());
     manager_.reset();
   }
 
@@ -82,12 +82,12 @@ class TaskQueueManagerPerfTest : public testing::Test {
                                                DefaultTickClock::GetInstance());
     manager_->AddTaskTimeObserver(&test_task_time_observer_);
 
-    virtual_time_domain_.reset(new PerfTestTimeDomain());
-    manager_->RegisterTimeDomain(virtual_time_domain_.get());
+    time_domain_.reset(new PerfTestTimeDomain());
+    manager_->RegisterTimeDomain(time_domain_.get());
 
     for (size_t i = 0; i < num_queues; i++) {
       queues_.push_back(manager_->CreateTaskQueue<TestTaskQueue>(
-          TaskQueue::Spec("test").SetTimeDomain(virtual_time_domain_.get())));
+          TaskQueue::Spec("test").SetTimeDomain(time_domain_.get())));
     }
 
     delayed_task_closure_ = BindRepeating(
@@ -200,7 +200,7 @@ class TaskQueueManagerPerfTest : public testing::Test {
   std::unique_ptr<MessageLoop> message_loop_;
   std::unique_ptr<SequenceManager> manager_;
   std::unique_ptr<RunLoop> run_loop_;
-  std::unique_ptr<VirtualTimeDomain> virtual_time_domain_;
+  std::unique_ptr<TimeDomain> time_domain_;
   std::vector<scoped_refptr<SingleThreadTaskRunner>> queues_;
   RepeatingClosure delayed_task_closure_;
   RepeatingClosure immediate_task_closure_;

third_party/blink/renderer/platform/scheduler/base/task_queue_selector_unittest.cc

@@ -16,7 +16,7 @@
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "third_party/blink/renderer/platform/scheduler/base/task_queue_impl_forward.h"
-#include "third_party/blink/renderer/platform/scheduler/base/virtual_time_domain.h"
+#include "third_party/blink/renderer/platform/scheduler/base/test/mock_time_domain.h"
 #include "third_party/blink/renderer/platform/scheduler/base/work_queue.h"
 #include "third_party/blink/renderer/platform/scheduler/base/work_queue_sets.h"
 
@@ -146,11 +146,11 @@ class TaskQueueSelectorTest : public testing::Test {
 
  protected:
   void SetUp() final {
-    virtual_time_domain_ = std::make_unique<VirtualTimeDomain>(
-        TimeTicks() + TimeDelta::FromSeconds(1));
+    time_domain_ = std::make_unique<MockTimeDomain>(TimeTicks() +
+                                                    TimeDelta::FromSeconds(1));
     for (size_t i = 0; i < kTaskQueueCount; i++) {
       std::unique_ptr<TaskQueueImpl> task_queue =
-          std::make_unique<TaskQueueImpl>(nullptr, virtual_time_domain_.get(),
+          std::make_unique<TaskQueueImpl>(nullptr, time_domain_.get(),
                                           TaskQueue::Spec("test"));
       selector_.AddQueue(task_queue.get());
       task_queues_.push_back(std::move(task_queue));
@@ -174,14 +174,14 @@ class TaskQueueSelectorTest : public testing::Test {
   }
 
   std::unique_ptr<TaskQueueImpl> NewTaskQueueWithBlockReporting() {
-    return std::make_unique<TaskQueueImpl>(nullptr, virtual_time_domain_.get(),
+    return std::make_unique<TaskQueueImpl>(nullptr, time_domain_.get(),
                                            TaskQueue::Spec("test"));
   }
 
   const size_t kTaskQueueCount = 5;
   RepeatingClosure test_closure_;
   TaskQueueSelectorForTest selector_;
-  std::unique_ptr<VirtualTimeDomain> virtual_time_domain_;
+  std::unique_ptr<TimeDomain> time_domain_;
   std::vector<std::unique_ptr<TaskQueueImpl>> task_queues_;
   std::map<TaskQueueImpl*, size_t> queue_to_index_map_;
   std::unique_ptr<HistogramTester> histogram_tester_;

third_party/blink/renderer/platform/scheduler/base/test/mock_time_domain.cc

+// Copyright 2018 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 "third_party/blink/renderer/platform/scheduler/base/test/mock_time_domain.h"
+
+namespace base {
+namespace sequence_manager {
+
+MockTimeDomain::MockTimeDomain(TimeTicks initial_now_ticks)
+    : now_ticks_(initial_now_ticks) {}
+
+MockTimeDomain::~MockTimeDomain() = default;
+
+LazyNow MockTimeDomain::CreateLazyNow() const {
+  return LazyNow(now_ticks_);
+}
+
+TimeTicks MockTimeDomain::Now() const {
+  return now_ticks_;
+}
+
+void MockTimeDomain::SetNowTicks(TimeTicks now_ticks) {
+  now_ticks_ = now_ticks;
+}
+
+Optional<TimeDelta> MockTimeDomain::DelayTillNextTask(LazyNow* lazy_now) {
+  return nullopt;
+}
+
+void MockTimeDomain::SetNextDelayedDoWork(LazyNow* lazy_now,
+                                          TimeTicks run_time) {}
+
+const char* MockTimeDomain::GetName() const {
+  return "MockTimeDomain";
+}
+
+}  // namespace sequence_manager
+}  // namespace base

third_party/blink/renderer/platform/scheduler/base/test/mock_time_domain.h

+// Copyright 2018 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.
+
+#ifndef THIRD_PARTY_BLINK_RENDERER_PLATFORM_SCHEDULER_BASE_TEST_MOCK_TIME_DOMAIN_H_
+#define THIRD_PARTY_BLINK_RENDERER_PLATFORM_SCHEDULER_BASE_TEST_MOCK_TIME_DOMAIN_H_
+
+#include "third_party/blink/renderer/platform/scheduler/base/time_domain_forward.h"
+
+namespace base {
+namespace sequence_manager {
+
+// TimeDomain with a mock clock and not invoking SequenceManager.
+// NOTE: All methods are main thread only.
+class MockTimeDomain : public TimeDomain {
+ public:
+  explicit MockTimeDomain(TimeTicks initial_now_ticks);
+  ~MockTimeDomain() override;
+
+  void SetNowTicks(TimeTicks now_ticks);
+
+  // TimeDomain implementation:
+  LazyNow CreateLazyNow() const override;
+  TimeTicks Now() const override;
+  Optional<TimeDelta> DelayTillNextTask(LazyNow* lazy_now) override;
+  void SetNextDelayedDoWork(LazyNow* lazy_now, TimeTicks run_time) override;
+  const char* GetName() const override;
+
+ private:
+  TimeTicks now_ticks_;
+
+  DISALLOW_COPY_AND_ASSIGN(MockTimeDomain);
+};
+
+}  // namespace sequence_manager
+}  // namespace base
+
+#endif  // THIRD_PARTY_BLINK_RENDERER_PLATFORM_SCHEDULER_BASE_TEST_MOCK_TIME_DOMAIN_H_

third_party/blink/renderer/platform/scheduler/base/time_domain_unittest.cc

@@ -31,11 +31,11 @@ class TaskQueueImplForTest : public internal::TaskQueueImpl {
   using TaskQueueImpl::SetDelayedWakeUpForTesting;
 };
 
-class MockTimeDomain : public TimeDomain {
+class TestTimeDomain : public TimeDomain {
  public:
-  MockTimeDomain() : now_(TimeTicks() + TimeDelta::FromSeconds(1)) {}
+  TestTimeDomain() : now_(TimeTicks() + TimeDelta::FromSeconds(1)) {}
 
-  ~MockTimeDomain() override = default;
+  ~TestTimeDomain() override = default;
 
   using TimeDomain::NextScheduledRunTime;
   using TimeDomain::SetNextWakeUpForQueue;
@@ -66,13 +66,13 @@ class MockTimeDomain : public TimeDomain {
  private:
   TimeTicks now_;
 
-  DISALLOW_COPY_AND_ASSIGN(MockTimeDomain);
+  DISALLOW_COPY_AND_ASSIGN(TestTimeDomain);
 };
 
 class TimeDomainTest : public testing::Test {
  public:
   void SetUp() final {
-    time_domain_ = WrapUnique(CreateMockTimeDomain());
+    time_domain_ = WrapUnique(CreateTestTimeDomain());
     task_queue_ = std::make_unique<TaskQueueImplForTest>(
         nullptr, time_domain_.get(), TaskQueue::Spec("test"));
   }
@@ -82,11 +82,11 @@ class TimeDomainTest : public testing::Test {
       task_queue_->UnregisterTaskQueue();
   }
 
-  virtual MockTimeDomain* CreateMockTimeDomain() {
-    return new MockTimeDomain();
+  virtual TestTimeDomain* CreateTestTimeDomain() {
+    return new TestTimeDomain();
   }
 
-  std::unique_ptr<MockTimeDomain> time_domain_;
+  std::unique_ptr<TestTimeDomain> time_domain_;
   std::unique_ptr<TaskQueueImplForTest> task_queue_;
 };
 

third_party/blink/renderer/platform/scheduler/base/virtual_time_domain.h

@@ -13,7 +13,8 @@
 namespace base {
 namespace sequence_manager {
 
-// TODO(kraynov): Move to platform/scheduler/common.
+// TODO(kraynov): Merge into AutoAdvancingVirtualTimeDomain since
+// it's not used anywhere else.
 class PLATFORM_EXPORT VirtualTimeDomain : public TimeDomain {
  public:
   explicit VirtualTimeDomain(TimeTicks initial_time_ticks);