adding render stats for deferred image decoding

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 <set>
 
 #include "base/bind.h"
@@ skipping 51 matching lines @@
                    base::Unretained(picture_pile),
                    mapped_buffer,
                    rect,
                    contents_scale,
                    stats),
         base::Bind(&RasterThread::RunReply, base::Unretained(this), reply));
   }
 
   void PostImageDecodingTaskAndReply(const tracked_objects::Location& from_here,
                                      skia::LazyPixelRef* pixel_ref,
+                                     RenderingStats* stats,
                                      const base::Closure& reply) {
     ++num_pending_tasks_;
     message_loop_proxy()->PostTaskAndReply(
         from_here,
-        base::Bind(&RunImageDecodeTask, base::Unretained(pixel_ref)),
+        base::Bind(&RunImageDecodeTask, pixel_ref, stats),
         base::Bind(&RasterThread::RunReply, base::Unretained(this), reply));
   }
 
  private:
   static void RunRasterTask(PicturePileImpl* picture_pile,
                             uint8_t* mapped_buffer,
                             const gfx::Rect& rect,
                             float contents_scale,
                             RenderingStats* stats) {
     TRACE_EVENT0("cc", "RasterThread::RunRasterTask");
     DCHECK(picture_pile);
     DCHECK(mapped_buffer);
     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,
         contents_scale,
         stats);
   }
 
-  static void RunImageDecodeTask(skia::LazyPixelRef* pixel_ref) {
+  static void RunImageDecodeTask(skia::LazyPixelRef* pixel_ref,
+                                 RenderingStats* stats) {
     TRACE_EVENT0("cc", "RasterThread::RunImageDecodeTask");
+    base::TimeTicks decodeBeginTime = base::TimeTicks::Now();
     pixel_ref->Decode();
+    stats->totalDeferredImageDecodeTimeInSeconds +=
+        (base::TimeTicks::Now() - decodeBeginTime).InSecondsF();
   }
 
   void RunReply(const base::Closure& reply) {
     --num_pending_tasks_;
     reply.Run();
   }
 
   int num_pending_tasks_;
 
   DISALLOW_COPY_AND_ASSIGN(RasterThread);
@@ skipping 208 matching lines @@
     resource_pool_->resource_provider()->releasePixelBuffer(
         tile->managed_state().resource->id());
 
     DidFinishTileInitialization(tile);
     tiles_with_pending_set_pixels_.pop();
   }
 }
 
 void TileManager::renderingStats(RenderingStats* stats) {
   stats->totalRasterizeTimeInSeconds =
-    rendering_stats_.totalRasterizeTimeInSeconds;
+      rendering_stats_.totalRasterizeTimeInSeconds;
   stats->totalPixelsRasterized = rendering_stats_.totalPixelsRasterized;
+  stats->totalDeferredImageDecodeCount =
+      rendering_stats_.totalDeferredImageDecodeCount;
+  stats->totalDeferredImageCacheHitCount =
+      rendering_stats_.totalDeferredImageCacheHitCount;
+  stats->totalPixelGatheringCount = rendering_stats_.totalPixelGatheringCount;
+  stats->totalDeferredImageDecodeTimeInSeconds =
+      rendering_stats_.totalDeferredImageDecodeTimeInSeconds;
+  stats->totalPixelGatheringTimeInSeconds =
+      rendering_stats_.totalPixelGatheringTimeInSeconds;
 }
 
 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 104 matching lines @@
     }
     tiles_that_need_to_be_rasterized_.pop_back();
   }
 }
 
 void TileManager::DispatchImageDecodingTasksForTile(Tile* tile) {
   ManagedTileState& managed_state = tile->managed_state();
   if (managed_state.need_to_gather_pixel_refs) {
     TRACE_EVENT0("cc",
         "TileManager::DispatchImageDecodingTaskForTile: Gather PixelRefs");
+    base::TimeTicks gatherBeginTime = base::TimeTicks::Now();
     const_cast<PicturePileImpl *>(tile->picture_pile())->GatherPixelRefs(
         tile->content_rect_, managed_state.pending_pixel_refs);
+    rendering_stats_.totalPixelGatheringCount++;
+    rendering_stats_.totalPixelGatheringTimeInSeconds +=
+        (base::TimeTicks::Now() - gatherBeginTime).InSecondsF();
     managed_state.need_to_gather_pixel_refs = false;
   }
 
   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++;
       pending_pixel_refs.erase(it++);
     } else {
       RasterThread* thread = GetFreeRasterThread();
-      if (thread)
-        DispatchOneImageDecodingTask(thread, tile, *it);
+      if (!thread)
+        return;
+      DispatchOneImageDecodingTask(thread, tile, *it);
       ++it;
     }
   }
 }
 
 void TileManager::DispatchOneImageDecodingTask(RasterThread* thread,
                                                scoped_refptr<Tile> tile,
                                                skia::LazyPixelRef* pixel_ref) {
   TRACE_EVENT0("cc", "TileManager::DispatchOneImageDecodingTask");
   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;
+  RenderingStats* stats = new RenderingStats();

[reveman, 2012/12/13 20:55:13]

you need to delete this instance in OnImageDecodingTaskCompleted.

[qinmin, 2012/12/13 21:09:25]

ah...I forgot that.. Done.

On 2012/12/13 20:55:13, David Reveman wrote:

 
   thread->PostImageDecodingTaskAndReply(
           FROM_HERE,
           pixel_ref,
+          stats,
           base::Bind(&TileManager::OnImageDecodingTaskCompleted,
                      base::Unretained(this),
                      tile,
-                     pixel_ref_id));
+                     pixel_ref_id,
+                     stats));
 }
 
 void TileManager::OnImageDecodingTaskCompleted(scoped_refptr<Tile> tile,
-                                               uint32_t pixel_ref_id) {
+                                               uint32_t pixel_ref_id,
+                                               RenderingStats* stats) {
   TRACE_EVENT0("cc", "TileManager::OnImageDecoded");
   pending_decode_tasks_.erase(pixel_ref_id);
-
+  rendering_stats_.totalDeferredImageDecodeTimeInSeconds +=
+      stats->totalDeferredImageDecodeTimeInSeconds;
+  rendering_stats_.totalDeferredImageDecodeCount++;
   for (TileList::iterator it = tiles_with_image_decoding_tasks_.begin();
       it != tiles_with_image_decoding_tasks_.end(); ++it) {
     std::list<skia::LazyPixelRef*>& pixel_refs =
         (*it)->managed_state().pending_pixel_refs;
     for (std::list<skia::LazyPixelRef*>::iterator pixel_it =
         pixel_refs.begin(); pixel_it != pixel_refs.end(); ++pixel_it) {
       if (pixel_ref_id == (*pixel_it)->getGenerationID()) {
         pixel_refs.erase(pixel_it);
         break;
       }
@@ skipping 84 matching lines @@
 }
 
 void TileManager::DidFinishTileInitialization(Tile* tile) {
   ManagedTileState& managed_tile_state = tile->managed_state();
   DCHECK(managed_tile_state.resource);
   managed_tile_state.resource_is_being_initialized = false;
   managed_tile_state.can_be_freed = true;
 }
 
 }