[cc] Track the rendering & painting cost of impl-side painting.

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"
 #include "base/logging.h"
 #include "base/threading/sequenced_worker_pool.h"
 #include "cc/platform_color.h"
+#include "cc/rendering_stats.h"
 #include "cc/resource_pool.h"
 #include "cc/tile.h"
 #include "third_party/skia/include/core/SkDevice.h"
 
 namespace {
 
 void RasterizeTile(cc::PicturePileImpl* picture_pile,
                    uint8_t* mapped_buffer,
-                   const gfx::Rect& rect) {
+                   const gfx::Rect& rect,
+                   cc::RenderingStats* stats) {
   TRACE_EVENT0("cc", "RasterizeTile");
   DCHECK(mapped_buffer);
   DCHECK(picture_pile);
   SkBitmap bitmap;
   bitmap.setConfig(SkBitmap::kARGB_8888_Config, rect.width(), rect.height());
   bitmap.setPixels(mapped_buffer);
   SkDevice device(bitmap);
   SkCanvas canvas(&device);
-  picture_pile->Raster(&canvas, rect);
+  picture_pile->Raster(&canvas, rect, stats);
 }
 
 const int kMaxRasterThreads = 1;
 
 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;
 
@@ skipping 168 matching lines @@
   // Sort by bin.
   std::sort(tiles_.begin(), tiles_.end(), BinComparator());
 
   // Assign gpu memory and determine what tiles need to be rasterized.
   AssignGpuMemoryToTiles();
 
   // Finally, kick the rasterizer.
   DispatchMoreRasterTasks();
 }
 
+void TileManager::renderingStats(RenderingStats* stats) {
+  stats->totalRasterizeTimeInSeconds =
+    rendering_stats_.totalRasterizeTimeInSeconds;
+  stats->totalPixelsRasterized = rendering_stats_.totalPixelsRasterized;
+}
+
 void TileManager::AssignGpuMemoryToTiles() {
   TRACE_EVENT0("cc", "TileManager::AssignGpuMemoryToTiles");
   // Some memory cannot be released. Figure out which.
   size_t unreleasable_bytes = 0;
   for (TileVector::iterator it = tiles_.begin(); it != tiles_.end(); ++it) {
     Tile* tile = *it;
     if (!tile->managed_state().can_be_freed)
       unreleasable_bytes += tile->bytes_consumed_if_allocated();
   }
 
@@ skipping 64 matching lines @@
 
   ManagedTileState& managed_tile_state = tile->managed_state();
   DCHECK(managed_tile_state.can_use_gpu_memory);
   ResourceProvider::ResourceId resource_id =
       resource_pool_->AcquireResource(tile->tile_size_.size(), tile->format_);
   resource_pool_->resource_provider()->acquirePixelBuffer(resource_id);
 
   managed_tile_state.resource_id_is_being_initialized = true;
   managed_tile_state.can_be_freed = false;
 
+  RenderingStats* stats = new RenderingStats();
+
   ++pending_raster_tasks_;
   worker_pool_->GetTaskRunnerWithShutdownBehavior(
       base::SequencedWorkerPool::SKIP_ON_SHUTDOWN)->PostTaskAndReply(
           FROM_HERE,
           base::Bind(&RasterizeTile,
                      base::Unretained(cloned_picture_pile.get()),
                      resource_pool_->resource_provider()->mapPixelBuffer(
                          resource_id),
-                     tile->rect_inside_picture_),
+                     tile->rect_inside_picture_,
+                     stats),
           base::Bind(&TileManager::OnRasterTaskCompleted,
                      base::Unretained(this),
                      tile,
                      resource_id,
-                     cloned_picture_pile));
+                     cloned_picture_pile,
+                     stats));
 }
 
 void TileManager::OnRasterTaskCompleted(
     scoped_refptr<Tile> tile,
     ResourceProvider::ResourceId resource_id,
-    scoped_refptr<PicturePileImpl> cloned_picture_pile) {
+    scoped_refptr<PicturePileImpl> cloned_picture_pile,
+    RenderingStats* stats) {
   TRACE_EVENT0("cc", "TileManager::OnRasterTaskCompleted");
   --pending_raster_tasks_;
 
+  rendering_stats_.totalRasterizeTimeInSeconds +=
+    stats->totalRasterizeTimeInSeconds;
+  rendering_stats_.totalPixelsRasterized += stats->totalPixelsRasterized;
+  delete stats;
+
   // Release raster resources.
   resource_pool_->resource_provider()->unmapPixelBuffer(resource_id);
 
   ManagedTileState& managed_tile_state = tile->managed_state();
   managed_tile_state.can_be_freed = true;
 
   // Tile can be freed after the completion of the raster task. Call
   // AssignGpuMemoryToTiles() to re-assign gpu memory to highest priority
   // tiles. The result of this could be that this tile is no longer
   // allowed to use gpu memory and in that case we need to abort
@@ skipping 26 matching lines @@
     Tile* tile, ResourceProvider::ResourceId resource_id) {
   ManagedTileState& managed_tile_state = tile->managed_state();
   DCHECK(!managed_tile_state.resource_id);
   managed_tile_state.resource_id = resource_id;
   managed_tile_state.resource_id_is_being_initialized = false;
   // TODO(qinmin): Make this conditional on managed_tile_state.bin == NOW_BIN.
   client_->ScheduleRedraw();
 }
 
 }