scheduler: Add support for tracing scheduler state

content/renderer/scheduler/task_queue_manager.cc

 // 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.
 
 #include "content/renderer/scheduler/task_queue_manager.h"
 
 #include "base/bind.h"
 #include "base/debug/trace_event.h"
+#include "base/debug/trace_event_argument.h"
 #include "content/renderer/scheduler/task_queue_selector.h"
 
 namespace content {
 namespace internal {
 
 class TaskQueue : public base::SingleThreadTaskRunner {
  public:
   TaskQueue(TaskQueueManager* task_queue_manager);
 
   // base::SingleThreadTaskRunner implementation.
@@ skipping 16 matching lines @@
   void SetAutoPump(bool auto_pump);
   void PumpQueue();
 
   bool UpdateWorkQueue();
   base::PendingTask TakeTaskFromWorkQueue();
 
   void WillDeleteTaskQueueManager();
 
   base::TaskQueue& work_queue() { return work_queue_; }
 
+  void AsValueInto(base::debug::TracedValue* state);
+
  private:
   virtual ~TaskQueue();
 
   void PumpQueueLocked();
   void EnqueueTaskLocked(const base::PendingTask& pending_task);
 
   // This lock protects all members except the work queue.
   mutable base::Lock lock_;
   TaskQueueManager* task_queue_manager_;
   base::TaskQueue incoming_queue_;
@@ skipping 113 matching lines @@
   }
   if (!work_queue_.empty())
     task_queue_manager_->PostDoWorkOnMainRunner();
 }
 
 void TaskQueue::PumpQueue() {
   base::AutoLock lock(lock_);
   PumpQueueLocked();
 }
 
-}  // namespace
+void TaskQueue::AsValueInto(base::debug::TracedValue* state) {
+  base::AutoLock lock(lock_);
+  state->BeginDictionary();
+  state->BeginArray("incoming_queue");
+  TaskQueueManager::QueueAsValueInto(incoming_queue_, state);
+  state->EndArray();
+  state->BeginArray("work_queue");
+  TaskQueueManager::QueueAsValueInto(work_queue_, state);
+  state->EndArray();
+  state->SetBoolean("auto_pump", auto_pump_);
+  state->EndDictionary();
+}
+
+}  // namespace internal
 
 TaskQueueManager::TaskQueueManager(
     size_t task_queue_count,
     scoped_refptr<base::SingleThreadTaskRunner> main_task_runner,
     TaskQueueSelector* selector)
     : main_task_runner_(main_task_runner),
       selector_(selector),
       weak_factory_(this) {
   DCHECK(main_task_runner->RunsTasksOnCurrentThread());
 
@@ skipping 96 matching lines @@
 }
 
 bool TaskQueueManager::PostNonNestableDelayedTask(
     const tracked_objects::Location& from_here,
     const base::Closure& task,
     base::TimeDelta delay) {
   // Defer non-nestable work to the main task runner.
   return main_task_runner_->PostNonNestableDelayedTask(from_here, task, delay);
 }
 
+void TaskQueueManager::AsValueInto(base::debug::TracedValue* state) const {
+  main_thread_checker_.CalledOnValidThread();
+  state->BeginArray("queues");
+  for (auto& queue : queues_)
+    queue->AsValueInto(state);
+  state->EndArray();
+}
+
+// static
+void TaskQueueManager::QueueAsValueInto(const base::TaskQueue& queue,
+                                        base::debug::TracedValue* state) {
+  base::TaskQueue queue_copy(queue);
+  state->BeginDictionary();
+  state->BeginArray("tasks");
+  while (!queue_copy.empty()) {
+    TaskAsValueInto(queue_copy.front(), state);
+    queue_copy.pop();
+  }
+  state->EndArray();
+  state->EndDictionary();
+}
+
+// static
+void TaskQueueManager::TaskAsValueInto(const base::PendingTask& task,
+                                       base::debug::TracedValue* state) {
+  state->BeginDictionary();
+  state->SetString("posted_from", task.posted_from.ToString());
+  state->SetInteger("sequence_num", task.sequence_num);

[picksi1, 2014/10/28 11:01:40]

do we need the underscores in the strings here?

[Sami, 2014/10/28 12:57:47]

As opposed to camelCase? I think underscores are closer to the json flavor.

[picksi1, 2014/10/28 13:38:59]

As opposed to spaces! I assume this string ends in TraceViewer so only needs to
be human readable (unless there are parsing issues along the way).

[Sami, 2014/10/28 13:42:00]

You could have spaces here per the json spec, but I think we generally prefer
hacker_style. One of the ideas was to write custom visualization for this data
in Trace Viewer, so this isn't necessarily just for humans.

+  state->SetBoolean("nestable", task.nestable);
+  state->SetBoolean("is_high_res", task.is_high_res);
+  state->SetDouble(
+      "time_posted",
+      (task.time_posted - base::TimeTicks()).InMicroseconds() / 1000.0L);
+  state->SetDouble(

[picksi1, 2014/10/28 11:01:40]

ditto: InMillisecondsF?

[Sami, 2014/10/28 12:57:48]

Done.

+      "delayed_run_time",
+      (task.delayed_run_time - base::TimeTicks()).InMicroseconds() / 1000.0L);
+  state->EndDictionary();
+}
+
 }  // namespace content