Adding flow traces for blink scheduler events

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/TracedTask.h"
 #include "wtf/DoubleBufferedDeque.h"
 #include "wtf/Functional.h"
 #include "wtf/Noncopyable.h"
 #include "wtf/ThreadingPrimitives.h"
 
 namespace blink {
 class WebThread;
 struct WebBeginFrameArgs;
 
 // The scheduler is an opinionated gateway for arranging work to be run on the
@@ skipping 42 matching lines @@
     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();
     virtual ~Scheduler();
 
+    void scheduleIdleTask(const TraceLocation&, const IdleTask&);
+    void postHighPriorityTaskInternal(const TraceLocation&, const Task&, const char* traceName);
+
     static void sharedTimerAdapter();
 
-
     // 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;
 
     WebThread* m_mainThread;
 
     // This mutex protects calls to the pending task queue, m_highPriorityTaskRunnerPosted and
     // m_compositorPriorityPolicyEndTimeSeconds.
     Mutex m_pendingTasksMutex;
     DoubleBufferedDeque<TracedTask> m_pendingHighPriorityTasks;
     double m_compositorPriorityPolicyEndTimeSeconds;
 
+    // Declared volatile as it is atomically incremented.
     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