Adds the concept of Policies to the Blink Scheduler

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"
 #include "public/platform/WebThread.h"
 
 #include <gmock/gmock.h>
 #include <gtest/gtest.h>
 #include <string>
 #include <vector>
 
 using blink::Scheduler;
 
 namespace {
 
+class SchedulerForTest : public blink::Scheduler {
+public:
+    static void initializeOnMainThread()
+    {
+        s_sharedScheduler = new SchedulerForTest();
+    }
+
+    using Scheduler::Normal;
+    using Scheduler::CompositorPriority;
+    using Scheduler::enterSchedulerPolicy;
+};
+
 class TestMainThread : public blink::WebThread {
 public:
     // blink::WebThread implementation.
     virtual void postTask(Task* task) OVERRIDE
     {
         m_pendingTasks.append(adoptPtr(task));
     }
 
     virtual void postDelayedTask(Task* task, long long delayMs) OVERRIDE
     {
@@ skipping 36 matching lines @@
     WTF::Deque<OwnPtr<Task> > m_pendingTasks;
 };
 
 class SchedulerTestingPlatformSupport : blink::TestingPlatformSupport {
 public:
     SchedulerTestingPlatformSupport()
         : TestingPlatformSupport(TestingPlatformSupport::Config())
         , m_sharedTimerFunction(nullptr)
         , m_sharedTimerRunning(false)
         , m_sharedTimerFireInterval(0)
+        , m_monotonicallyIncreasingTime(0)
     {
     }
 
     // blink::Platform implementation.
     virtual blink::WebThread* currentThread() OVERRIDE
     {
         return &m_mainThread;
     }
 
     virtual void setSharedTimerFiredFunction(SharedTimerFunction timerFunction) OVERRIDE
     {
         m_sharedTimerFunction = timerFunction;
     }
 
+    virtual double monotonicallyIncreasingTime() OVERRIDE
+    {
+        return m_monotonicallyIncreasingTime;
+    }
+
     virtual void setSharedTimerFireInterval(double)
     {
         m_sharedTimerFireInterval = 0;
         m_sharedTimerRunning = true;
     }
 
     virtual void stopSharedTimer()
     {
         m_sharedTimerRunning = false;
     }
@@ skipping 16 matching lines @@
     void triggerSharedTimer()
     {
         m_sharedTimerFunction();
     }
 
     size_t numPendingMainThreadTasks() const
     {
         return m_mainThread.numPendingMainThreadTasks();
     }
 
+    void setMonotonicTimeForTest(double time)
+    {
+        m_monotonicallyIncreasingTime = time;
+    }
+
 private:
     TestMainThread m_mainThread;
     SharedTimerFunction m_sharedTimerFunction;
     bool m_sharedTimerRunning;
     double m_sharedTimerFireInterval;
+    double m_monotonicallyIncreasingTime;
 };
 
 class SchedulerTest : public testing::Test {
 public:
     SchedulerTest()
         : m_reentrantCount(0)
         , m_maxRecursion(4)
     {
-        Scheduler::initializeOnMainThread();
-        m_scheduler = Scheduler::shared();
+        SchedulerForTest::initializeOnMainThread();
+        m_scheduler = static_cast<SchedulerForTest*>(Scheduler::shared());
     }
 
     ~SchedulerTest()
     {
         Scheduler::shutdown();
     }
 
+    virtual void SetUp() OVERRIDE
+    {
+        m_scheduler->enterSchedulerPolicy(SchedulerForTest::Normal);
+    }
+
     void runPendingTasks()
     {
         m_platformSupport.runPendingTasks();
     }
 
     void appendToVector(std::string value)
     {
         m_order.push_back(value);
     }
 
@@ skipping 19 matching lines @@
     {
         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;
-    Scheduler* m_scheduler;
+    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;
 }
@@ skipping 59 matching lines @@
     // 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));
     runPendingTasks();
     EXPECT_EQ(4, result);
 }
 
-TEST_F(SchedulerTest, TestTaskPrioritization)
+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")));
 
     runPendingTasks();
     EXPECT_THAT(m_order, testing::ElementsAre(
+        std::string("L1"), std::string("L2"), std::string("I1"), std::string("C1"), std::string("I2"), std::string("C2")));
+}
+
+TEST_F(SchedulerTest, TestTaskPrioritization_compositorPriorityPolicy)
+{
+    m_scheduler->enterSchedulerPolicy(SchedulerForTest::CompositorPriority);
+    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")));
+
+    runPendingTasks();
+    EXPECT_THAT(m_order, testing::ElementsAre(
         std::string("I1"), std::string("C1"), std::string("I2"), std::string("C2"), std::string("L1"), std::string("L2")));
 }
 
 TEST_F(SchedulerTest, TestRentrantTask)
 {
     m_scheduler->postTask(FROM_HERE, WTF::bind(&SchedulerTest::appendToVectorReentrantTask, this));
     runPendingTasks();
 
     EXPECT_THAT(m_reentrantOrder, testing::ElementsAre(0, 1, 2, 3, 4));
 }
@@ skipping 86 matching lines @@
 
     runPendingTasks();
     EXPECT_EQ(0U, m_platformSupport.numPendingMainThreadTasks());
 }
 
 void postDummyInputTask()
 {
     Scheduler::shared()->postInputTask(FROM_HERE, WTF::bind(&dummyTask));
 }
 
