cc:: Add RenderingStatsInstrumentation to manage collection of RenderingStats

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 "base/bind.h"
 #include "base/debug/trace_event.h"
 #include "base/stringprintf.h"
 #include "base/synchronization/condition_variable.h"
 #include "base/threading/simple_thread.h"
-#include "cc/rendering_stats.h"
 
 #if defined(OS_ANDROID)
 // TODO(epenner): Move thread priorities to base. (crbug.com/170549)
 #include <sys/resource.h>
 #endif
 
 namespace cc {
 
 namespace {
 
 class WorkerPoolTaskImpl : public internal::WorkerPoolTask {
  public:
   WorkerPoolTaskImpl(const WorkerPool::Callback& task,
                      const base::Closure& reply)
       : internal::WorkerPoolTask(reply),
         task_(task) {}
 
   virtual bool IsCheap() OVERRIDE { return false; }
 
-  virtual void Run(RenderingStats* rendering_stats) OVERRIDE {
-    task_.Run(rendering_stats);
+  virtual void Run() OVERRIDE {
+    task_.Run();
   }
 
-  virtual void RunOnThread(
-      RenderingStats* rendering_stats, unsigned thread_index) OVERRIDE {
-    task_.Run(rendering_stats);
+  virtual void RunOnThread(unsigned thread_index) OVERRIDE {
+    task_.Run();
   }
 
  private:
   WorkerPool::Callback task_;
 };
 
 }  // namespace
 
 namespace internal {
 
@@ skipping 15 matching lines @@
 class WorkerPool::Inner : public base::DelegateSimpleThread::Delegate {
  public:
   Inner(WorkerPool* worker_pool,
         size_t num_threads,
         const std::string& thread_name_prefix,
         bool need_on_task_completed_callback);
   ~Inner();
 
   void Shutdown();
 
-  void SetRecordRenderingStats(bool record_rendering_stats);
-
-  void GetRenderingStats(RenderingStats* stats);
-
   void PostTask(scoped_ptr<internal::WorkerPoolTask> task);
 
   // Appends all completed tasks to worker pool's completed tasks queue
   // and returns true if idle.
   bool CollectCompletedTasks();
 
   // Runs cheap tasks on caller thread until |time_limit| is reached
   // and returns true if idle.
   bool RunCheapTasksUntilTimeLimit(base::TimeTicks time_limit);
 
@@ skipping 54 matching lines @@
   unsigned running_task_count_;
 
   // Set during shutdown. Tells workers to exit when no more tasks
   // are pending.
   bool shutdown_;
 
   typedef ScopedPtrDeque<internal::WorkerPoolTask> TaskDeque;
   TaskDeque pending_tasks_;
   TaskDeque completed_tasks_;
 
-  scoped_ptr<RenderingStats> rendering_stats_;
-
   ScopedPtrDeque<base::DelegateSimpleThread> workers_;
 
   DISALLOW_COPY_AND_ASSIGN(Inner);
 };
 
 WorkerPool::Inner::Inner(WorkerPool* worker_pool,
                          size_t num_threads,
                          const std::string& thread_name_prefix,
                          bool need_on_task_completed_callback)
     : worker_pool_on_origin_thread_(worker_pool),
@@ skipping 49 matching lines @@
     // to exit as each will wake up another worker before exiting.
     has_pending_tasks_cv_.Signal();
   }
 
   while (workers_.size()) {
     scoped_ptr<base::DelegateSimpleThread> worker = workers_.take_front();
     worker->Join();
   }
 }
 
-void WorkerPool::Inner::SetRecordRenderingStats(bool record_rendering_stats) {
-  base::AutoLock lock(lock_);
-
-  if (record_rendering_stats)
-    rendering_stats_.reset(new RenderingStats);
-  else
-    rendering_stats_.reset();
-}
-
-void WorkerPool::Inner::GetRenderingStats(RenderingStats* stats) {
-  base::AutoLock lock(lock_);
-
-  if (rendering_stats_)
-    stats->Add(*rendering_stats_);
-}
-
 void WorkerPool::Inner::PostTask(scoped_ptr<internal::WorkerPoolTask> task) {
   base::AutoLock lock(lock_);
 
   pending_tasks_.push_back(task.Pass());
 
   // There is more work available, so wake up worker thread.
   has_pending_tasks_cv_.Signal();
 }
 
 bool WorkerPool::Inner::CollectCompletedTasks() {
@@ skipping 21 matching lines @@
 
     if (!task) {
       // Schedule an idle callback if requested and not pending.
       if (!running_task_count_ && pending_tasks_.empty())
         ScheduleOnIdleWithLockAcquired();
 
       // Exit when no more cheap tasks are pending.
       break;
     }
 
-    scoped_ptr<RenderingStats> rendering_stats;
-    // Collect rendering stats if |rendering_stats_| is set.
-    if (rendering_stats_)
-      rendering_stats = make_scoped_ptr(new RenderingStats);
-
     // Increment |running_task_count_| before starting to run task.
     running_task_count_++;
 
     {
       base::AutoUnlock unlock(lock_);
 
-      task->Run(rendering_stats.get());
+      task->Run();
 
       // Append tasks directly to worker pool's completed tasks queue.
       worker_pool_on_origin_thread_->completed_tasks_.push_back(task.Pass());
       if (need_on_task_completed_callback_)
         worker_pool_on_origin_thread_->OnTaskCompleted();
     }
 
-    // Add rendering stat results to |rendering_stats_|.
-    if (rendering_stats && rendering_stats_)
-      rendering_stats_->Add(*rendering_stats);
-
     // Decrement |running_task_count_| now that we are done running task.
     running_task_count_--;
   }
 
   // Append any other completed tasks before releasing lock.
   return AppendCompletedTasksWithLockAcquired(
       &worker_pool_on_origin_thread_->completed_tasks_);
 }
 
 bool WorkerPool::Inner::AppendCompletedTasksWithLockAcquired(
@@ skipping 80 matching lines @@
           ScheduleOnIdleWithLockAcquired();
 
         // Wait for new pending tasks.
         has_pending_tasks_cv_.Wait();
         continue;
       }
 
       // Get next task.
       scoped_ptr<internal::WorkerPoolTask> task = pending_tasks_.take_front();
 
-      scoped_ptr<RenderingStats> rendering_stats;
-      // Collect rendering stats if |rendering_stats_| is set.
-      if (rendering_stats_)
-        rendering_stats = make_scoped_ptr(new RenderingStats);
-
       // Increment |running_task_count_| before starting to run task.
       running_task_count_++;
 
       // There may be more work available, so wake up another
       // worker thread.
       has_pending_tasks_cv_.Signal();
 
       {
         base::AutoUnlock unlock(lock_);
 
-        task->RunOnThread(rendering_stats.get(), thread_index);
+        task->RunOnThread(thread_index);
       }
 
       completed_tasks_.push_back(task.Pass());
 
-      // Add rendering stat results to |rendering_stats_|.
-      if (rendering_stats && rendering_stats_)
-        rendering_stats_->Add(*rendering_stats);
-
       // Decrement |running_task_count_| now that we are done running task.
       running_task_count_--;
 
       // Schedule a task completed callback if requested and not pending.
       ScheduleOnTaskCompletedWithLockAcquired();
     }
 
     // We noticed we should exit. Wake up the next worker so it knows it should
     // exit as well (because the Shutdown() code only signals once).
     has_pending_tasks_cv_.Signal();
