scheduler: Trace queue size at post time

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 <queue>
 
 #include "base/bind.h"
 #include "base/trace_event/trace_event.h"
@@ skipping 51 matching lines @@
   ~TaskQueue() override;
 
   bool PostDelayedTaskImpl(const tracked_objects::Location& from_here,
                            const base::Closure& task,
                            base::TimeDelta delay,
                            bool nestable);
 
   void PumpQueueLocked();
   void EnqueueTaskLocked(const base::PendingTask& pending_task);
 
-  void TraceWorkQueueSize() const;
+  void TraceQueueSize(bool is_locked) const;
   static void QueueAsValueInto(const base::TaskQueue& queue,
                                base::trace_event::TracedValue* state);
   static void TaskAsValueInto(const base::PendingTask& task,
                               base::trace_event::TracedValue* state);
 
   // This lock protects all members except the work queue.
   mutable base::Lock lock_;
   TaskQueueManager* task_queue_manager_;
   base::TaskQueue incoming_queue_;
   bool auto_pump_;
@@ skipping 65 matching lines @@
 
   {
     base::AutoLock lock(lock_);
     if (!delayed_task_run_times_.empty()) {
       *next_pending_delayed_task =
           std::min(*next_pending_delayed_task, delayed_task_run_times_.top());
     }
     if (!auto_pump_ || incoming_queue_.empty())
       return false;
     work_queue_.Swap(&incoming_queue_);
-    TraceWorkQueueSize();
+    TraceQueueSize(true);
     return true;
   }
 }
 
 base::PendingTask TaskQueue::TakeTaskFromWorkQueue() {
   base::PendingTask pending_task = work_queue_.front();
   work_queue_.pop();
-  TraceWorkQueueSize();
+  TraceQueueSize(false);
   return pending_task;
 }
 
-void TaskQueue::TraceWorkQueueSize() const {
-  if (!name_)
+void TaskQueue::TraceQueueSize(bool is_locked) const {
+  bool is_tracing;
+  TRACE_EVENT_CATEGORY_GROUP_ENABLED(
+      TRACE_DISABLED_BY_DEFAULT("renderer.scheduler"), &is_tracing);
+  if (!is_tracing || !name_)
     return;
+  if (!is_locked)

[alex clarke (OOO till 29th), 2015/02/25 12:37:51]

Did you consider using lock_.Try() here?

[alex clarke (OOO till 29th), 2015/02/25 12:38:51]

Ah you can't do that on the same thread.

+    lock_.Acquire();
+  else
+    lock_.AssertAcquired();
   TRACE_COUNTER1(TRACE_DISABLED_BY_DEFAULT("renderer.scheduler"), name_,
-                 work_queue_.size());
+                 incoming_queue_.size() + work_queue_.size());
+  if (!is_locked)
+    lock_.Release();
 }
 
 void TaskQueue::EnqueueTask(const base::PendingTask& pending_task) {
   base::AutoLock lock(lock_);
   EnqueueTaskLocked(pending_task);
 }
 
 void TaskQueue::EnqueueTaskLocked(const base::PendingTask& pending_task) {
   lock_.AssertAcquired();
   if (!task_queue_manager_)
     return;
   if (auto_pump_ && incoming_queue_.empty())
     task_queue_manager_->MaybePostDoWorkOnMainRunner();
   incoming_queue_.push(pending_task);
 
   if (!pending_task.delayed_run_time.is_null()) {
     // Update the time of the next pending delayed task.
     while (!delayed_task_run_times_.empty() &&
            delayed_task_run_times_.top() <= pending_task.delayed_run_time) {
       delayed_task_run_times_.pop();
     }
     // Clear the delayed run time because we've already applied the delay
     // before getting here.
     incoming_queue_.back().delayed_run_time = base::TimeTicks();
   }
+  TraceQueueSize(true);
 }
 
 void TaskQueue::SetAutoPump(bool auto_pump) {
   base::AutoLock lock(lock_);
   if (auto_pump) {
     auto_pump_ = true;
     PumpQueueLocked();
   } else {
     auto_pump_ = false;
   }
@@ skipping 254 matching lines @@
   state->EndArray();
   state->BeginDictionary("selector");
   selector_->AsValueInto(state.get());
   state->EndDictionary();
   if (should_run)
     state->SetInteger("selected_queue", selected_queue);
   return state;
 }
 
 }  // namespace content