cc: Add TileManager::GetActivationStateAsValue for debugging state.

cc/tiles/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/tiles/tile_manager.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <algorithm>
@@ skipping 1340 matching lines @@
 
 // Utility function that can be used to create a "Task set finished" task that
 // posts |callback| to |task_runner| when run.
 scoped_refptr<TileTask> TileManager::CreateTaskSetFinishedTask(
     void (TileManager::*callback)()) {
   return make_scoped_refptr(new TaskSetFinishedTaskImpl(
       task_runner_,
       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) {}
 
 TileManager::MemoryUsage::MemoryUsage(size_t memory_bytes,
                                       size_t resource_count)
     : memory_bytes_(static_cast<int64_t>(memory_bytes)),
       resource_count_(static_cast<int>(resource_count)) {
   // MemoryUsage is constructed using size_ts, since it deals with memory and
   // the inputs are typically size_t. However, during the course of usage (in
   // particular operator-=) can cause internal values to become negative.
@@ skipping 63 matching lines @@
   all_tile_tasks_completed = false;
   did_notify_all_tile_tasks_completed = false;
 }
 
 TileManager::PrioritizedWorkToSchedule::PrioritizedWorkToSchedule() = default;
 TileManager::PrioritizedWorkToSchedule::PrioritizedWorkToSchedule(
     PrioritizedWorkToSchedule&& other) = default;
 TileManager::PrioritizedWorkToSchedule::~PrioritizedWorkToSchedule() = default;
 
 }  // namespace cc