-TEST_F(SchedulerTest, HighPriorityTasksOnlyRunOncePerSharedTimerFiring)
+TEST_F(SchedulerTest, HighPriorityTasksOnlyDontRunBecauseOfSharedTimerFiring_InNormalMode)
 {
     s_dummyTaskCount = 0;
     m_scheduler->postInputTask(FROM_HERE, WTF::bind(&dummyTask));
     // Trigger the posting of an input task during execution of the shared timer function.
     m_scheduler->setSharedTimerFiredFunction(&postDummyInputTask);
+    m_scheduler->setSharedTimerFireInterval(0);
+    m_platformSupport.triggerSharedTimer();
+
+    EXPECT_EQ(0, s_dummyTaskCount);
+
+    // Clean up.
+    m_scheduler->stopSharedTimer();
+    m_scheduler->setSharedTimerFiredFunction(nullptr);
+}
+
+TEST_F(SchedulerTest, HighPriorityTasksOnlyRunOncePerSharedTimerFiring_InLowSchedulerPolicy)
+{
+    s_dummyTaskCount = 0;
+    m_scheduler->enterSchedulerPolicy(SchedulerForTest::CompositorPriority);
+    m_scheduler->postInputTask(FROM_HERE, WTF::bind(&dummyTask));
+    // Trigger the posting of an input task during execution of the shared timer function.
+    m_scheduler->setSharedTimerFiredFunction(&postDummyInputTask);
     m_scheduler->setSharedTimerFireInterval(0);
     m_platformSupport.triggerSharedTimer();
 
     EXPECT_EQ(1, s_dummyTaskCount);
 
     // Clean up.
     m_scheduler->stopSharedTimer();
     m_scheduler->setSharedTimerFiredFunction(nullptr);
 }
 
+TEST_F(SchedulerTest, TestInputEventDoesNotTriggerShouldYield_InNormalMode)
+{
+    m_scheduler->postInputTask(FROM_HERE, WTF::bind(&dummyTask));
+
+    EXPECT_FALSE(m_scheduler->shouldYieldForHighPriorityWork());
+}
+
+TEST_F(SchedulerTest, TestCompositorEventDoesNotTriggerShouldYield_InNormalMode)
+{
+    m_scheduler->postCompositorTask(FROM_HERE, WTF::bind(&dummyTask));
+
+    EXPECT_FALSE(m_scheduler->shouldYieldForHighPriorityWork());
+}
+
+TEST_F(SchedulerTest, TestInputEventDoesTriggerShouldYield_InLowSchedulerPolicy)
+{
+    m_scheduler->enterSchedulerPolicy(SchedulerForTest::CompositorPriority);
+    m_scheduler->postInputTask(FROM_HERE, WTF::bind(&dummyTask));
+
+    EXPECT_TRUE(m_scheduler->shouldYieldForHighPriorityWork());
+}
+
+TEST_F(SchedulerTest, TestCompositorEventDoesTriggerShouldYield_InLowSchedulerPolicy)
+{
+    m_scheduler->enterSchedulerPolicy(SchedulerForTest::CompositorPriority);
+    m_scheduler->postCompositorTask(FROM_HERE, WTF::bind(&dummyTask));
+
+    EXPECT_TRUE(m_scheduler->shouldYieldForHighPriorityWork());
+}
+
+TEST_F(SchedulerTest, TestCompositorEvent_LowSchedulerPolicyDoesntLastLong)
+{
+    m_platformSupport.setMonotonicTimeForTest(1000.0);
+
+    m_scheduler->enterSchedulerPolicy(SchedulerForTest::CompositorPriority);
+    m_scheduler->postInputTask(FROM_HERE, WTF::bind(&dummyTask));
+    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