cc: Avoid expensive RenderingStats collection.

cc/raster_worker_pool.cc

 // Copyright 2012 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/raster_worker_pool.h"
 
 #include <algorithm>
 
 #include "base/bind.h"
 #include "base/debug/trace_event.h"
@@ skipping 22 matching lines @@
   SkBitmap bitmap;
   bitmap.setConfig(SkBitmap::kARGB_8888_Config, rect.width(), rect.height());
   bitmap.setPixels(buffer);
   SkDevice device(bitmap);
   SkCanvas canvas(&device);
   picture_pile->Raster(&canvas, rect, contents_scale, stats);
 }
 
 void RunImageDecodeTask(skia::LazyPixelRef* pixel_ref, RenderingStats* stats) {
   TRACE_EVENT0("cc", "RunImageDecodeTask");
-  base::TimeTicks decode_begin_time = base::TimeTicks::Now();
+  base::TimeTicks decode_begin_time;
+  if (stats)
+    decode_begin_time = base::TimeTicks::Now();
+
   pixel_ref->Decode();
-  stats->totalDeferredImageDecodeCount++;
-  stats->totalDeferredImageDecodeTime +=
-      base::TimeTicks::Now() - decode_begin_time;
+
+  if (stats) {
+    stats->totalDeferredImageDecodeCount++;
+    stats->totalDeferredImageDecodeTime +=
+        base::TimeTicks::Now() - decode_begin_time;
+  }
 }
 
 const char* kRasterThreadNamePrefix = "CompositorRaster";
 
 // Allow two pending raster tasks per thread. This keeps resource usage
 // low while making sure raster threads aren't unnecessarily idle.
 const int kNumPendingRasterTasksPerThread = 2;
 
 }  // namespace
 
@@ skipping 25 matching lines @@
 }
 
 void RasterWorkerPool::Thread::Init() {
 #if defined(OS_ANDROID)
   // TODO(epenner): Move thread priorities to base. (crbug.com/170549)
   int nice_value = 10; // Idle priority.
   setpriority(PRIO_PROCESS, base::PlatformThread::CurrentId(), nice_value);
 #endif
 }
 
-RasterWorkerPool::RasterWorkerPool(size_t num_raster_threads)
+RasterWorkerPool::RasterWorkerPool(
+    size_t num_raster_threads, bool record_rendering_stats)
     : is_running_(false),
-      raster_threads_need_sorting_(false) {
+      raster_threads_need_sorting_(false),
+      record_rendering_stats_(record_rendering_stats) {
   const std::string thread_name_prefix = kRasterThreadNamePrefix;
   while (raster_threads_.size() < num_raster_threads) {
     int thread_number = raster_threads_.size() + 1;
     raster_threads_.push_back(
         new Thread(thread_name_prefix +
                    StringPrintf("Worker%d", thread_number).c_str()));
   }
 }
 
 RasterWorkerPool::~RasterWorkerPool() {
@@ skipping 45 matching lines @@
   scoped_refptr<PicturePileImpl> picture_pile_clone =
       picture_pile->GetCloneForDrawingOnThread(task->thread_);
 
   task->thread_->message_loop_proxy()->PostTaskAndReply(
       FROM_HERE,
       base::Bind(&RunRasterTask,
                  base::Unretained(picture_pile_clone.get()),
                  buffer,
                  rect,
                  contents_scale,
-                 &task->rendering_stats_),
+                 record_rendering_stats_ ? &task->rendering_stats_ : NULL),
       base::Bind(&RasterWorkerPool::OnRasterTaskCompleted,
                  base::Unretained(this),
                  base::Unretained(task),
                  picture_pile_clone,
                  reply));
 }
 
 void RasterWorkerPool::PostImageDecodeTaskAndReply(
     skia::LazyPixelRef* pixel_ref,
     const base::Closure& reply) {
   CHECK(is_running_);
   Thread::Task* task = CreateTask();
 
   task->thread_->message_loop_proxy()->PostTaskAndReply(
       FROM_HERE,
-      base::Bind(&RunImageDecodeTask, pixel_ref, &task->rendering_stats_),
+      base::Bind(&RunImageDecodeTask, pixel_ref,
+                 record_rendering_stats_ ? &task->rendering_stats_ : NULL),
       base::Bind(&RasterWorkerPool::OnTaskCompleted,
                  base::Unretained(this),
                  base::Unretained(task),
                  reply));
 }
 
 void RasterWorkerPool::GetRenderingStats(RenderingStats* stats) {
+  DCHECK(record_rendering_stats_);
   stats->totalRasterizeTime = base::TimeDelta();
   stats->totalPixelsRasterized = 0;
   stats->totalDeferredImageDecodeCount = 0;
   stats->totalDeferredImageDecodeTime = base::TimeDelta();
   for (ThreadVector::iterator it = raster_threads_.begin();
        it != raster_threads_.end(); ++it) {
     Thread* thread = *it;
     stats->totalRasterizeTime +=
         thread->rendering_stats().totalRasterizeTime;
     stats->totalPixelsRasterized +=
@@ skipping 35 matching lines @@
 void RasterWorkerPool::SortRasterThreadsIfNeeded() {
   if (!raster_threads_need_sorting_)
     return;
 
   std::sort(raster_threads_.begin(), raster_threads_.end(),
             PendingTaskComparator());
   raster_threads_need_sorting_ = false;
 }
 
 }  // namespace cc