Prioritizing input and compositor tasks in the blink scheduler.

Source/platform/scheduler/Scheduler.h

Index: Source/platform/scheduler/Scheduler.h
diff --git a/Source/platform/scheduler/Scheduler.h b/Source/platform/scheduler/Scheduler.h
index c492e580aa17268afe30b6c439a9c08acd08638f..148f0dadd106ddda218ccc38ccf9f1f661681a32 100644
--- a/Source/platform/scheduler/Scheduler.h
+++ b/Source/platform/scheduler/Scheduler.h
@@ -6,8 +6,11 @@
 #define Scheduler_h
 
 #include "platform/PlatformExport.h"
+#include "platform/TraceLocation.h"
+#include "platform/scheduler/DoubleBufferedDeque.h"
 #include "wtf/Functional.h"
 #include "wtf/Noncopyable.h"
+#include "wtf/ThreadingPrimitives.h"
 
 namespace blink {
 class WebThread;
@@ -40,7 +43,7 @@ public:
 
     // 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 the main thread.
+    // Can be called on any thread.
     bool shouldYieldForHighPriorityWork();
 
     // The shared timer can be used to schedule a periodic callback which may
@@ -50,19 +53,43 @@ public:
     void stopSharedTimer();
 
 private:
+    class MainThreadPendingTaskRunner;

[eseidel, 2014/08/08 17:31:07]

Do you need these forward declarations in order to use the class?  Also, doesn't
this forward-declare them as classes scoped to this class's namespace?  That
seems wrong.  I would expect you'd wnat these at the top inside blink { but not
inside the class itself.  I worry some compiler variant might choke.

[alexclarke, 2014/08/12 11:37:02]

gcc requires this sadly.
We don't want incrementMainThreadTaskRunnerCount(),
decrementMainThreadTaskRunnerCount() or 
runHighPriorityTasks() to be part of the public interface.

If this was java those methods would be package protected.
I'd be surprised if we where going to have problems here since Lakos style
PIMPLs (http://advancedcpp.livejournal.com/9332.html) have been commonly used in
C++ for many years.

+    class MainThreadPendingHighPriorityTaskRunner;
+    friend class MainThreadPendingTaskRunner;
+    friend class MainThreadPendingHighPriorityTaskRunner;
+
     Scheduler();
     ~Scheduler();
 
-    void scheduleTask(const TraceLocation&, const Task&);
     void scheduleIdleTask(const IdleTask&);
 
     static void sharedTimerAdapter();
     void tickSharedTimer();
 
     static Scheduler* s_sharedScheduler;
-    blink::WebThread* m_mainThread;
 
+    class TracedTask {

[eseidel, 2014/08/08 17:31:07]

How is this different from Task?  Can all Tasks's be traced?  Also, shouldnt'
this be Noncopyable?

[alexclarke, 2014/08/12 11:37:02]

Done.
No since these are held inside a WTF::Deque which does copying.

+    public:
+        TracedTask(const Task& task, const TraceLocation& location)
+            : m_task(task)
+            , m_location(location) { }
+
+        void run();
+
+    private:
+        Task m_task;
+        TraceLocation m_location;
+    };
+
+    void maybePostMainThreadPendingHighPriorityTaskRunner();
+    void runHighPriorityTasks();
+
+    // These members can be accessed from any thread.
+    blink::WebThread* m_mainThread;

[eseidel, 2014/08/08 17:31:07]

You shouldn't need blink:: here.

[alexclarke, 2014/08/12 11:37:02]

Done.

+    DoubleBufferedDeque<TracedTask> m_pendingInputTasks;
+    DoubleBufferedDeque<TracedTask> m_pendingCompositorTasks;
     void (*m_sharedTimerFunction)();
+    volatile int m_mainThreadTaskRunnerCount;
 };
 
 } // namespace blink