Modify the scheduler to queue idle work between idle periods.

Source/platform/scheduler/Scheduler.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/PlatformThreadData.h"
 #include "platform/RuntimeEnabledFeatures.h"
 #include "platform/Task.h"
@@ skipping 121 matching lines @@
     ASSERT(isMainThread());
     m_currentFrameCommitted = false;
     m_estimatedNextBeginFrameSeconds = estimatedNextBeginFrameSeconds;
     // TODO: Schedule a deferred task here to run idle work if didCommitFrameToCompositor never gets called.
 }
 
 void Scheduler::didCommitFrameToCompositor()
 {
     ASSERT(isMainThread());
     m_currentFrameCommitted = true;
+    flushIncomingIdleTasks();
     maybePostMainThreadPendingIdleTask();
 }
 
 void Scheduler::postHighPriorityTaskInternal(const TraceLocation& location, const Task& task, const char* traceName)
 {
     m_mainThread->postTask(new MainThreadPendingHighPriorityTaskRunner(task, location, traceName));
     atomicIncrement(&m_highPriorityTaskCount);
     TRACE_COUNTER1(TRACE_DISABLED_BY_DEFAULT("blink.scheduler"), "PendingHighPriorityTasks", m_highPriorityTaskCount);
 }
 
 void Scheduler::didRunHighPriorityTask()
 {
     atomicDecrement(&m_highPriorityTaskCount);
     TRACE_COUNTER1(TRACE_DISABLED_BY_DEFAULT("blink.scheduler"), "PendingHighPriorityTasks", m_highPriorityTaskCount);
 }
 
 void Scheduler::postIdleTaskInternal(const TraceLocation& location, const IdleTask& idleTask, const char* traceName)
 {
-    Locker<Mutex> lock(m_pendingIdleTasksMutex);
-    m_pendingIdleTasks.append(internal::TracedIdleTask::Create(idleTask, location, traceName));
+    Locker<Mutex> lock(m_incomingIdleTasksMutex);
+    m_incomingIdleTasks.append(internal::TracedIdleTask::Create(idleTask, location, traceName));
 }
 
 void Scheduler::postTask(const TraceLocation& location, const Task& task)
 {
     m_mainThread->postTask(new MainThreadPendingTaskRunner(task, location, "Scheduler::MainThreadTask"));
 }
 
 void Scheduler::postInputTask(const TraceLocation& location, const Task& task)
 {
     postHighPriorityTaskInternal(location, task, "Scheduler::InputTask");
@@ skipping 21 matching lines @@
 void Scheduler::postIdleTask(const TraceLocation& location, const IdleTask& idleTask)
 {
     postIdleTaskInternal(location, idleTask, "Scheduler::IdleTask");
 }
 
 bool Scheduler::maybePostMainThreadPendingIdleTask()
 {
     ASSERT(isMainThread());
     TRACE_EVENT0("blink", "Scheduler::maybePostMainThreadPendingIdleTask");
     if (canRunIdleTask()) {
-        Locker<Mutex> lock(m_pendingIdleTasksMutex);
         if (!m_pendingIdleTasks.isEmpty()) {
             m_mainThread->postTask(new MainThreadPendingIdleTaskRunner());
             return true;
         }
     }
     return false;
 }
 
 void Scheduler::tickSharedTimer()
 {
@@ skipping 42 matching lines @@
     // other threads. We could use locks here, but this function is (sometimes) called a lot by
     // ThreadTimers::sharedTimerFiredInternal so we decided to use atomics + barrier loads here which
     // should be cheaper.
     // NOTE it's possible the barrier read is overkill here, since delayed yielding isn't a big deal.
     return acquireLoad(&m_highPriorityTaskCount) != 0;
 }
 
 bool Scheduler::maybeRunPendingIdleTask()
 {
     ASSERT(isMainThread());
-    if (!canRunIdleTask())
+    if (!canRunIdleTask() || m_pendingIdleTasks.isEmpty())
         return false;
 
-    takeFirstPendingIdleTask()->run();
+    m_pendingIdleTasks.takeFirst()->run();
     return true;
 }
 
-PassOwnPtr<internal::TracedIdleTask> Scheduler::takeFirstPendingIdleTask()
+void Scheduler::flushIncomingIdleTasks()
 {
-    Locker<Mutex> lock(m_pendingIdleTasksMutex);
-    ASSERT(!m_pendingIdleTasks.isEmpty());
-    return m_pendingIdleTasks.takeFirst();
+    ASSERT(isMainThread());
+    Locker<Mutex> lock(m_incomingIdleTasksMutex);
+    while (!m_incomingIdleTasks.isEmpty())
+        m_pendingIdleTasks.append(m_incomingIdleTasks.takeFirst());
 }
 
 double Scheduler::currentFrameDeadlineForIdleTasks() const
 {
     ASSERT(isMainThread());
     // TODO: Make idle time more fine-grain chunks when in Compositor priority.
     return m_estimatedNextBeginFrameSeconds;
 }
 
 bool Scheduler::canRunIdleTask() const
@@ skipping 23 matching lines @@
 {
     ASSERT(m_policyStateMutex.locked());
     if (schedulerPolicy == CompositorPriority)
         m_compositorPriorityPolicyEndTimeSeconds = Platform::current()->monotonicallyIncreasingTime() + kLowSchedulerPolicyAfterTouchTimeSeconds;
 
     releaseStore(&m_schedulerPolicy, schedulerPolicy);
     TRACE_COUNTER1(TRACE_DISABLED_BY_DEFAULT("blink.scheduler"), "SchedulerPolicy", schedulerPolicy);
 }
 
 } // namespace blink