scheduler: Post high priority tasks directly to the message loop

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 301 matching lines @@
     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")));
     m_scheduler->postIpcTask(FROM_HERE, WTF::bind(&SchedulerTest::appendToVector, this, std::string("IPC")));
 
     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"),
         std::string("IPC")));
 }
 
-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")));
-    m_scheduler->postIpcTask(FROM_HERE, WTF::bind(&SchedulerTest::appendToVector, this, std::string("IPC")));
-
-    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"),
-        std::string("IPC")));
-}
-
 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));
 }
 
+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")));
 
-TEST_F(SchedulerTest, TestRentrantInputTaskDuringShutdown)
-{
-    m_scheduler->postInputTask(FROM_HERE, WTF::bind(&SchedulerTest::appendToVectorReentrantInputTask, this));
     Scheduler::shutdown();
+    EXPECT_TRUE(m_order.empty());
 
-    EXPECT_THAT(m_reentrantOrder, testing::ElementsAre(0, 1, 2, 3, 4));
-}
-
-TEST_F(SchedulerTest, TestRentrantCompositorTaskDuringShutdown)
-{
-    m_scheduler->postCompositorTask(FROM_HERE, WTF::bind(&SchedulerTest::appendToVectorReentrantCompositorTask, this));
-    Scheduler::shutdown();
-
-    EXPECT_THAT(m_reentrantOrder, testing::ElementsAre(0, 1, 2, 3, 4));
+    runPendingTasks();
+    EXPECT_THAT(m_order, testing::ElementsAre(
+        std::string("1"), std::string("2"), std::string("3"), std::string("4")));
 }
 
 bool s_shouldContinue;
 void reentrantInputTask(Scheduler* scheduler)
 {
     if (s_shouldContinue)
         scheduler->postInputTask(FROM_HERE, WTF::bind(&reentrantInputTask, scheduler));
 }
 
 void reentrantCompositorTask(Scheduler* scheduler)
@@ skipping 26 matching lines @@
     // If starvation occurs then this will never exit.
     runPendingTasks();
 }
 
 int s_dummyTaskCount;
 void dummyTask()
 {
     s_dummyTaskCount++;
 }
 
-TEST_F(SchedulerTest, TestMultipleCallsToPostInputOrCompositorTaskResultsInOnlyOneMainThreadTask)
-{
-    EXPECT_EQ(0U, m_platformSupport.numPendingMainThreadTasks());
-
-    for (int i = 0; i < 10; i++) {
-        m_scheduler->postInputTask(FROM_HERE, WTF::bind(&dummyTask));
-        m_scheduler->postCompositorTask(FROM_HERE, WTF::bind(&dummyTask));
-    }
-
-    EXPECT_EQ(1U, m_platformSupport.numPendingMainThreadTasks());
-}
-
 TEST_F(SchedulerTest, TestMainThreadTaskLifeCycle)
 {
     EXPECT_EQ(0U, m_platformSupport.numPendingMainThreadTasks());
 
     m_scheduler->postInputTask(FROM_HERE, WTF::bind(&dummyTask));
     EXPECT_EQ(1U, m_platformSupport.numPendingMainThreadTasks());
 
     runPendingTasks();
     EXPECT_EQ(0U, m_platformSupport.numPendingMainThreadTasks());
 
@@ skipping 18 matching lines @@
     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, TestDidReceiveInputEventDoesNotTriggerShouldYield)
 {
     m_scheduler->didReceiveInputEvent();
@@ skipping 61 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