cc:: Add RenderingStatsInstrumentation to manage collection of RenderingStats

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 174 matching lines @@
   state->SetBoolean("is_cheap_to_raster", picture_pile_analysis.is_cheap_to_raster);
   state->SetBoolean("is_transparent", picture_pile_analysis.is_transparent);
   state->SetBoolean("is_solid_color", picture_pile_analysis.is_solid_color);
   return state.PassAs<base::Value>();
 }
 
 TileManager::TileManager(
     TileManagerClient* client,
     ResourceProvider* resource_provider,
     size_t num_raster_threads,
+    RenderingStatsRecorder* rendering_stats_recorder,
     bool use_cheapness_estimator,
     bool use_color_estimator,
     bool prediction_benchmarking)
     : client_(client),
       resource_pool_(ResourcePool::Create(resource_provider)),
       raster_worker_pool_(RasterWorkerPool::Create(this, num_raster_threads)),
       manage_tiles_pending_(false),
       manage_tiles_call_count_(0),
       bytes_pending_upload_(0),
       has_performed_uploads_since_last_flush_(false),
       ever_exceeded_memory_budget_(false),
-      record_rendering_stats_(false),
+      rendering_stats_recorder_(rendering_stats_recorder),
       use_cheapness_estimator_(use_cheapness_estimator),
       use_color_estimator_(use_color_estimator),
       allow_cheap_tasks_(true),
       did_schedule_cheap_tasks_(false),
       prediction_benchmarking_(prediction_benchmarking),
       pending_tasks_(0),
       max_pending_tasks_(kMaxNumPendingTasksPerThread * num_raster_threads) {
   for (int i = 0; i < NUM_STATES; ++i) {
     for (int j = 0; j < NUM_TREES; ++j) {
       for (int k = 0; k < NUM_BINS; ++k)
@@ skipping 304 matching lines @@
   size_t memoryUsedBytes;
   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::SetRecordRenderingStats(bool record_rendering_stats) {
-  if (record_rendering_stats_ == record_rendering_stats)
-    return;
-
-  record_rendering_stats_ = record_rendering_stats;
-  raster_worker_pool_->SetRecordRenderingStats(record_rendering_stats);
-}
-
-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.
   if (manage_tiles_pending_)
     return true;
 
   for (int i = 0; i < NUM_STATES; ++i) {
     switch (i) {
       case WAITING_FOR_RASTER_STATE:
       case RASTER_STATE:
       case UPLOAD_STATE:
@@ skipping 192 matching lines @@
     managed_tile_state.picture_pile_analysis.is_transparent &=
         use_color_estimator_;
     managed_tile_state.picture_pile_analyzed = true;
   }
 }
 
 void TileManager::GatherPixelRefsForTile(Tile* tile) {
   TRACE_EVENT0("cc", "TileManager::GatherPixelRefsForTile");
   ManagedTileState& managed_tile_state = tile->managed_state();
   if (managed_tile_state.need_to_gather_pixel_refs) {
-    base::TimeTicks gather_begin_time;
-    if (record_rendering_stats_)
-      gather_begin_time = base::TimeTicks::HighResNow();
+    base::TimeTicks start_time = rendering_stats_recorder_->StartRecording();
     tile->picture_pile()->GatherPixelRefs(
         tile->content_rect_,
         tile->contents_scale_,
         managed_tile_state.pending_pixel_refs);
     managed_tile_state.need_to_gather_pixel_refs = false;
-    if (record_rendering_stats_) {
-      rendering_stats_.totalImageGatheringCount++;
-      rendering_stats_.totalImageGatheringTime +=
-          base::TimeTicks::HighResNow() - gather_begin_time;
-    }
+    base::TimeDelta duration =
+        rendering_stats_recorder_->EndRecording(start_time);
+    rendering_stats_recorder_->AddImageGathering(duration);
   }
 }
 
 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(
         (*it)->getGenerationID())) {
       ++it;
       continue;
     }
     // TODO(qinmin): passing correct image size to PrepareToDecode().
     if ((*it)->PrepareToDecode(skia::LazyPixelRef::PrepareParams())) {
-      rendering_stats_.totalDeferredImageCacheHitCount++;
+      rendering_stats_recorder_->IncrementDeferredImageCacheHitCount();
       pending_pixel_refs.erase(it++);
     } else {
       if (pending_tasks_ >= max_pending_tasks_)
         return;
       DispatchOneImageDecodeTask(tile, *it);
       ++it;
     }
   }
 }
 
 void TileManager::DispatchOneImageDecodeTask(
     scoped_refptr<Tile> tile, skia::LazyPixelRef* pixel_ref) {
   TRACE_EVENT0("cc", "TileManager::DispatchOneImageDecodeTask");
   uint32_t pixel_ref_id = pixel_ref->getGenerationID();
   DCHECK(pending_decode_tasks_.end() ==
       pending_decode_tasks_.find(pixel_ref_id));
   pending_decode_tasks_[pixel_ref_id] = pixel_ref;
 
   raster_worker_pool_->PostTaskAndReply(
-      base::Bind(&TileManager::RunImageDecodeTask, pixel_ref),
+      base::Bind(&TileManager::RunImageDecodeTask,
+                 pixel_ref,
+                 rendering_stats_recorder_),
       base::Bind(&TileManager::OnImageDecodeTaskCompleted,
                  base::Unretained(this),
                  tile,
                  pixel_ref_id));
   pending_tasks_++;
 }
 
 void TileManager::OnImageDecodeTaskCompleted(
     scoped_refptr<Tile> tile, uint32_t pixel_ref_id) {
   TRACE_EVENT0("cc", "TileManager::OnImageDecodeTaskCompleted");
@@ skipping 43 matching lines @@
       allow_cheap_tasks_ &&
       global_state_.tree_priority != SMOOTHNESS_TAKES_PRIORITY &&
       managed_tile_state.picture_pile_analysis.is_cheap_to_raster;
   raster_worker_pool_->PostRasterTaskAndReply(
       tile->picture_pile(),
       is_cheap_task,
       base::Bind(&TileManager::RunRasterTask,
                  buffer,
                  tile->content_rect(),
                  tile->contents_scale(),
-                 GetRasterTaskMetadata(*tile)),
+                 GetRasterTaskMetadata(*tile),
+                 rendering_stats_recorder_),
       base::Bind(&TileManager::OnRasterTaskCompleted,
                  base::Unretained(this),
                  tile,
                  base::Passed(&resource),
                  manage_tiles_call_count_));
   if (is_cheap_task && !did_schedule_cheap_tasks_) {
     raster_worker_pool_->SetRunCheapTasksTimeLimit(
         base::TimeTicks::Now() +
         base::TimeDelta::FromMilliseconds(kRunCheapTasksTimeMs));
     did_schedule_cheap_tasks_ = true;
@@ skipping 95 matching lines @@
   --raster_state_count_[mts.raster_state][tree][mts.tree_bin[tree]];
   DCHECK_GE(raster_state_count_[mts.raster_state][tree][mts.tree_bin[tree]], 0);
 
   // Increment count for new bin.
   ++raster_state_count_[mts.raster_state][tree][new_tree_bin];
 
   mts.tree_bin[tree] = new_tree_bin;
 }
 
 // static
