cc: Move more traces to be disabled-by-default around tile management.

content/renderer/raster_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/raster_worker_pool.h"
 
 #include <string>
 #include <utility>
 #include <vector>
 
@@ skipping 231 matching lines @@
 
 RasterWorkerPool::~RasterWorkerPool() {}
 
 cc::NamespaceToken RasterWorkerPool::GetNamespaceToken() {
   base::AutoLock lock(lock_);
   return work_queue_.GetNamespaceToken();
 }
 
 void RasterWorkerPool::ScheduleTasks(cc::NamespaceToken token,
                                      cc::TaskGraph* graph) {
-  TRACE_EVENT2("cc", "RasterWorkerPool::ScheduleTasks", "num_nodes",
+  TRACE_EVENT2("disabled-by-default-cc.debug",
+               "RasterWorkerPool::ScheduleTasks", "num_nodes",
                graph->nodes.size(), "num_edges", graph->edges.size());
   {
     base::AutoLock lock(lock_);
     ScheduleTasksWithLockAcquired(token, graph);
   }
 }
 
 void RasterWorkerPool::ScheduleTasksWithLockAcquired(cc::NamespaceToken token,
                                                      cc::TaskGraph* graph) {
   DCHECK(token.IsValid());
   DCHECK(!cc::TaskGraphWorkQueue::DependencyMismatch(graph));
   DCHECK(!shutdown_);
 
   work_queue_.ScheduleTasks(token, graph);
 
   // If there is more work available, wake up the other worker threads.
   if (work_queue_.HasReadyToRunTasks())
     has_ready_to_run_tasks_cv_.Broadcast();
 }
 
 void RasterWorkerPool::WaitForTasksToFinishRunning(cc::NamespaceToken token) {
-  TRACE_EVENT0("cc", "RasterWorkerPool::WaitForTasksToFinishRunning");
+  TRACE_EVENT0("disabled-by-default-cc.debug",
+               "RasterWorkerPool::WaitForTasksToFinishRunning");
 
   DCHECK(token.IsValid());
 
   {
     base::AutoLock lock(lock_);
     base::ThreadRestrictions::ScopedAllowWait allow_wait;
 
     auto* task_namespace = work_queue_.GetNamespaceForToken(token);
 
     if (!task_namespace)
       return;
 
     while (!work_queue_.HasFinishedRunningTasksInNamespace(task_namespace))
       has_namespaces_with_finished_running_tasks_cv_.Wait();
   }
 }
 
 void RasterWorkerPool::CollectCompletedTasks(
     cc::NamespaceToken token,
     cc::Task::Vector* completed_tasks) {
-  TRACE_EVENT0("cc", "RasterWorkerPool::CollectCompletedTasks");
+  TRACE_EVENT0("disabled-by-default-cc.debug",
+               "RasterWorkerPool::CollectCompletedTasks");
 
   {
     base::AutoLock lock(lock_);
     CollectCompletedTasksWithLockAcquired(token, completed_tasks);
   }
 }
 
 void RasterWorkerPool::CollectCompletedTasksWithLockAcquired(
     cc::NamespaceToken token,
     cc::Task::Vector* completed_tasks) {
@@ skipping 50 matching lines @@
 
 // Overridden from cc::Task:
 void RasterWorkerPool::ClosureTask::RunOnWorkerThread() {
   closure_.Run();
   closure_.Reset();
 }
 
 RasterWorkerPool::ClosureTask::~ClosureTask() {}
 
 }  // namespace content