Add builders for tracing event's structural arguments

cc/resources/image_copy_raster_worker_pool.cc

 // Copyright 2014 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/resources/image_copy_raster_worker_pool.h"
 
 #include <algorithm>
 
 #include "base/debug/trace_event.h"
+#include "base/debug/trace_event_argument.h"
 #include "cc/debug/traced_value.h"
 #include "cc/resources/resource_pool.h"
 #include "cc/resources/scoped_resource.h"
 #include "gpu/command_buffer/client/gles2_interface.h"
 
 namespace cc {
 
 // static
 scoped_ptr<RasterWorkerPool> ImageCopyRasterWorkerPool::Create(
     base::SequencedTaskRunner* task_runner,
@@ skipping 114 matching lines @@
   ScheduleTasksOnOriginThread(this, &graph_);
   task_graph_runner_->ScheduleTasks(namespace_token_, &graph_);
 
   raster_finished_task_ = new_raster_finished_task;
   raster_required_for_activation_finished_task_ =
       new_raster_required_for_activation_finished_task;
 
   resource_pool_->ReduceResourceUsage();
 
   TRACE_EVENT_ASYNC_STEP_INTO1(
-      "cc",
-      "ScheduledTasks",
-      this,
-      "rasterizing",
-      "state",
-      TracedValue::FromValue(StateAsValue().release()));
+      "cc", "ScheduledTasks", this, "rasterizing", "state", StateAsValue());
 }
 
 void ImageCopyRasterWorkerPool::CheckForCompletedTasks() {
   TRACE_EVENT0("cc", "ImageCopyRasterWorkerPool::CheckForCompletedTasks");
 
   task_graph_runner_->CollectCompletedTasks(namespace_token_,
                                             &completed_tasks_);
   for (Task::Vector::const_iterator it = completed_tasks_.begin();
        it != completed_tasks_.end();
        ++it) {
@@ skipping 56 matching lines @@
   client_->DidFinishRunningTasks();
 }
 
 void ImageCopyRasterWorkerPool::OnRasterRequiredForActivationFinished() {
   TRACE_EVENT0(
       "cc", "ImageCopyRasterWorkerPool::OnRasterRequiredForActivationFinished");
 
   DCHECK(raster_tasks_required_for_activation_pending_);
   raster_tasks_required_for_activation_pending_ = false;
   TRACE_EVENT_ASYNC_STEP_INTO1(
-      "cc",
-      "ScheduledTasks",
-      this,
-      "rasterizing",
-      "state",
-      TracedValue::FromValue(StateAsValue().release()));
+      "cc", "ScheduledTasks", this, "rasterizing", "state", StateAsValue());
   client_->DidFinishRunningTasksRequiredForActivation();
 }
 
 void ImageCopyRasterWorkerPool::FlushCopies() {
   if (!has_performed_copy_since_last_flush_)
     return;
 
   context_provider_->ContextGL()->ShallowFlushCHROMIUM();
   has_performed_copy_since_last_flush_ = false;
 }
 
-scoped_ptr<base::Value> ImageCopyRasterWorkerPool::StateAsValue() const {
-  scoped_ptr<base::DictionaryValue> state(new base::DictionaryValue);
+scoped_refptr<base::debug::ConvertableToTraceFormat>
+ImageCopyRasterWorkerPool::StateAsValue() const {
+  scoped_refptr<base::debug::TracedValue> state =
+      new base::debug::TracedValue();
 
   state->SetInteger("pending_count", raster_task_states_.size());
   state->SetBoolean("tasks_required_for_activation_pending",
                     raster_tasks_required_for_activation_pending_);
-  state->Set("staging_state", StagingStateAsValue().release());
+  state->BeginDictionary("staging_state");
+  StagingStateAsValueInto(state.get());
+  state->EndDictionary();
 
-  return state.PassAs<base::Value>();
+  return state;
 }
-scoped_ptr<base::Value> ImageCopyRasterWorkerPool::StagingStateAsValue() const {
-  scoped_ptr<base::DictionaryValue> staging_state(new base::DictionaryValue);
-
+void ImageCopyRasterWorkerPool::StagingStateAsValueInto(
+    base::debug::TracedValue* staging_state) const {
   staging_state->SetInteger("staging_resource_count",
                             resource_pool_->total_resource_count());
   staging_state->SetInteger("bytes_used_for_staging_resources",
                             resource_pool_->total_memory_usage_bytes());
   staging_state->SetInteger("pending_copy_count",
                             resource_pool_->total_resource_count() -
                                 resource_pool_->acquired_resource_count());
   staging_state->SetInteger("bytes_pending_copy",
                             resource_pool_->total_memory_usage_bytes() -
                                 resource_pool_->acquired_memory_usage_bytes());
-
-  return staging_state.PassAs<base::Value>();
 }
 
 }  // namespace cc