content: Add heartbeat trace for CategorizedWorkerPool.

content/renderer/categorized_worker_pool.cc

 // Copyright 2015 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/categorized_worker_pool.h"
 
 #include <string>
 #include <utility>
 #include <vector>
 
 #include "base/strings/stringprintf.h"
 #include "base/threading/thread_restrictions.h"
 #include "base/trace_event/trace_event.h"
 #include "cc/base/math_util.h"
 #include "cc/raster/task_category.h"
 
 namespace content {
 namespace {
 
+constexpr int kHeartbeatIntervalInSeconds = 60;  // 1 minute
+
 // A thread which forwards to CategorizedWorkerPool::Run with the runnable
 // categories.
 class CategorizedWorkerPoolThread : public base::SimpleThread {
  public:
   CategorizedWorkerPoolThread(
       const std::string& name_prefix,
       const Options& options,
       CategorizedWorkerPool* pool,
       std::vector<cc::TaskCategory> categories,
       base::ConditionVariable* has_ready_to_run_tasks_cv)
@@ skipping 202 matching lines @@
     if (!RunTaskWithLockAcquired(categories)) {
       // We are no longer running tasks, which may allow another category to
       // start running. Signal other worker threads.
       SignalHasReadyToRunTasksWithLockAcquired();
 
       // Exit when shutdown is set and no more tasks are pending.
       if (shutdown_)
         break;
 
       // Wait for more tasks.
-      has_ready_to_run_tasks_cv->Wait();
+      WaitForMoreTasksWithLockAcquired(has_ready_to_run_tasks_cv);
       continue;
     }
   }
 }
 
+void CategorizedWorkerPool::WaitForMoreTasksWithLockAcquired(
+    base::ConditionVariable* has_ready_to_run_tasks_cv) {
+  const base::TimeDelta timeout =
+      base::TimeDelta::FromSeconds(kHeartbeatIntervalInSeconds);
+  while (has_ready_to_run_tasks_cv->TimedWait(timeout)) {
+    TRACE_EVENT_INSTANT0(
+        "heartbeat", "CategorizedWorkerPool::HeartbeatDuringWaitForMoreTasks",
+        TRACE_EVENT_SCOPE_THREAD);
+  }
+}
+
 void CategorizedWorkerPool::FlushForTesting() {
   base::AutoLock lock(lock_);
 
   while (!work_queue_.HasFinishedRunningTasksInAllNamespaces()) {
     has_namespaces_with_finished_running_tasks_cv_.Wait();
   }
 }
 
 scoped_refptr<base::SequencedTaskRunner>
 CategorizedWorkerPool::CreateSequencedTaskRunner() {
@@ skipping 164 matching lines @@
 
 // Overridden from cc::Task:
 void CategorizedWorkerPool::ClosureTask::RunOnWorkerThread() {
   closure_.Run();
   closure_.Reset();
 }
 
 CategorizedWorkerPool::ClosureTask::~ClosureTask() {}
 
 }  // namespace content