Implement idle task scheduling.

Source/platform/scheduler/SchedulerTest.cpp

 // Copyright 2014 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 "config.h"
 #include "platform/scheduler/Scheduler.h"
 
 #include "platform/TestingPlatformSupport.h"
 #include "platform/TraceLocation.h"
 #include "public/platform/Platform.h"
@@ skipping 170 matching lines @@
         // If the Scheduler hasn't been shut down then explicitly flush the tasks.
         if (Scheduler::shared())
             runPendingTasks();
     }
 
     void runPendingTasks()
     {
         m_platformSupport.runPendingTasks();
     }
 
+    void enableIdleTasks()
+    {
+        m_platformSupport.setMonotonicTimeForTest(0);
+        m_scheduler->willBeginFrame(1);
+        m_scheduler->didCommitFrameToCompositor();
+    }
+
     void appendToVector(std::string value)
     {
         m_order.push_back(value);
     }
 
+    void appendToVectorIdleTask(std::string value, double deadline)
+    {
+        appendToVector(value);
+    }
+
     void appendToVectorReentrantTask()
     {
         m_reentrantOrder.push_back(m_reentrantCount++);
 
         if (m_reentrantCount > m_maxRecursion)
             return;
         Scheduler::shared()->postTask(FROM_HERE, WTF::bind(&SchedulerTest::appendToVectorReentrantTask, this));
     }
 
     void appendToVectorReentrantInputTask()
     {
         m_reentrantOrder.push_back(m_reentrantCount++);
 
         if (m_reentrantCount > m_maxRecursion)
             return;
         m_scheduler->postInputTask(FROM_HERE, WTF::bind(&SchedulerTest::appendToVectorReentrantInputTask, this));
     }
 
     void appendToVectorReentrantCompositorTask()
     {
         m_reentrantOrder.push_back(m_reentrantCount++);
 
         if (m_reentrantCount > m_maxRecursion)
             return;
         m_scheduler->postCompositorTask(FROM_HERE, WTF::bind(&SchedulerTest::appendToVectorReentrantCompositorTask, this));
     }
-
 protected:
     SchedulerTestingPlatformSupport m_platformSupport;
     SchedulerForTest* m_scheduler;
     std::vector<std::string> m_order;
     std::vector<int> m_reentrantOrder;
     int m_reentrantCount;
     int m_maxRecursion;
 };
 
 void orderedTestTask(int value, int* result)
 {
     *result = (*result << 4) | value;
 }
 
 void unorderedTestTask(int value, int* result)
 {
     *result += value;
 }
 
