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 25 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.
 
-    // 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.
+    // Returns true if we're in low latency mode and 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();
 
 private:
     class MainThreadPendingTaskRunner;
     class MainThreadPendingHighPriorityTaskRunner;
     friend class MainThreadPendingTaskRunner;
     friend class MainThreadPendingHighPriorityTaskRunner;
 
+    enum LatencyMode {
+        Normal,
+        LowLatency,

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

What does LowLatency mode mean?  Maybe just a comment to explain?

+    };
+
     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;
+
+    // Only does work in low latency mode. Returns true if any work was done.
+    bool runPendingHighPrioirtyTasksIfInLowLatencyMode();
+
+    // Returns true if any work was done.
     bool swapQueuesAndRunPendingTasks();
     void swapQueuesRunPendingTasksAndAllowHighPriorityTaskRunnerPosting();
 
     // Returns true if any work was done.
     bool executeHighPriorityTasks(Deque<TracedTask>&);
 
     // Must be called while m_pendingTasksMutex is locked.
     void maybePostMainThreadPendingHighPriorityTaskRunner();
 
     static Scheduler* s_sharedScheduler;
 
     // Should only be accessed from the main thread.
     void (*m_sharedTimerFunction)();
 
+    // Should only be accessed from the main thread.
+    LatencyMode latencyMode() const;
+
+    // Can be called from any thread.
+    void setLatencyMode(LatencyMode);
+
     // These members can be accessed from any thread.
     WebThread* m_mainThread;
 
     // This mutex protects calls to the pending task queue and m_highPriorityTaskRunnerPosted.
     Mutex m_pendingTasksMutex;
     DoubleBufferedDeque<TracedTask> m_pendingHighPriorityTasks;
 
     volatile int m_highPriorityTaskCount;
     bool m_highPriorityTaskRunnerPosted;
+
+    volatile int m_latencyMode;
+    double m_lowLatencyModeEndTimeSeconds;
+
+    // The time we should stay in low latency mode for after a touch event.
+    static double s_lowLatencyModeAfterTouchTimeSeconds;
 };
 
 } // namespace blink
 
 #endif // Scheduler_h