[scheduler] Add TaskQueue::Observer

third_party/WebKit/Source/platform/scheduler/base/task_queue_manager_unittest.cc

Index: third_party/WebKit/Source/platform/scheduler/base/task_queue_manager_unittest.cc
diff --git a/third_party/WebKit/Source/platform/scheduler/base/task_queue_manager_unittest.cc b/third_party/WebKit/Source/platform/scheduler/base/task_queue_manager_unittest.cc
index b797052f84d67d7fdfe9df28f3e5653eb765d180..52fa223c956bde03cb35363958be5501015eaf05 100644
--- a/third_party/WebKit/Source/platform/scheduler/base/task_queue_manager_unittest.cc
+++ b/third_party/WebKit/Source/platform/scheduler/base/task_queue_manager_unittest.cc
@@ -1545,9 +1545,9 @@ TEST_F(TaskQueueManagerTest, TimeDomainsAreIndependant) {
 
   base::TimeTicks start_time = manager_->Delegate()->NowTicks();
   std::unique_ptr<VirtualTimeDomain> domain_a(
-      new VirtualTimeDomain(nullptr, start_time));
+      new VirtualTimeDomain(start_time));
   std::unique_ptr<VirtualTimeDomain> domain_b(
-      new VirtualTimeDomain(nullptr, start_time));
+      new VirtualTimeDomain(start_time));
   manager_->RegisterTimeDomain(domain_a.get());
   manager_->RegisterTimeDomain(domain_b.get());
   runners_[0]->SetTimeDomain(domain_a.get());
@@ -1592,7 +1592,7 @@ TEST_F(TaskQueueManagerTest, TimeDomainMigration) {
 
   base::TimeTicks start_time = manager_->Delegate()->NowTicks();
   std::unique_ptr<VirtualTimeDomain> domain_a(
-      new VirtualTimeDomain(nullptr, start_time));
+      new VirtualTimeDomain(start_time));
   manager_->RegisterTimeDomain(domain_a.get());
   runners_[0]->SetTimeDomain(domain_a.get());
 
@@ -1612,7 +1612,7 @@ TEST_F(TaskQueueManagerTest, TimeDomainMigration) {
   EXPECT_THAT(run_order, ElementsAre(1, 2));
 
   std::unique_ptr<VirtualTimeDomain> domain_b(
-      new VirtualTimeDomain(nullptr, start_time));
+      new VirtualTimeDomain(start_time));
   manager_->RegisterTimeDomain(domain_b.get());
   runners_[0]->SetTimeDomain(domain_b.get());
 
@@ -1633,9 +1633,9 @@ TEST_F(TaskQueueManagerTest, TimeDomainMigrationWithIncomingImmediateTasks) {
 
   base::TimeTicks start_time = manager_->Delegate()->NowTicks();
   std::unique_ptr<VirtualTimeDomain> domain_a(
-      new VirtualTimeDomain(nullptr, start_time));
+      new VirtualTimeDomain(start_time));
   std::unique_ptr<VirtualTimeDomain> domain_b(
-      new VirtualTimeDomain(nullptr, start_time));
+      new VirtualTimeDomain(start_time));
   manager_->RegisterTimeDomain(domain_a.get());
   manager_->RegisterTimeDomain(domain_b.get());
 
