[blink] Support moving timers between WebTaskRunners

third_party/WebKit/Source/platform/TimerTest.cpp

Index: third_party/WebKit/Source/platform/TimerTest.cpp
diff --git a/third_party/WebKit/Source/platform/TimerTest.cpp b/third_party/WebKit/Source/platform/TimerTest.cpp
index 1135c84eaea3cf98c63a346dbb70f787bedc694f..2288573228a191ba61979ea0517753137e6b3b62 100644
--- a/third_party/WebKit/Source/platform/TimerTest.cpp
+++ b/third_party/WebKit/Source/platform/TimerTest.cpp
@@ -596,5 +596,104 @@ TEST_F(TimerTest, MarkOnHeapTimerAsUnreachable) {
   }
 }
 
+namespace {
+
+class TaskObserver : public base::MessageLoop::TaskObserver {
+ public:
+  TaskObserver(WebTaskRunner* task_runner,
+               std::vector<WebTaskRunner*>* runOrder)
+      : m_taskRunner(task_runner), m_runOrder(runOrder) {}
+
+  void WillProcessTask(const base::PendingTask&) {}
+
+  void DidProcessTask(const base::PendingTask&) {
+    m_runOrder->push_back(m_taskRunner);
+  }
+
+ private:
+  WebTaskRunner* m_taskRunner;
+  std::vector<WebTaskRunner*>* m_runOrder;
+};
+
+}  // namespace
+
+TEST_F(TimerTest, MoveToNewTaskRunnerOneShot) {
+  std::vector<WebTaskRunner*> runOrder;
+
+  scoped_refptr<scheduler::TaskQueue> taskRunner1(
+      m_platform.rendererScheduler()->NewTimerTaskRunner(
+          scheduler::TaskQueue::QueueType::TEST));
+  scheduler::WebTaskRunnerImpl webTaskRunner1(taskRunner1);
+  TaskObserver taskObserver1(&webTaskRunner1, &runOrder);
+  taskRunner1->AddTaskObserver(&taskObserver1);
+
+  scoped_refptr<scheduler::TaskQueue> taskRunner2(
+      m_platform.rendererScheduler()->NewTimerTaskRunner(
+          scheduler::TaskQueue::QueueType::TEST));
+  scheduler::WebTaskRunnerImpl webTaskRunner2(taskRunner2);
+  TaskObserver taskObserver2(&webTaskRunner2, &runOrder);
+  taskRunner2->AddTaskObserver(&taskObserver2);
+
+  TimerForTest<TimerTest> timer(&webTaskRunner1, this,
+                                &TimerTest::countingTask);
+
+  double startTime = monotonicallyIncreasingTime();
+
+  timer.startOneShot(1, BLINK_FROM_HERE);
+
+  m_platform.runForPeriodSeconds(0.5);
+
+  timer.moveToNewTaskRunner(&webTaskRunner2);
+
+  m_platform.runUntilIdle();
+
+  EXPECT_THAT(m_runTimes, ElementsAre(startTime + 1.0));
+
+  EXPECT_THAT(runOrder, ElementsAre(&webTaskRunner2));
+
+  EXPECT_TRUE(taskRunner1->IsEmpty());
+  EXPECT_TRUE(taskRunner2->IsEmpty());
+}
+
+TEST_F(TimerTest, MoveToNewTaskRunnerRepeating) {
+  std::vector<WebTaskRunner*> runOrder;
+
+  scoped_refptr<scheduler::TaskQueue> taskRunner1(
+      m_platform.rendererScheduler()->NewTimerTaskRunner(
+          scheduler::TaskQueue::QueueType::TEST));
+  scheduler::WebTaskRunnerImpl webTaskRunner1(taskRunner1);
+  TaskObserver taskObserver1(&webTaskRunner1, &runOrder);
+  taskRunner1->AddTaskObserver(&taskObserver1);
+
+  scoped_refptr<scheduler::TaskQueue> taskRunner2(
+      m_platform.rendererScheduler()->NewTimerTaskRunner(
+          scheduler::TaskQueue::QueueType::TEST));
+  scheduler::WebTaskRunnerImpl webTaskRunner2(taskRunner2);
+  TaskObserver taskObserver2(&webTaskRunner2, &runOrder);
+  taskRunner2->AddTaskObserver(&taskObserver2);
+
+  TimerForTest<TimerTest> timer(&webTaskRunner1, this,
+                                &TimerTest::countingTask);
+
+  double startTime = monotonicallyIncreasingTime();
+
+  timer.startRepeating(1, BLINK_FROM_HERE);
+
+  m_platform.runForPeriodSeconds(2.5);
+
+  timer.moveToNewTaskRunner(&webTaskRunner2);
+
+  m_platform.runForPeriodSeconds(2);
+
+  EXPECT_THAT(m_runTimes, ElementsAre(startTime + 1.0, startTime + 2.0,
+                                      startTime + 3.0, startTime + 4.0));
+
+  EXPECT_THAT(runOrder, ElementsAre(&webTaskRunner1, &webTaskRunner1,
+                                    &webTaskRunner2, &webTaskRunner2));
+
+  EXPECT_TRUE(taskRunner1->IsEmpty());
+  EXPECT_FALSE(taskRunner2->IsEmpty());
+}
+
 }  // namespace
 }  // namespace blink