Prevent redundant DoWorks due to canceled delayed tasks

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 9c8ad0dbd1fc5b978fbbd80cd9eaaad1441b0ea9..2bcc642a785ff236270e66b90fb6eb758c713e70 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
@@ -118,6 +118,10 @@ class TaskQueueManagerTest : public testing::Test {
     manager_->UpdateWorkQueues(lazy_now);
   }
 
+  internal::TaskQueueSelector* GetTaskQueueSelector() {
+    return &manager_->selector_;
+  }
+
   std::unique_ptr<base::MessageLoop> message_loop_;
   std::unique_ptr<base::SimpleTestTickClock> now_src_;
   scoped_refptr<TaskQueueManagerDelegateForTest> main_task_runner_;
@@ -1843,5 +1847,180 @@ TEST_F(TaskQueueManagerTestWithTracing, BlameContextAttribution) {
   EXPECT_EQ(2u, events.size());
 }
 
+class CancelableTask {
+ public:
+  CancelableTask() : weak_factory_(this) {}
+
+  void NopTask() {}
+
+  base::WeakPtrFactory<CancelableTask> weak_factory_;
+};
+
+TEST_F(TaskQueueManagerTest, NoWakeUpsForCanceledDelayedTasks) {
+  Initialize(1u);
+
+  base::TimeTicks start_time = manager_->delegate()->NowTicks();
+
+  CancelableTask task1;
+  CancelableTask task2;
+  CancelableTask task3;
+  CancelableTask task4;
+  base::TimeDelta delay1(base::TimeDelta::FromSeconds(5));
+  base::TimeDelta delay2(base::TimeDelta::FromSeconds(10));
+  base::TimeDelta delay3(base::TimeDelta::FromSeconds(15));
+  base::TimeDelta delay4(base::TimeDelta::FromSeconds(30));
+  runners_[0]->PostDelayedTask(
+      FROM_HERE,
+      base::Bind(&CancelableTask::NopTask, task1.weak_factory_.GetWeakPtr()),
+      delay1);
+  runners_[0]->PostDelayedTask(
+      FROM_HERE,
+      base::Bind(&CancelableTask::NopTask, task2.weak_factory_.GetWeakPtr()),
+      delay2);
+  runners_[0]->PostDelayedTask(
+      FROM_HERE,
+      base::Bind(&CancelableTask::NopTask, task3.weak_factory_.GetWeakPtr()),
+      delay3);
+  runners_[0]->PostDelayedTask(
+      FROM_HERE,
+      base::Bind(&CancelableTask::NopTask, task4.weak_factory_.GetWeakPtr()),
+      delay4);
+
+  task2.weak_factory_.InvalidateWeakPtrs();
+  task3.weak_factory_.InvalidateWeakPtrs();
+
+  std::set<base::TimeTicks> run_times;
+
+  for (;;) {

[Sami, 2016/09/13 17:42:53]

nit: could extract this to a helper method -- up to you.

[alex clarke (OOO till 29th), 2016/09/14 09:04:24]

Done.

+    // Advance time if we've run out of immediate work to do.
+    if (GetTaskQueueSelector()->EnabledWorkQueuesEmpty()) {
+      base::TimeTicks run_time;
+      if (manager_->real_time_domain()->NextScheduledRunTime(&run_time)) {
+        now_src_->SetNowTicks(run_time);
+      } else {
+        break;
+      }
+    }
+
+    run_times.insert(now_src_->NowTicks());
+    test_task_runner_->RunPendingTasks();
+  }
+
+  EXPECT_THAT(run_times, ElementsAre(start_time + delay1, start_time + delay4));
+}
+
+TEST_F(TaskQueueManagerTest, NoWakeUpsForCanceledDelayedTasksReversePostOrder) {
+  Initialize(1u);
+
+  base::TimeTicks start_time = manager_->delegate()->NowTicks();
+
+  CancelableTask task1;
+  CancelableTask task2;
+  CancelableTask task3;
+  CancelableTask task4;
+  base::TimeDelta delay1(base::TimeDelta::FromSeconds(5));
+  base::TimeDelta delay2(base::TimeDelta::FromSeconds(10));
+  base::TimeDelta delay3(base::TimeDelta::FromSeconds(15));
+  base::TimeDelta delay4(base::TimeDelta::FromSeconds(30));
+  runners_[0]->PostDelayedTask(
+      FROM_HERE,
+      base::Bind(&CancelableTask::NopTask, task4.weak_factory_.GetWeakPtr()),
+      delay4);
+  runners_[0]->PostDelayedTask(
+      FROM_HERE,
+      base::Bind(&CancelableTask::NopTask, task3.weak_factory_.GetWeakPtr()),
+      delay3);
+  runners_[0]->PostDelayedTask(
+      FROM_HERE,
+      base::Bind(&CancelableTask::NopTask, task2.weak_factory_.GetWeakPtr()),
+      delay2);
+  runners_[0]->PostDelayedTask(
+      FROM_HERE,
+      base::Bind(&CancelableTask::NopTask, task1.weak_factory_.GetWeakPtr()),
+      delay1);
+
+  task2.weak_factory_.InvalidateWeakPtrs();
+  task3.weak_factory_.InvalidateWeakPtrs();
+
+  std::set<base::TimeTicks> run_times;
+
+  for (;;) {
+    // Advance time if we've run out of immediate work to do.
+    if (GetTaskQueueSelector()->EnabledWorkQueuesEmpty()) {
+      base::TimeTicks run_time;
+      if (manager_->real_time_domain()->NextScheduledRunTime(&run_time)) {
+        now_src_->SetNowTicks(run_time);
+      } else {
+        break;
+      }
+    }
+
+    run_times.insert(now_src_->NowTicks());
+    test_task_runner_->RunPendingTasks();
+  }
+
+  EXPECT_THAT(run_times, ElementsAre(start_time + delay1, start_time + delay4));
+}
+
+TEST_F(TaskQueueManagerTest, TimeDomainWakeUpOnlyCancelledIfAllUsesCancelled) {
+  Initialize(1u);
+
+  base::TimeTicks start_time = manager_->delegate()->NowTicks();
+
+  CancelableTask task1;
+  CancelableTask task2;
+  CancelableTask task3;
+  CancelableTask task4;
+  base::TimeDelta delay1(base::TimeDelta::FromSeconds(5));
+  base::TimeDelta delay2(base::TimeDelta::FromSeconds(10));
+  base::TimeDelta delay3(base::TimeDelta::FromSeconds(15));
+  base::TimeDelta delay4(base::TimeDelta::FromSeconds(30));
+  runners_[0]->PostDelayedTask(
+      FROM_HERE,
+      base::Bind(&CancelableTask::NopTask, task1.weak_factory_.GetWeakPtr()),
+      delay1);
+  runners_[0]->PostDelayedTask(
+      FROM_HERE,
+      base::Bind(&CancelableTask::NopTask, task2.weak_factory_.GetWeakPtr()),
+      delay2);
+  runners_[0]->PostDelayedTask(
+      FROM_HERE,
+      base::Bind(&CancelableTask::NopTask, task3.weak_factory_.GetWeakPtr()),
+      delay3);
+  runners_[0]->PostDelayedTask(
+      FROM_HERE,
+      base::Bind(&CancelableTask::NopTask, task4.weak_factory_.GetWeakPtr()),
+      delay4);
+
+  // Post a non-canceled task with |delay3|. So we should still get a wakeup at
+  // |delay3| even though we cancel |task3|.
+  runners_[0]->PostDelayedTask(
+      FROM_HERE, base::Bind(&CancelableTask::NopTask, base::Unretained(&task3)),
+      delay3);
+
+  task2.weak_factory_.InvalidateWeakPtrs();
+  task3.weak_factory_.InvalidateWeakPtrs();
+
+  std::set<base::TimeTicks> run_times;
+
+  for (;;) {
+    // Advance time if we've run out of immediate work to do.
+    if (GetTaskQueueSelector()->EnabledWorkQueuesEmpty()) {
+      base::TimeTicks run_time;
+      if (manager_->real_time_domain()->NextScheduledRunTime(&run_time)) {
+        now_src_->SetNowTicks(run_time);
+      } else {
+        break;
+      }
+    }
+
+    run_times.insert(now_src_->NowTicks());
+    test_task_runner_->RunPendingTasks();
+  }
+
+  EXPECT_THAT(run_times, ElementsAre(start_time + delay1, start_time + delay3,
+                                     start_time + delay4));
+}
+
 }  // namespace scheduler
 }  // namespace blink