cc: Add more info to the BeginMainFrame dump.

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 1346 matching lines @@
 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())));
 }
 
 std::unique_ptr<base::trace_event::ConvertableToTraceFormat>
 TileManager::ActivationStateAsValue() {
   auto state = base::MakeUnique<base::trace_event::TracedValue>();
+  ActivationStateAsValueInto(state.get());
+  return std::move(state);
+}
+
+void TileManager::ActivationStateAsValueInto(
+    base::trace_event::TracedValue* state) {
   state->SetString("tree_priority",
                    TreePriorityToString(global_state_.tree_priority));
   state->SetInteger("soft_memory_limit",
                     global_state_.soft_memory_limit_in_bytes);
   state->SetInteger("hard_memory_limit",
                     global_state_.soft_memory_limit_in_bytes);
   state->SetInteger("pending_required_for_activation_callback_id",
                     pending_required_for_activation_callback_id_);
   state->SetInteger("current_memory_usage",
                     resource_pool_->memory_usage_bytes());
@@ skipping 18 matching lines @@
                       tile->required_for_activation());
     value->SetBoolean("required_for_draw", tile->required_for_draw());
   };
 
   std::unique_ptr<RasterTilePriorityQueue> raster_priority_queue(
       client_->BuildRasterQueue(global_state_.tree_priority,
                                 RasterTilePriorityQueue::Type::ALL));
   state->BeginArray("raster_tiles");
   for (; !raster_priority_queue->IsEmpty(); raster_priority_queue->Pop()) {
     state->BeginDictionary();
-    tile_as_value(raster_priority_queue->Top(), state.get());
+    tile_as_value(raster_priority_queue->Top(), state);
     state->EndDictionary();
   }
   state->EndArray();
 
   std::unique_ptr<RasterTilePriorityQueue> required_priority_queue(
       client_->BuildRasterQueue(
           global_state_.tree_priority,
           RasterTilePriorityQueue::Type::REQUIRED_FOR_ACTIVATION));
   state->BeginArray("activation_tiles");
   for (; !required_priority_queue->IsEmpty(); required_priority_queue->Pop()) {
     state->BeginDictionary();
-    tile_as_value(required_priority_queue->Top(), state.get());
+    tile_as_value(required_priority_queue->Top(), state);
     state->EndDictionary();
   }
   state->EndArray();
-
-  return std::move(state);
 }
 
 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
@@ skipping 65 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