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 59 matching lines @@
   // Adds a task at the end of the incoming task queue and schedules a call to
   // TaskQueueManager::DoWork() if the incoming queue was empty and automatic
   // pumping is enabled. Can be called on an arbitrary thread.
   void EnqueueTask(const base::PendingTask& pending_task);
 
   void PumpQueueLocked();
   bool ShouldAutoPumpQueueLocked(
       TaskQueueManager::WorkQueueUpdateEventType event_type);
   void EnqueueTaskLocked(const base::PendingTask& pending_task);
 
-  void TraceWorkQueueSize() const;
+  void TraceQueueSize(bool is_locked) const;
   static const char* PumpPolicyToString(
       TaskQueueManager::PumpPolicy pump_policy);
   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_;
@@ skipping 83 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 (!ShouldAutoPumpQueueLocked(event_type))
       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)
+    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 (pump_policy_ == TaskQueueManager::AUTO_PUMP_POLICY &&
       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::SetPumpPolicy(TaskQueueManager::PumpPolicy pump_policy) {
   base::AutoLock lock(lock_);
   if (pump_policy == TaskQueueManager::AUTO_PUMP_POLICY &&
       pump_policy_ != TaskQueueManager::AUTO_PUMP_POLICY) {
     PumpQueueLocked();
   }
   pump_policy_ = pump_policy;
 }
@@ skipping 305 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