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 "public/platform/WebThread.h"
+#include "wtf/Deque.h"
 #include "wtf/Functional.h"
 #include "wtf/Noncopyable.h"
+#include "wtf/ThreadingPrimitives.h"
 
 namespace blink {
 class WebThread;
 }
 
 namespace blink {
 
 class TraceLocation;

[Sami, 2014/08/07 15:51:27]

I think this forward declaration can be removed now.

 
 // The scheduler is an opinionated gateway for arranging work to be run on the
 // main thread. It decides which tasks get priority over others based on a
 // scheduling policy and the overall system state.
 class PLATFORM_EXPORT Scheduler {
     WTF_MAKE_NONCOPYABLE(Scheduler);
 public:
     typedef Function<void()> Task;
     // An IdleTask is passed an allotted time in CLOCK_MONOTONIC milliseconds and is expected to complete within this timeframe.
     typedef Function<void(double allottedTimeMs)> IdleTask;
@@ skipping 17 matching lines @@
     // 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:
     Scheduler();
     ~Scheduler();
 
-    void scheduleTask(const TraceLocation&, const Task&);
     void scheduleIdleTask(const IdleTask&);
 
     static void sharedTimerAdapter();
     void tickSharedTimer();
 
     static Scheduler* s_sharedScheduler;
+
+    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;
+    };
+
+    class LockingTracedTaskDeque {
+    public:
+        void append(const TracedTask& value);
+        bool isEmpty();
+
+        // Returns true if a task was executed, false otherwise.
+        bool runFirstTaskIfNotEmpty();
+
+    private:
+        WTF::Deque<TracedTask> m_queue;
+        Mutex m_mutex;
+    };
+
+    class MainThreadPendingTaskRunner;

[Sami, 2014/08/07 15:51:26]

It doesn't look like this declaration is needed?

+
+    // These members can be accessed from any thread.
     blink::WebThread* m_mainThread;
+    LockingTracedTaskDeque m_pendingInputTasks;
+    LockingTracedTaskDeque m_pendingCompositorTasks;
+    LockingTracedTaskDeque m_pendingLowPriorityTasks;
+    void (*m_sharedTimerFunction)();

[Sami, 2014/08/07 15:51:26]

This should be separated from the cross-thread fields.

+    volatile int m_mainThreadInFlight;
 
-    void (*m_sharedTimerFunction)();
+    void maybePostTaskLoopOnMainThread();

[Sami, 2014/08/07 15:51:26]

Looks like these got moved after the data members again.

+    void runHighPriorityTasks();
+    void runPendingTasks();
+
+    friend class MainThreadPendingTaskRunner;

[Sami, 2014/08/07 15:51:27]

Could you move this right after the private: line?

 };
 
 } // namespace blink
 
 #endif // Scheduler_h