@@ -1690,68 +1690,64 @@ TEST_F(TaskQueueManagerTest,
 }
 
 namespace {
-class MockTimeDomainObserver : public TimeDomain::Observer {
+
+class MockTaskQueueObserver : public TaskQueue::Observer {
  public:
-  ~MockTimeDomainObserver() override {}
+  ~MockTaskQueueObserver() override {}
 
-  MOCK_METHOD1(OnTimeDomainHasImmediateWork, void(TaskQueue*));
-  MOCK_METHOD1(OnTimeDomainHasDelayedWork, void(TaskQueue*));
+  MOCK_METHOD2(OnQueueNextWakeUpChanged, void(TaskQueue*, base::TimeTicks));
 };
+
 }  // namespace
 
-TEST_F(TaskQueueManagerTest, TimeDomainObserver_ImmediateTask) {
+TEST_F(TaskQueueManagerTest, TaskQueueObserver_ImmediateTask) {
   Initialize(1u);
 
-  MockTimeDomainObserver observer;
-  std::unique_ptr<VirtualTimeDomain> domain(
-      new VirtualTimeDomain(&observer, manager_->Delegate()->NowTicks()));
-  manager_->RegisterTimeDomain(domain.get());
-  runners_[0]->SetTimeDomain(domain.get());
+  MockTaskQueueObserver observer;
+  runners_[0]->SetObserver(&observer);
 
   // We should get a notification when a task is posted on an empty queue.
-  EXPECT_CALL(observer, OnTimeDomainHasImmediateWork(runners_[0].get()));
+  EXPECT_CALL(observer,
+              OnQueueNextWakeUpChanged(runners_[0].get(), base::TimeTicks()));
   runners_[0]->PostTask(FROM_HERE, base::Bind(&NopTask));
   Mock::VerifyAndClearExpectations(&observer);
 
   // But not subsequently.
-  EXPECT_CALL(observer, OnTimeDomainHasImmediateWork(_)).Times(0);
+  EXPECT_CALL(observer, OnQueueNextWakeUpChanged(_, _)).Times(0);
   runners_[0]->PostTask(FROM_HERE, base::Bind(&NopTask));
   Mock::VerifyAndClearExpectations(&observer);
 
   // Unless the immediate work queue is emptied.
   runners_[0]->ReloadImmediateWorkQueueIfEmpty();
-  EXPECT_CALL(observer, OnTimeDomainHasImmediateWork(runners_[0].get()));
+  EXPECT_CALL(observer,
+              OnQueueNextWakeUpChanged(runners_[0].get(), base::TimeTicks()));
   runners_[0]->PostTask(FROM_HERE, base::Bind(&NopTask));
 
   // Tidy up.
   runners_[0]->UnregisterTaskQueue();
-  manager_->UnregisterTimeDomain(domain.get());
 }
 
-TEST_F(TaskQueueManagerTest, TimeDomainObserver_DelayedTask) {
+TEST_F(TaskQueueManagerTest, TaskQueueObserver_DelayedTask) {
   Initialize(1u);
 
-  MockTimeDomainObserver observer;
-  std::unique_ptr<VirtualTimeDomain> domain(
-      new VirtualTimeDomain(&observer, manager_->Delegate()->NowTicks()));
-  manager_->RegisterTimeDomain(domain.get());
-  runners_[0]->SetTimeDomain(domain.get());
+  MockTaskQueueObserver observer;
+  runners_[0]->SetObserver(&observer);
 
   // We should get a notification when a delayed task is posted on an empty
   // queue.
-  EXPECT_CALL(observer, OnTimeDomainHasDelayedWork(runners_[0].get()));
+  EXPECT_CALL(observer, OnQueueNextWakeUpChanged(runners_[0].get(), _));
   runners_[0]->PostDelayedTask(FROM_HERE, base::Bind(&NopTask),
                                base::TimeDelta::FromSeconds(10));
   Mock::VerifyAndClearExpectations(&observer);
 
   // We should not get a notification for a longer delay.
-  EXPECT_CALL(observer, OnTimeDomainHasDelayedWork(_)).Times(0);
+  EXPECT_CALL(observer, OnQueueNextWakeUpChanged(_, _)).Times(0);
   runners_[0]->PostDelayedTask(FROM_HERE, base::Bind(&NopTask),
                                base::TimeDelta::FromSeconds(100));
   Mock::VerifyAndClearExpectations(&observer);
 
   // We should get a notification for a shorter delay.
-  EXPECT_CALL(observer, OnTimeDomainHasDelayedWork(runners_[0].get()));
+  EXPECT_CALL(observer, OnQueueNextWakeUpChanged(runners_[0].get(), _));
   runners_[0]->PostDelayedTask(FROM_HERE, base::Bind(&NopTask),
                                base::TimeDelta::FromSeconds(1));
   Mock::VerifyAndClearExpectations(&observer);
@@ -1762,26 +1758,24 @@ TEST_F(TaskQueueManagerTest, TimeDomainObserver_DelayedTask) {
 
   // When a queue has been enabled, we may get a notification if the
   // TimeDomain's next scheduled wake-up has changed.
-  EXPECT_CALL(observer, OnTimeDomainHasDelayedWork(runners_[0].get()));
+  EXPECT_CALL(observer, OnQueueNextWakeUpChanged(runners_[0].get(), _));
   voter->SetQueueEnabled(true);
 
   // Tidy up.
   runners_[0]->UnregisterTaskQueue();
-  manager_->UnregisterTimeDomain(domain.get());
 }
 
-TEST_F(TaskQueueManagerTest, TimeDomainObserver_DelayedTaskMultipleQueues) {
+TEST_F(TaskQueueManagerTest, TaskQueueObserver_DelayedTaskMultipleQueues) {
   Initialize(2u);
 
-  MockTimeDomainObserver observer;
-  std::unique_ptr<VirtualTimeDomain> domain(
-      new VirtualTimeDomain(&observer, manager_->Delegate()->NowTicks()));
-  manager_->RegisterTimeDomain(domain.get());
-  runners_[0]->SetTimeDomain(domain.get());
-  runners_[1]->SetTimeDomain(domain.get());
+  MockTaskQueueObserver observer;
+  runners_[0]->SetObserver(&observer);
+  runners_[1]->SetObserver(&observer);
 
-  EXPECT_CALL(observer, OnTimeDomainHasDelayedWork(runners_[0].get())).Times(1);
-  EXPECT_CALL(observer, OnTimeDomainHasDelayedWork(runners_[1].get())).Times(1);
+  EXPECT_CALL(observer, OnQueueNextWakeUpChanged(runners_[0].get(), _))
+      .Times(1);
+  EXPECT_CALL(observer, OnQueueNextWakeUpChanged(runners_[1].get(), _))
+      .Times(1);
   runners_[0]->PostDelayedTask(FROM_HERE, base::Bind(&NopTask),
                                base::TimeDelta::FromSeconds(1));
   runners_[1]->PostDelayedTask(FROM_HERE, base::Bind(&NopTask),
@@ -1794,30 +1788,29 @@ TEST_F(TaskQueueManagerTest, TimeDomainObserver_DelayedTaskMultipleQueues) {
       runners_[1]->CreateQueueEnabledVoter();
 
   // Disabling a queue should not trigger a notification.
-  EXPECT_CALL(observer, OnTimeDomainHasDelayedWork(_)).Times(0);
+  EXPECT_CALL(observer, OnQueueNextWakeUpChanged(_, _)).Times(0);
   voter0->SetQueueEnabled(false);
   Mock::VerifyAndClearExpectations(&observer);
 
   // Re-enabling it should should also trigger a notification.
-  EXPECT_CALL(observer, OnTimeDomainHasDelayedWork(runners_[0].get()));
+  EXPECT_CALL(observer, OnQueueNextWakeUpChanged(runners_[0].get(), _));
   voter0->SetQueueEnabled(true);
   Mock::VerifyAndClearExpectations(&observer);
 
   // Disabling a queue should not trigger a notification.
-  EXPECT_CALL(observer, OnTimeDomainHasDelayedWork(_)).Times(0);
+  EXPECT_CALL(observer, OnQueueNextWakeUpChanged(_, _)).Times(0);
   voter1->SetQueueEnabled(false);
   Mock::VerifyAndClearExpectations(&observer);
 
   // Re-enabling it should should trigger a notification.
-  EXPECT_CALL(observer, OnTimeDomainHasDelayedWork(runners_[1].get()));
+  EXPECT_CALL(observer, OnQueueNextWakeUpChanged(runners_[1].get(), _));
   voter1->SetQueueEnabled(true);
   Mock::VerifyAndClearExpectations(&observer);
 
   // Tidy up.
-  EXPECT_CALL(observer, OnTimeDomainHasDelayedWork(_)).Times(AnyNumber());
+  EXPECT_CALL(observer, OnQueueNextWakeUpChanged(_, _)).Times(AnyNumber());
   runners_[0]->UnregisterTaskQueue();
   runners_[1]->UnregisterTaskQueue();
-  manager_->UnregisterTimeDomain(domain.get());
 }
 
 namespace {
@@ -2860,6 +2853,9 @@ TEST_F(TaskQueueManagerTest, GetNextScheduledWakeUp) {
 TEST_F(TaskQueueManagerTest, SetTimeDomainForDisabledQueue) {
   Initialize(1u);
 
+  MockTaskQueueObserver observer;
+  runners_[0]->SetObserver(&observer);
+
   runners_[0]->PostDelayedTask(FROM_HERE, base::Bind(&NopTask),
                                base::TimeDelta::FromMilliseconds(1));
 
@@ -2867,12 +2863,11 @@ TEST_F(TaskQueueManagerTest, SetTimeDomainForDisabledQueue) {
       runners_[0]->CreateQueueEnabledVoter();
   voter->SetQueueEnabled(false);
 
-  MockTimeDomainObserver observer;
   // We should not get a notification for a disabled queue.
-  EXPECT_CALL(observer, OnTimeDomainHasDelayedWork(_)).Times(0);
+  EXPECT_CALL(observer, OnQueueNextWakeUpChanged(_, _)).Times(0);
 
   std::unique_ptr<VirtualTimeDomain> domain(
-      new VirtualTimeDomain(&observer, manager_->Delegate()->NowTicks()));
+      new VirtualTimeDomain(manager_->Delegate()->NowTicks()));
   manager_->RegisterTimeDomain(domain.get());
   runners_[0]->SetTimeDomain(domain.get());