cc: Avoid expensive RenderingStats collection.

cc/tile_manager.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/tile_manager.h"
 
 #include <algorithm>
 
 #include "base/bind.h"
 #include "base/debug/trace_event.h"
@@ skipping 96 matching lines @@
 }
 
 ManagedTileState::~ManagedTileState() {
   DCHECK(!resource);
   DCHECK(!resource_is_being_initialized);
 }
 
 TileManager::TileManager(
     TileManagerClient* client,
     ResourceProvider* resource_provider,
-    size_t num_raster_threads)
+    size_t num_raster_threads,
+    bool record_rendering_stats)
     : client_(client),
       resource_pool_(ResourcePool::Create(resource_provider)),
-      raster_worker_pool_(RasterWorkerPool::Create(num_raster_threads)),
+      raster_worker_pool_(RasterWorkerPool::Create(num_raster_threads, record_rendering_stats)),
       manage_tiles_pending_(false),
       manage_tiles_call_count_(0),
       bytes_pending_set_pixels_(0),
-      ever_exceeded_memory_budget_(false) {
+      ever_exceeded_memory_budget_(false),
+      record_rendering_stats_(record_rendering_stats) {
   for (int i = 0; i < NUM_STATES; ++i) {
     for (int j = 0; j < NUM_TREES; ++j) {
       for (int k = 0; k < NUM_BINS; ++k)
         raster_state_count_[i][j][k] = 0;
     }
   }
 }
 
 TileManager::~TileManager() {
   // Reset global state and manage. This should cause
@@ skipping 256 matching lines @@
   GetMemoryStats(&memoryRequiredBytes,
                  &memoryNiceToHaveBytes,
                  &memoryUsedBytes);
   requirements->SetInteger("memory_required_bytes", memoryRequiredBytes);
   requirements->SetInteger("memory_nice_to_have_bytes", memoryNiceToHaveBytes);
   requirements->SetInteger("memory_used_bytes", memoryUsedBytes);
   return requirements.PassAs<base::Value>();
 }
 
 void TileManager::GetRenderingStats(RenderingStats* stats) {
+  CHECK(record_rendering_stats_);
   raster_worker_pool_->GetRenderingStats(stats);
   stats->totalDeferredImageCacheHitCount =
       rendering_stats_.totalDeferredImageCacheHitCount;
   stats->totalImageGatheringCount = rendering_stats_.totalImageGatheringCount;
   stats->totalImageGatheringTime =
       rendering_stats_.totalImageGatheringTime;
 }
 
 bool TileManager::HasPendingWorkScheduled(WhichTree tree) const {
   // Always true when ManageTiles() call is pending.
@@ skipping 144 matching lines @@
       DispatchOneRasterTask(tile);
     }
     tiles_that_need_to_be_rasterized_.pop_back();
   }
 }
 
 void TileManager::GatherPixelRefsForTile(Tile* tile) {
   TRACE_EVENT0("cc", "TileManager::GatherPixelRefsForTile");
   ManagedTileState& managed_state = tile->managed_state();
   if (managed_state.need_to_gather_pixel_refs) {
-    base::TimeTicks gather_begin_time = base::TimeTicks::Now();
+    base::TimeTicks gather_begin_time;
+    if (record_rendering_stats_)
+      gather_begin_time = base::TimeTicks::Now();
     tile->picture_pile()->GatherPixelRefs(
         tile->content_rect_,
         tile->contents_scale_,
         managed_state.pending_pixel_refs);
-    rendering_stats_.totalImageGatheringCount++;
-    rendering_stats_.totalImageGatheringTime +=
-        base::TimeTicks::Now() - gather_begin_time;
     managed_state.need_to_gather_pixel_refs = false;
+    if (record_rendering_stats_) {
+      rendering_stats_.totalImageGatheringCount++;
+      rendering_stats_.totalImageGatheringTime +=
+          base::TimeTicks::Now() - gather_begin_time;
+    }
   }
 }
 
 void TileManager::DispatchImageDecodeTasksForTile(Tile* tile) {
   GatherPixelRefsForTile(tile);
   std::list<skia::LazyPixelRef*>& pending_pixel_refs =
       tile->managed_state().pending_pixel_refs;
   std::list<skia::LazyPixelRef*>::iterator it = pending_pixel_refs.begin();
   while (it != pending_pixel_refs.end()) {
     if (pending_decode_tasks_.end() != pending_decode_tasks_.find(
@@ skipping 181 matching lines @@
   bitmap.setPixels(buffer);
   SkDevice device(bitmap);
   SkCanvas canvas(&device);
   picture_pile->Raster(&canvas, rect, contents_scale, stats);
 }
 
 // static
 void TileManager::RunImageDecodeTask(skia::LazyPixelRef* pixel_ref,
                                      RenderingStats* stats) {
   TRACE_EVENT0("cc", "TileManager::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;
+  }
 }
 
 }  // namespace cc