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

[Sami, 2014/09/10 16:00:38]

It feels like we don't need to mention the fact that this function depends on
the mode. I think it is adequately captured in the word "should" and the callers
don't really need to know exactly why the scheduler wants them to yield. I would
therefore keep this comment as is.

[alexclarke, 2014/09/10 17:35:37]

Done.

+    // 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 {

[Sami, 2014/09/10 16:00:38]

Unfortunately the word latency is used for various things over the code base and
it's not obvious what it is referring to. How about something a little more
explicit like this -- mostly because I don't think optimizing for latency is the
only mode we need:

enum SchedulingMode {
    Passthrough,  // or NoOp, or whatever
    PreferHighPriorityWork
}

WDYT?

+        Normal,
+        LowLatency,
+    };
+
     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();

[Sami, 2014/09/10 16:00:38]

s/Prioirty/Priority/

[alexclarke, 2014/09/10 17:35:37]

Done.

+
+    // 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.

[Sami, 2014/09/10 16:00:38]

Could you group the thread-specific members next to each other so it is easier
to see at a glance what goes where?

[alexclarke, 2014/09/10 17:35:37]

Done.

+    LatencyMode latencyMode() const;
+
+    // Can be called from any thread.
+    void setLatencyMode(LatencyMode);

[Sami, 2014/09/10 16:00:38]

Maybe call this |enter| instead of |set| to distinguish it from a pure setter as
it also updates the deadline for going back to normal mode.

[alexclarke, 2014/09/10 17:35:37]

Done.

+
     // 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;

[Sami, 2014/09/10 16:00:38]

Can we make this type safe?

I wonder if we should make this & m_pendingHighPriorityTasks a packed bitfield
so we only have one atomic load/store. Premature optimization?

[alexclarke, 2014/09/10 17:35:37]

Well it's not supposed to be accessed directly.  I've added a comment.
Maybe we could, but I think we should defer those optimizations until we're more
certain what overall algorithm we want. 

+    double m_lowLatencyModeEndTimeSeconds;
+
+    // The time we should stay in low latency mode for after a touch event.
+    static double s_lowLatencyModeAfterTouchTimeSeconds;

[Sami, 2014/09/10 16:00:38]

This is constant right? I'd just move it to the anonymous namespace in
Scheduler.cpp (and use kConstantNaming).

[alexclarke, 2014/09/10 17:35:37]

Done.

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