Track the 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/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) {
   TRACE_EVENT0("cc", "RasterizeTile");
@@ skipping 32 matching lines @@
 }
 
 TileManager::TileManager(
     TileManagerClient* client, ResourceProvider* resource_provider)
     : client_(client),
       resource_pool_(ResourcePool::Create(resource_provider,
                                           Renderer::ImplPool)),
       manage_tiles_pending_(false),
       pending_raster_tasks_(0),
       worker_pool_(new base::SequencedWorkerPool(kMaxRasterThreads,
-                                                 kRasterThreadNamePrefix)) {
+                                                 kRasterThreadNamePrefix)),
+      rasterize_time_in_seconds_(0) {
 }
 
 TileManager::~TileManager() {
   // Reset global state and manage. This should cause
   // our memory usage to drop to zero.
   global_state_ = GlobalStateThatImpactsTilePriority();
   ManageTiles();
   DCHECK(tiles_.size() == 0);
   // This should finish all pending raster tasks and release any
   // uninitialized resources.
@@ skipping 132 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 += rasterize_time_in_seconds_;
+    rasterize_time_in_seconds_ = 0;

[nduca, 2012/11/29 18:16:30]

we also need number of pixels rasterized

[Tom Hudson, 2012/11/29 20:30:31]

Done.

+}
+
+
 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 87 matching lines @@
                      cloned_picture_pile));
 }
 
 void TileManager::OnRasterTaskCompleted(
     scoped_refptr<Tile> tile,
     ResourceProvider::ResourceId resource_id,
     scoped_refptr<PicturePileImpl> cloned_picture_pile) {
   TRACE_EVENT0("cc", "TileManager::OnRasterTaskCompleted");
   --pending_raster_tasks_;
 
+  rasterize_time_in_seconds_ += cloned_picture_pile->rasterizeTime();
+
   // 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 20 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();
 }
 
 }