Add support for Low Priorirty tasks.

Source/platform/scheduler/Scheduler.h

 // 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.
 
 #ifndef Scheduler_h
 #define Scheduler_h
 
 #include "platform/PlatformExport.h"
 #include "platform/TraceLocation.h"
 #include "wtf/DoubleBufferedDeque.h"
@@ skipping 24 matching lines @@
 
     // Called to notify that a previously begun frame was committed.
     void didCommitFrameToCompositor();
 
     // The following entrypoints are used to schedule different types of tasks
     // to be run on the main thread. They can be called from any thread.
     void postInputTask(const TraceLocation&, const Task&);
     void postCompositorTask(const TraceLocation&, const Task&);
     void postTask(const TraceLocation&, const Task&); // For generic (low priority) tasks.
     void postIdleTask(const TraceLocation&, const IdleTask&); // For non-critical tasks which may be reordered relative to other task types.
+    void postIpcTask(const TraceLocation&, const Task&); // For (low priority) tasks posted in response to IPCs

[eseidel, 2014/09/10 16:28:09]

Are IPCs normally low?  I would expect them to be of various priorities...

That said, I would want us to have our prioritization as simple as possible. 
Ideally only 3 priorities or fewer?

 
     // Returns true if there is high priority work pending on the main thread
     // and the caller should yield to let the scheduler service that work.
     // Can be called on any thread.
     bool shouldYieldForHighPriorityWork() const;
 
     // The shared timer can be used to schedule a periodic callback which may
     // get preempted by higher priority work.
     void setSharedTimerFiredFunction(void (*function)());
     void setSharedTimerFireInterval(double);
     void stopSharedTimer();
 
+    // Returns the predicted next compositor start time based on data provided by willBeginFrame.
+    double nextPredictedCompositorStart();

[eseidel, 2014/09/10 16:28:09]

Should this be on the Scheduler directly?  Or some sort of CompositorFrame
object?

+
+    // Returns the predicted next compositor deadline time based on data provided by willBeginFrame.
+    double nextPredictedCompositorDeadline();
+
 private:
     class MainThreadPendingTaskRunner;
     class MainThreadPendingHighPriorityTaskRunner;
+    class MainThreadPendingLowPriorityTaskRunner;
     friend class MainThreadPendingTaskRunner;
     friend class MainThreadPendingHighPriorityTaskRunner;
+    friend class MainThreadPendingLowPriorityTaskRunner;
 
     class TracedTask {
     public:
         TracedTask(const Task& task, const TraceLocation& location)
             : m_task(task)
             , m_location(location) { }
 
         void run();
 
     private:
         Task m_task;
         TraceLocation m_location;
     };
 
     Scheduler();
     ~Scheduler();
 
     void scheduleIdleTask(const TraceLocation&, const IdleTask&);
 
     static void sharedTimerAdapter();
     void tickSharedTimer();
 
     bool hasPendingHighPriorityWork() const;
-    bool swapQueuesAndRunPendingTasks();
-    void swapQueuesRunPendingTasksAndAllowHighPriorityTaskRunnerPosting();
+    bool runPendingHighPrioirtyTasks();
+    void runPendingHighPriorityTasksAndAllowTaskRunnerPosting();
+    void runPendingLowPriorityTasks();
+
+    // If m_activeLowPrioirtyQueue is null or empty, then reloaded it from m_pendingLowPriorityTasks.
+    void reloadEmptyLowPrioirtyQueue();
 
     // Returns true if any work was done.
     bool executeHighPriorityTasks(Deque<TracedTask>&);
 
     // Must be called while m_pendingTasksMutex is locked.
     void maybePostMainThreadPendingHighPriorityTaskRunner();
 
+    // Must be called while m_pendingTasksMutex is locked.

[eseidel, 2014/09/10 16:28:09]

Why not just ASSERT that the thread is locked in the code?

+    void maybePostMainThreadPendingLowPriorityTaskRunner(double currentTime);
+
+    // Must be called while m_pendingTasksMutex is locked.
+    double nextPredictedCompositorStartInternal(double currentTime);
+
+    // Must be called while m_pendingTasksMutex is locked.
+    double nextPredictedCompositorDeadlineInternal(double currentTime);
+
     static Scheduler* s_sharedScheduler;
 
     // Should only be accessed from the main thread.
     void (*m_sharedTimerFunction)();
 
     // These members can be accessed from any thread.
     WebThread* m_mainThread;
 
-    // This mutex protects calls to the pending task queue and m_highPriorityTaskRunnerPosted.
+    // This mutex protects all members of m_mutexProtected.
     Mutex m_pendingTasksMutex;
-    DoubleBufferedDeque<TracedTask> m_pendingHighPriorityTasks;
+    struct {
+        DoubleBufferedDeque<TracedTask> m_pendingHighPriorityTasks;
+        DoubleBufferedDeque<TracedTask> m_pendingLowPriorityTasks;
+        bool m_highPriorityTaskRunnerPosted;
+        bool m_lowPriorityTaskRunnerPosted;
+    } m_mutexProtected;

[eseidel, 2014/09/10 16:28:09]

I'm not sure this gets you much.  We certainly could make this a real class
which enforced the lock restriction?

+
+    double m_compositorStart;
+    double m_compositorDeadline;
+    double m_compositorInterval;
 
     volatile int m_highPriorityTaskCount;
-    bool m_highPriorityTaskRunnerPosted;
+    Deque<TracedTask>* m_activeLowPrioirtyQueue;
+
+    static const double s_maximumLowPrioirtyTaskExecutionTimeSeconds;
 };
 
 } // namespace blink
 
 #endif // Scheduler_h