-void idleTestTask(int value, int* result, double allottedTime)
+void idleTestTask(bool* taskRun, double expectedDeadline, double deadlineSeconds)
 {
-    *result += value;
+    EXPECT_FALSE(*taskRun);
+    EXPECT_EQ(expectedDeadline, deadlineSeconds);
+    *taskRun = true;
 }
 
 TEST_F(SchedulerTest, TestPostTask)
 {
     int result = 0;
     m_scheduler->postTask(FROM_HERE, WTF::bind(&orderedTestTask, 1, &result));
     m_scheduler->postTask(FROM_HERE, WTF::bind(&orderedTestTask, 2, &result));
     m_scheduler->postTask(FROM_HERE, WTF::bind(&orderedTestTask, 3, &result));
     m_scheduler->postTask(FROM_HERE, WTF::bind(&orderedTestTask, 4, &result));
     runPendingTasks();
@@ skipping 31 matching lines @@
 
     m_scheduler->stopSharedTimer();
     EXPECT_FALSE(m_platformSupport.sharedTimerRunning());
 
     m_scheduler->setSharedTimerFiredFunction(nullptr);
     EXPECT_FALSE(m_platformSupport.sharedTimerRunning());
 }
 
 TEST_F(SchedulerTest, TestIdleTask)
 {
-    // TODO: Check task allottedTime when implemented in the scheduler.
-    int result = 0;
-    m_scheduler->postIdleTask(FROM_HERE, WTF::bind<double>(&idleTestTask, 1, &result));
-    m_scheduler->postIdleTask(FROM_HERE, WTF::bind<double>(&idleTestTask, 1, &result));
-    m_scheduler->postIdleTask(FROM_HERE, WTF::bind<double>(&idleTestTask, 1, &result));
-    m_scheduler->postIdleTask(FROM_HERE, WTF::bind<double>(&idleTestTask, 1, &result));
+    bool taskRun = false;
+    double firstDeadline = 1.1;
+    double secondDeadline = 2.3;
+    m_platformSupport.setMonotonicTimeForTest(0.1);
+
+    m_scheduler->postIdleTask(FROM_HERE, WTF::bind<double>(&idleTestTask, &taskRun, secondDeadline));
+
     runPendingTasks();
-    EXPECT_EQ(4, result);
+    EXPECT_FALSE(taskRun); // Shouldn't run yet as no willBeginFrame.
+
+    m_scheduler->willBeginFrame(firstDeadline);
+    runPendingTasks();
+    EXPECT_FALSE(taskRun); // Shouldn't run yet as no didCommitFrameToCompositor.
+
+    m_platformSupport.setMonotonicTimeForTest(firstDeadline + 0.1);
+    m_scheduler->didCommitFrameToCompositor();
+    runPendingTasks();
+    EXPECT_FALSE(taskRun); // We missed the deadline.
+
+    m_scheduler->willBeginFrame(secondDeadline);
+    m_platformSupport.setMonotonicTimeForTest(secondDeadline - 0.1);
+    m_scheduler->didCommitFrameToCompositor();
+    runPendingTasks();
+    EXPECT_TRUE(taskRun);
 }
 
 TEST_F(SchedulerTest, TestTaskPrioritization_normalPolicy)
 {
     m_scheduler->postTask(FROM_HERE, WTF::bind(&SchedulerTest::appendToVector, this, std::string("L1")));
     m_scheduler->postTask(FROM_HERE, WTF::bind(&SchedulerTest::appendToVector, this, std::string("L2")));
     m_scheduler->postInputTask(FROM_HERE, WTF::bind(&SchedulerTest::appendToVector, this, std::string("I1")));
     m_scheduler->postCompositorTask(FROM_HERE, WTF::bind(&SchedulerTest::appendToVector, this, std::string("C1")));
     m_scheduler->postInputTask(FROM_HERE, WTF::bind(&SchedulerTest::appendToVector, this, std::string("I2")));
     m_scheduler->postCompositorTask(FROM_HERE, WTF::bind(&SchedulerTest::appendToVector, this, std::string("C2")));
@@ skipping 12 matching lines @@
 
     EXPECT_THAT(m_reentrantOrder, testing::ElementsAre(0, 1, 2, 3, 4));
 }
 
 TEST_F(SchedulerTest, TestTasksRunAfterShutdown)
 {
     m_scheduler->postTask(FROM_HERE, WTF::bind(&SchedulerTest::appendToVector, this, std::string("1")));
     m_scheduler->postInputTask(FROM_HERE, WTF::bind(&SchedulerTest::appendToVector, this, std::string("2")));
     m_scheduler->postCompositorTask(FROM_HERE, WTF::bind(&SchedulerTest::appendToVector, this, std::string("3")));
     m_scheduler->postIpcTask(FROM_HERE, WTF::bind(&SchedulerTest::appendToVector, this, std::string("4")));
+    // Idle task should not be run if scheduler is shutdown, but should not crash when flushed.
+    m_scheduler->postIdleTask(FROM_HERE, WTF::bind<double>(&SchedulerTest::appendToVectorIdleTask, this, std::string("Not Run")));
+    enableIdleTasks();
 
     Scheduler::shutdown();
     EXPECT_TRUE(m_order.empty());
 
     runPendingTasks();
     EXPECT_THAT(m_order, testing::ElementsAre(
         std::string("1"), std::string("2"), std::string("3"), std::string("4")));
 }
 
 bool s_shouldContinue;
@@ skipping 152 matching lines @@
     m_platformSupport.setMonotonicTimeForTest(1000.5);
     runPendingTasks();
 
     ASSERT_FALSE(m_scheduler->shouldYieldForHighPriorityWork());
     m_scheduler->postCompositorTask(FROM_HERE, WTF::bind(&dummyTask));
 
     EXPECT_FALSE(m_scheduler->shouldYieldForHighPriorityWork());
 }
 
 } // namespace