[cc] Trace detailed tile info when --trace-all-rendered-frames

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 76 matching lines @@
   case NEVER_BIN:
       return scoped_ptr<base::Value>(base::Value::CreateStringValue(
           "NEVER_BIN"));
   default:
       DCHECK(false) << "Unrecognized TileManagerBin value";
       return scoped_ptr<base::Value>(base::Value::CreateStringValue(
           "<unknown TileManagerBin value>"));
   }
 }
 
+scoped_ptr<base::Value> TileManagerBinPriorityAsValue(
+    TileManagerBinPriority bin_priority) {
+  switch (bin_priority) {
+  case HIGH_PRIORITY_BIN:
+      return scoped_ptr<base::Value>(base::Value::CreateStringValue(
+          "HIGH_PRIORITY_BIN"));
+  case LOW_PRIORITY_BIN:
+      return scoped_ptr<base::Value>(base::Value::CreateStringValue(
+          "LOW_PRIORITY_BIN"));
+  default:
+      DCHECK(false) << "Unrecognized TileManagerBinPriority value";
+      return scoped_ptr<base::Value>(base::Value::CreateStringValue(
+          "<unknown TileManagerBinPriority value>"));
+  }
+}
+
+scoped_ptr<base::Value> TileRasterStateAsValue(
+    TileRasterState raster_state) {
+  switch (raster_state) {
+  case IDLE_STATE:
+      return scoped_ptr<base::Value>(base::Value::CreateStringValue(
+          "IDLE_STATE"));
+  case WAITING_FOR_RASTER_STATE:
+      return scoped_ptr<base::Value>(base::Value::CreateStringValue(
+          "WAITING_FOR_RASTER_STATE"));
+  case RASTER_STATE:
+      return scoped_ptr<base::Value>(base::Value::CreateStringValue(
+          "RASTER_STATE"));
+  case SET_PIXELS_STATE:
+      return scoped_ptr<base::Value>(base::Value::CreateStringValue(
+          "SET_PIXELS_STATE"));
+  default:
+      DCHECK(false) << "Unrecognized TileRasterState value";
+      return scoped_ptr<base::Value>(base::Value::CreateStringValue(
+          "<unknown TileRasterState value>"));
+  }
+}
+
 ManagedTileState::ManagedTileState()
     : can_use_gpu_memory(false),
       can_be_freed(true),
       resource_is_being_initialized(false),
       contents_swizzled(false),
       need_to_gather_pixel_refs(true),
       gpu_memmgr_stats_bin(NEVER_BIN),
       raster_state(IDLE_STATE) {
   for (int i = 0; i < NUM_TREES; ++i)
     tree_bin[i] = NEVER_BIN;
 }
 
 ManagedTileState::~ManagedTileState() {
   DCHECK(!resource);
   DCHECK(!resource_is_being_initialized);
 }
 
+scoped_ptr<base::Value> ManagedTileState::AsValue() const {
+  scoped_ptr<base::DictionaryValue> state(new base::DictionaryValue());
+  state->SetBoolean("can_use_gpu_memory", can_use_gpu_memory);
+  state->SetBoolean("can_be_freed", can_be_freed);
+  state->SetBoolean("has_resource", resource.get() != 0);
+  state->SetBoolean("resource_is_being_initialized", resource_is_being_initialized);
+  state->Set("raster_state", TileRasterStateAsValue(raster_state).release());
+  state->Set("bin.0", TileManagerBinAsValue(bin[0]).release());
+  state->Set("bin.1", TileManagerBinAsValue(bin[0]).release());
+  state->Set("gpu_memmgr_stats_bin", TileManagerBinAsValue(bin[0]).release());
+  state->Set("resolution", TileResolutionAsValue(resolution).release());
+  state->SetDouble("time_to_needed_in_seconds", time_to_needed_in_seconds);
+  return state.PassAs<base::Value>();
+}
+
 TileManager::TileManager(
     TileManagerClient* client,
     ResourceProvider* resource_provider,
     size_t num_raster_threads)
     : client_(client),
       resource_pool_(ResourcePool::Create(resource_provider)),
       raster_worker_pool_(RasterWorkerPool::Create(num_raster_threads)),
       manage_tiles_pending_(false),
       manage_tiles_call_count_(0),
       bytes_pending_set_pixels_(0),
@@ skipping 185 matching lines @@
 
     DidTileBinChange(tile, bin_map[mts.tree_bin[ACTIVE_TREE]], ACTIVE_TREE);
     DidTileBinChange(tile, bin_map[mts.tree_bin[PENDING_TREE]], PENDING_TREE);
   }
 
   SortTiles();
 
   // Assign gpu memory and determine what tiles need to be rasterized.
   AssignGpuMemoryToTiles();
 
-  TRACE_EVENT_INSTANT1("cc", "DidManage", "state", ValueToString(AsValue()));
+  TRACE_EVENT_INSTANT1("cc", "DidManage", "state",
+                       ValueToString(AsValue()));
 
   // Finally, kick the rasterizer.
   DispatchMoreTasks();
 }
 
 void TileManager::CheckForCompletedTileUploads() {
   while (!tiles_with_pending_set_pixels_.empty()) {
     Tile* tile = tiles_with_pending_set_pixels_.front();
     DCHECK(tile->managed_state().resource);
 
@@ skipping 43 matching lines @@
 
 scoped_ptr<base::Value> TileManager::AsValue() const {
     scoped_ptr<base::DictionaryValue> state(new base::DictionaryValue());
     state->SetInteger("tile_count", tiles_.size());
 
     state->Set("global_state", global_state_.AsValue().release());
 
     state->Set("memory_requirements", GetMemoryRequirementsAsValue().release());
     return state.PassAs<base::Value>();
 }
+scoped_ptr<base::Value> TileManager::AllTilesAsValue() const {
+    scoped_ptr<base::ListValue> state(new base::ListValue());
+    for (size_t i = 0; i < tiles_.size(); i++)
+        state->Append(tiles_[i]->AsValue().release());
+    return state.PassAs<base::Value>();
+}
 
 scoped_ptr<base::Value> TileManager::GetMemoryRequirementsAsValue() const {
   scoped_ptr<base::DictionaryValue> requirements(
       new base::DictionaryValue());
 
   size_t memoryRequiredBytes;
   size_t memoryNiceToHaveBytes;
   size_t memoryUsedBytes;
   GetMemoryStats(&memoryRequiredBytes,
                  &memoryNiceToHaveBytes,
@@ skipping 380 matching lines @@
                                      RenderingStats* stats) {
   TRACE_EVENT0("cc", "TileManager::RunImageDecodeTask");
   base::TimeTicks decode_begin_time = base::TimeTicks::Now();
   pixel_ref->Decode();
   stats->totalDeferredImageDecodeCount++;
   stats->totalDeferredImageDecodeTime +=
       base::TimeTicks::Now() - decode_begin_time;
 }
 
 }  // namespace cc