@@ skipping 43 matching lines @@
                                task,
                                reply)).PassAs<internal::WorkerPoolTask>());
 }
 
 void WorkerPool::SetRunCheapTasksTimeLimit(
     base::TimeTicks run_cheap_tasks_time_limit) {
   run_cheap_tasks_time_limit_ = run_cheap_tasks_time_limit;
   ScheduleRunCheapTasks();
 }
 
-void WorkerPool::SetRecordRenderingStats(bool record_rendering_stats) {
-  inner_->SetRecordRenderingStats(record_rendering_stats);
-}
-
-void WorkerPool::GetRenderingStats(RenderingStats* stats) {
-  inner_->GetRenderingStats(stats);
-}
-
 void WorkerPool::OnIdle() {
   TRACE_EVENT0("cc", "WorkerPool::OnIdle");
 
   DispatchCompletionCallbacks();
 }
 
 void WorkerPool::OnTaskCompleted() {
   TRACE_EVENT0("cc", "WorkerPool::OnTaskCompleted");
 
   DispatchCompletionCallbacks();
@@ skipping 92 matching lines @@
     TRACE_EVENT_INSTANT0("cc", "WorkerPool::RunCheapTasks check time");
     CancelCheckForCompletedTasks();
     DispatchCompletionCallbacks();
     // Schedule another check for completed tasks if not idle.
     if (!is_idle)
       ScheduleCheckForCompletedTasks();
   }
 }
 
 }  // namespace cc