Adds the concept of Policies to 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 "wtf/DoubleBufferedDeque.h"
@@ skipping 36 matching lines @@
     // 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();
 
-private:
+protected:
     class MainThreadPendingTaskRunner;
     class MainThreadPendingHighPriorityTaskRunner;
     friend class MainThreadPendingTaskRunner;
     friend class MainThreadPendingHighPriorityTaskRunner;
 
+    enum SchedulerPolicy {
+        Normal,
+        CompositorPriority,
+    };
+
     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&);
+    virtual ~Scheduler();
 
     static void sharedTimerAdapter();
-    void tickSharedTimer();
 
-    bool hasPendingHighPriorityWork() const;
+
+    // Start of main thread only members -----------------------------------
+
+    // Only does work in CompositorPriority mode. Returns true if any work was done.
+    bool runPendingHighPriorityTasksIfInCompositorPriority();
+
+    // Returns true if any work was done.
     bool swapQueuesAndRunPendingTasks();
+
     void swapQueuesRunPendingTasksAndAllowHighPriorityTaskRunnerPosting();
 
     // Returns true if any work was done.
     bool executeHighPriorityTasks(Deque<TracedTask>&);
 
+    // Return the current SchedulerPolicy.
+    SchedulerPolicy schedulerPolicy() const;
+
+    void maybeEnterNormalSchedulerPolicy();
+
     // Must be called while m_pendingTasksMutex is locked.
     void maybePostMainThreadPendingHighPriorityTaskRunner();
 
+    void tickSharedTimer();
+
+    void (*m_sharedTimerFunction)();
+
+    // End of main thread only members -------------------------------------
+
+
+    void scheduleIdleTask(const TraceLocation&, const IdleTask&);
+
+    bool hasPendingHighPriorityWork() const;
+
+    void enterSchedulerPolicyLocked(SchedulerPolicy);
+
+    void enterSchedulerPolicy(SchedulerPolicy);
+
     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 calls to the pending task queue, m_highPriorityTaskRunnerPosted and
+    // m_compositorPriorityPolicyEndTimeSeconds.
     Mutex m_pendingTasksMutex;
     DoubleBufferedDeque<TracedTask> m_pendingHighPriorityTasks;
+    double m_compositorPriorityPolicyEndTimeSeconds;
 
     volatile int m_highPriorityTaskCount;
     bool m_highPriorityTaskRunnerPosted;
+
+    // Don't access m_schedulerPolicy directly, use enterSchedulerPolicyLocked and SchedulerPolicy instead.
+    volatile int m_schedulerPolicy;
 };
 
 } // namespace blink
 
 #endif // Scheduler_h