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"
@@ skipping 58 matching lines @@
 };
 
 class SchedulerTestingPlatformSupport : blink::TestingPlatformSupport {
 public:
     SchedulerTestingPlatformSupport()
         : TestingPlatformSupport(TestingPlatformSupport::Config())
         , m_sharedTimerFunction(nullptr)
         , m_sharedTimerRunning(false)
         , m_sharedTimerFireInterval(0)
     {
+        WTF::setMonotonicallyIncreasingTimeFunction(getDebugTime);

[Sami, 2014/09/10 16:00:39]

Maybe getMonotonicTimeForTest?

[alexclarke, 2014/09/10 17:35:37]

Done.

+    }
+
+    virtual ~SchedulerTestingPlatformSupport()
+    {
+        WTF::setMonotonicallyIncreasingTimeFunction(0);

[Sami, 2014/09/10 16:00:39]

I hope we're not stomping over some other test by doing this :P

[alexclarke, 2014/09/10 17:35:37]

Likewise.  If it turns out we are, then we can just save and restore it. 
Although that means adding a (trivial) function in WTF to get the current
function.

     }
 
     // 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 s_debugTime;
+    }
+
     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();
     }
 
+    static void setDebugTime(double time)
+    {
+        s_debugTime = time;
+    }
+
 private:
+    static double getDebugTime(void)
+    {
+        return s_debugTime;
+    }
+
     TestMainThread m_mainThread;
     SharedTimerFunction m_sharedTimerFunction;
     bool m_sharedTimerRunning;
     double m_sharedTimerFireInterval;
+
+    static double s_debugTime;
 };
 
+double SchedulerTestingPlatformSupport::s_debugTime = 0;
+
 class SchedulerTest : public testing::Test {
 public:
     SchedulerTest()
         : m_reentrantCount(0)
         , m_maxRecursion(4)
     {
         Scheduler::initializeOnMainThread();
         m_scheduler = Scheduler::shared();
     }
 
@@ skipping 247 matching lines @@
     m_scheduler->setSharedTimerFireInterval(0);
     m_platformSupport.triggerSharedTimer();
 
     EXPECT_EQ(1, s_dummyTaskCount);
 
     // Clean up.
     m_scheduler->stopSharedTimer();
     m_scheduler->setSharedTimerFiredFunction(nullptr);
 }
 
+TEST_F(SchedulerTest, TestInputEventTriggersShouldYield)
+{
+    ASSERT_FALSE(m_scheduler->shouldYieldForHighPriorityWork());
+    m_scheduler->postInputTask(FROM_HERE, WTF::bind(&dummyTask));
+
+    EXPECT_TRUE(m_scheduler->shouldYieldForHighPriorityWork());
+}
+
+TEST_F(SchedulerTest, TestCompositorEventDoesNotTriggerShouldYield_InNormalMode)
+{
+    ASSERT_FALSE(m_scheduler->shouldYieldForHighPriorityWork());
+    m_scheduler->postCompositorTask(FROM_HERE, WTF::bind(&dummyTask));
+
+    EXPECT_FALSE(m_scheduler->shouldYieldForHighPriorityWork());
+}
+
+TEST_F(SchedulerTest, TestInputEventTriggersLowLatencyMode)
+{
+    // Fire off an input task to put us in low latency mode.
+    m_scheduler->postInputTask(FROM_HERE, WTF::bind(&dummyTask));
+    runPendingTasks();
+
+    ASSERT_FALSE(m_scheduler->shouldYieldForHighPriorityWork());
+    m_scheduler->postCompositorTask(FROM_HERE, WTF::bind(&dummyTask));
+
+    EXPECT_TRUE(m_scheduler->shouldYieldForHighPriorityWork());
+}
+
+TEST_F(SchedulerTest, TestCompositorEvent_LowLatencyModeDoesntLastLongWithoutInputEvents)
+{
+    SchedulerTestingPlatformSupport::setDebugTime(1000.0);
+
+    // Fire off an input task to put us in low latency mode.
+    m_scheduler->postInputTask(FROM_HERE, WTF::bind(&dummyTask));
+    SchedulerTestingPlatformSupport::setDebugTime(1000.5);
+    runPendingTasks();
+
+    ASSERT_FALSE(m_scheduler->shouldYieldForHighPriorityWork());
+    m_scheduler->postCompositorTask(FROM_HERE, WTF::bind(&dummyTask));
+
+    EXPECT_FALSE(m_scheduler->shouldYieldForHighPriorityWork());
+}
+
 } // namespace