-void TileManager::RunRasterTask(uint8* buffer,
-                                const gfx::Rect& rect,
-                                float contents_scale,
-                                const RasterTaskMetadata& metadata,
-                                PicturePileImpl* picture_pile,
-                                RenderingStats* stats) {
+void TileManager::RunRasterTask(
+    uint8* buffer,
+    const gfx::Rect& rect,
+    float contents_scale,
+    const RasterTaskMetadata& metadata,
+    RenderingStatsRecorder* stats_recorder,
+    PicturePileImpl* picture_pile) {
   TRACE_EVENT2(
       "cc", "TileManager::RunRasterTask",
       "is_on_pending_tree",
       metadata.is_tile_in_pending_tree_now_bin,
       "is_low_res",
       metadata.tile_resolution == LOW_RESOLUTION);
   devtools_instrumentation::ScopedRasterTask raster_task(metadata.layer_id);
 
   DCHECK(picture_pile);
   DCHECK(buffer);
 
   SkBitmap bitmap;
   bitmap.setConfig(SkBitmap::kARGB_8888_Config, rect.width(), rect.height());
   bitmap.setPixels(buffer);
   SkDevice device(bitmap);
   SkCanvas canvas(&device);
 
-  base::TimeTicks begin_time;
-  if (stats)
-    begin_time = base::TimeTicks::HighResNow();
+  base::TimeTicks start_time = stats_recorder->StartRecording();
 
   int64 total_pixels_rasterized = 0;
   picture_pile->Raster(&canvas, rect, contents_scale,
                        &total_pixels_rasterized);
 
-  if (stats) {
-    stats->totalPixelsRasterized += total_pixels_rasterized;
+  base::TimeDelta duration = stats_recorder->EndRecording(start_time);
 
-    base::TimeTicks end_time = base::TimeTicks::HighResNow();
-    base::TimeDelta duration = end_time - begin_time;
-    stats->totalRasterizeTime += duration;
-    if (metadata.is_tile_in_pending_tree_now_bin)
-      stats->totalRasterizeTimeForNowBinsOnPendingTree += duration;
+  if (stats_recorder->record_rendering_stats()) {
+    stats_recorder->AddRaster(duration, total_pixels_rasterized, metadata.is_tile_in_pending_tree_now_bin);
 
     UMA_HISTOGRAM_CUSTOM_COUNTS("Renderer4.PictureRasterTimeMS",
                                 duration.InMilliseconds(),
                                 0,
                                 10,
                                 10);
 
     if (metadata.prediction_benchmarking) {
       PicturePileImpl::Analysis analysis;
       picture_pile->AnalyzeInRect(rect, contents_scale, &analysis);
@@ skipping 72 matching lines @@
 
   if (is_predicted_transparent)
     UMA_HISTOGRAM_BOOLEAN(
         "Renderer4.ColorPredictor.PredictedTransparentIsActually",
         is_transparent);
   UMA_HISTOGRAM_BOOLEAN("Renderer4.ColorPredictor.IsActuallyTransparent",
                         is_transparent);
 }
 
 // static
-void TileManager::RunImageDecodeTask(skia::LazyPixelRef* pixel_ref,
-                                     RenderingStats* stats) {
+void TileManager::RunImageDecodeTask(
+    skia::LazyPixelRef* pixel_ref,
+    RenderingStatsRecorder* stats_recorder) {
   TRACE_EVENT0("cc", "TileManager::RunImageDecodeTask");
-  base::TimeTicks decode_begin_time;
-  if (stats)
-    decode_begin_time = base::TimeTicks::HighResNow();
+  base::TimeTicks start_time = stats_recorder->StartRecording();
   pixel_ref->Decode();
-  if (stats) {
-    stats->totalDeferredImageDecodeCount++;
-    stats->totalDeferredImageDecodeTime +=
-        base::TimeTicks::HighResNow() - decode_begin_time;
-  }
+  base::TimeDelta duration = stats_recorder->EndRecording(start_time);
+  stats_recorder->AddDeferredImageDecode(duration);
 }
 
 }  // namespace cc