Prioritizing input and compositor tasks in the blink scheduler.

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 "platform/scheduler/DoubleBufferedDeque.h"
 #include "wtf/Functional.h"
 #include "wtf/Noncopyable.h"
+#include "wtf/ThreadingPrimitives.h"
 
 namespace blink {
 class WebThread;
 }
 
 namespace blink {
 
 class TraceLocation;
 
 // The scheduler is an opinionated gateway for arranging work to be run on the
@@ skipping 12 matching lines @@
 
     // 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 IdleTask&); // For non-critical tasks which may be reordered relative to other task types.
 
     // 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
     // get preempted by higher priority work.
     void setSharedTimerFiredFunction(void (*function)());
     void setSharedTimerFireInterval(double);
     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;
+
+    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
 
 #endif // Scheduler_h