cc: Add TileManager::GetActivationStateAsValue for debugging state.

cc/tiles/tile_manager.cc

Index: cc/tiles/tile_manager.cc
diff --git a/cc/tiles/tile_manager.cc b/cc/tiles/tile_manager.cc
index bb8e450d332d13f47e38f5ba8a3164f51d23ee07..03db310b74cd5d8c51b3f81e9d84883b3e01e7b7 100644
--- a/cc/tiles/tile_manager.cc
+++ b/cc/tiles/tile_manager.cc
@@ -1358,6 +1358,58 @@ scoped_refptr<TileTask> TileManager::CreateTaskSetFinishedTask(
       base::Bind(callback, task_set_finished_weak_ptr_factory_.GetWeakPtr())));
 }
 
+void TileManager::GetActivationStateAsValue(base::DictionaryValue* value) {
+  value->SetString("tree_priority",
+                   TreePriorityToString(global_state_.tree_priority));
+  value->SetInteger("soft_memory_limit",
+                    global_state_.soft_memory_limit_in_bytes);
+  value->SetInteger("hard_memory_limit",
+                    global_state_.soft_memory_limit_in_bytes);
+  value->SetInteger("pending_required_for_activation_callback_id",
+                    pending_required_for_activation_callback_id_);
+  value->SetInteger("current_memory_usage",
+                    resource_pool_->memory_usage_bytes());
+  value->SetInteger("current_resource_usage", resource_pool_->resource_count());
+
+  auto tile_as_value = [](const PrioritizedTile& prioritized_tile) {
+    Tile* tile = prioritized_tile.tile();
+    TilePriority priority = prioritized_tile.priority();
+    auto value_tile = base::MakeUnique<base::DictionaryValue>();
+    value_tile->SetInteger("id", tile->id());
+    value_tile->SetString("content_rect",
+                          tile->content_rect().ToString().c_str());
+    value_tile->SetDouble("contents_scale", tile->contents_scale());
+    value_tile->SetBoolean("is_ready_to_draw",
+                           tile->draw_info().IsReadyToDraw());
+    value_tile->SetString("resolution",
+                          TileResolutionToString(priority.resolution));
+    value_tile->SetString("priority_bin",
+                          TilePriorityBinToString(priority.priority_bin));
+    value_tile->SetDouble("distance_to_visible", priority.distance_to_visible);
+    value_tile->SetBoolean("required_for_activation",
+                           tile->required_for_activation());
+    value_tile->SetBoolean("required_for_draw", tile->required_for_draw());
+    return value_tile;
+  };
+
+  auto raster_tiles = base::MakeUnique<base::ListValue>();
+  std::unique_ptr<RasterTilePriorityQueue> raster_priority_queue(
+      client_->BuildRasterQueue(global_state_.tree_priority,
+                                RasterTilePriorityQueue::Type::ALL));
+  for (; !raster_priority_queue->IsEmpty(); raster_priority_queue->Pop())
+    raster_tiles->Append(tile_as_value(raster_priority_queue->Top()));
+  value->Set("raster_tiles", std::move(raster_tiles));
+
+  auto activation_tiles = base::MakeUnique<base::ListValue>();
+  std::unique_ptr<RasterTilePriorityQueue> required_priority_queue(
+      client_->BuildRasterQueue(
+          global_state_.tree_priority,
+          RasterTilePriorityQueue::Type::REQUIRED_FOR_ACTIVATION));
+  for (; !required_priority_queue->IsEmpty(); required_priority_queue->Pop())
+    activation_tiles->Append(tile_as_value(required_priority_queue->Top()));
+  value->Set("activation_tiles", std::move(activation_tiles));
+}
+
 TileManager::MemoryUsage::MemoryUsage()
     : memory_bytes_(0), resource_count_(0) {}