cc: add rasterize time to continuous painting graph data in impl-side-painting

cc/worker_pool.cc

 // Copyright 2013 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 "cc/worker_pool.h"
 
 #include <algorithm>
 
 #include "base/bind.h"
 #include "base/stl_util.h"
@@ skipping 41 matching lines @@
 }
 
 void WorkerPoolTask::Completed() {
   reply_.Run();
 }
 
 }  // namespace internal
 
 WorkerPool::Worker::Worker(
     WorkerPool* worker_pool,
-    const std::string name,
-    scoped_ptr<RenderingStats> rendering_stats)
+    const std::string name)
     : base::Thread(name.c_str()),
       worker_pool_(worker_pool),
-      weak_ptr_factory_(ALLOW_THIS_IN_INITIALIZER_LIST(this)),
-      rendering_stats_(rendering_stats.Pass()) {
+      weak_ptr_factory_(ALLOW_THIS_IN_INITIALIZER_LIST(this)) {
   Start();
   DCHECK(IsRunning());
 }
 
 WorkerPool::Worker::~Worker() {
   DCHECK(!IsRunning());
   DCHECK_EQ(pending_tasks_.size(), 0);
 }
 
 void WorkerPool::Worker::StopAfterCompletingAllPendingTasks() {
@@ skipping 40 matching lines @@
 
 void WorkerPool::Worker::OnTaskCompleted() {
   CHECK(!pending_tasks_.empty());
 
   scoped_ptr<internal::WorkerPoolTask> task = pending_tasks_.take_front();
   task->Completed();
 
   worker_pool_->DidNumPendingTasksChange();
 }
 
-WorkerPool::WorkerPool(size_t num_threads, bool record_rendering_stats)
+WorkerPool::WorkerPool(size_t num_threads)
     : workers_need_sorting_(false),
       shutdown_(false) {
   const std::string thread_name_prefix = kWorkerThreadNamePrefix;
   while (workers_.size() < num_threads) {
     int thread_number = workers_.size() + 1;
-    scoped_ptr<RenderingStats> rendering_stats = record_rendering_stats ?
-        make_scoped_ptr(new RenderingStats) : scoped_ptr<RenderingStats>();
     workers_.push_back(new Worker(
         this,
-        thread_name_prefix + StringPrintf("Worker%d", thread_number).c_str(),
-        rendering_stats.Pass()));
+        thread_name_prefix + StringPrintf("Worker%d", thread_number).c_str()));
   }
 }
 
 WorkerPool::~WorkerPool() {
   Shutdown();
   STLDeleteElements(&workers_);
 }
 
 void WorkerPool::Shutdown() {
   DCHECK(!shutdown_);
@@ skipping 15 matching lines @@
                           task,
                           reply)).PassAs<internal::WorkerPoolTask>());
 }
 
 bool WorkerPool::IsBusy() {
   Worker* worker = GetWorkerForNextTask();
 
   return worker->num_pending_tasks() >= kNumPendingTasksPerWorker;
 }
 
+void WorkerPool::SetRecordRenderingStats(bool record_rendering_stats) {
+  for (WorkerVector::iterator it = workers_.begin();
+       it != workers_.end(); ++it) {
+    Worker* worker = *it;
+    worker->SetRenderingStats(record_rendering_stats ?
+        make_scoped_ptr(new RenderingStats) : scoped_ptr<RenderingStats>());
+  }
+}
+
 void WorkerPool::GetRenderingStats(RenderingStats* stats) {
   stats->totalRasterizeTime = base::TimeDelta();
   stats->totalPixelsRasterized = 0;
   stats->totalDeferredImageDecodeCount = 0;
   stats->totalDeferredImageDecodeTime = base::TimeDelta();
   for (WorkerVector::iterator it = workers_.begin();
        it != workers_.end(); ++it) {
     Worker* worker = *it;
     CHECK(worker->rendering_stats());
     stats->totalRasterizeTime +=
@@ skipping 19 matching lines @@
 
 void WorkerPool::SortWorkersIfNeeded() {
   if (!workers_need_sorting_)
     return;
 
   std::sort(workers_.begin(), workers_.end(), NumPendingTasksComparator());
   workers_need_sorting_ = false;
 }
 
 }  // namespace cc