Add builders for tracing event's structural arguments

cc/quads/render_pass.cc

 // Copyright 2011 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/quads/render_pass.h"
 
+#include "base/debug/trace_event_argument.h"
 #include "base/values.h"
 #include "cc/base/math_util.h"
 #include "cc/debug/traced_value.h"
 #include "cc/output/copy_output_request.h"
 #include "cc/quads/checkerboard_draw_quad.h"
 #include "cc/quads/debug_border_draw_quad.h"
 #include "cc/quads/draw_quad.h"
 #include "cc/quads/io_surface_draw_quad.h"
 #include "cc/quads/picture_draw_quad.h"
 #include "cc/quads/render_pass_draw_quad.h"
@@ skipping 133 matching lines @@
   this->id = id;
   this->output_rect = output_rect;
   this->damage_rect = damage_rect;
   this->transform_to_root_target = transform_to_root_target;
   this->has_transparent_background = has_transparent_background;
 
   DCHECK(quad_list.empty());
   DCHECK(shared_quad_state_list.empty());
 }
 
-scoped_ptr<base::Value> RenderPass::AsValue() const {
-  scoped_ptr<base::DictionaryValue> value(new base::DictionaryValue());
-  value->Set("output_rect", MathUtil::AsValue(output_rect).release());
-  value->Set("damage_rect", MathUtil::AsValue(damage_rect).release());
+void RenderPass::AsValueInto(base::debug::TracedValue* value) const {
+  value->BeginArray("output_rect");
+  MathUtil::AddToTracedValue(output_rect, value);
+  value->EndArray();
+
+  value->BeginArray("damage_rect");
+  MathUtil::AddToTracedValue(damage_rect, value);
+  value->EndArray();
+
   value->SetBoolean("has_transparent_background", has_transparent_background);
   value->SetInteger("copy_requests", copy_requests.size());
-  scoped_ptr<base::ListValue> shared_states_value(new base::ListValue());
+
+  value->BeginArray("shared_quad_state_list");
   for (size_t i = 0; i < shared_quad_state_list.size(); ++i) {
-    shared_states_value->Append(shared_quad_state_list[i]->AsValue().release());
+    value->BeginDictionary();
+    shared_quad_state_list[i]->AsValueInto(value);
+    value->EndDictionary();
   }
-  value->Set("shared_quad_state_list", shared_states_value.release());
-  scoped_ptr<base::ListValue> quad_list_value(new base::ListValue());
+  value->EndArray();
+
+  value->BeginArray("quad_list");
   for (size_t i = 0; i < quad_list.size(); ++i) {
-    quad_list_value->Append(quad_list[i]->AsValue().release());
+    value->BeginDictionary();
+    quad_list[i]->AsValueInto(value);
+    value->EndDictionary();
   }
-  value->Set("quad_list", quad_list_value.release());
+  value->EndArray();
 
   TracedValue::MakeDictIntoImplicitSnapshotWithCategory(
       TRACE_DISABLED_BY_DEFAULT("cc.debug.quads"),
-      value.get(), "cc::RenderPass", id.AsTracingId());
-  return value.PassAs<base::Value>();
+      value,
+      "cc::RenderPass",
+      id.AsTracingId());
 }
 
 SharedQuadState* RenderPass::CreateAndAppendSharedQuadState() {
   shared_quad_state_list.push_back(make_scoped_ptr(new SharedQuadState));
   return shared_quad_state_list.back();
 }
 
 RenderPassDrawQuad* RenderPass::CopyFromAndAppendRenderPassDrawQuad(
     const RenderPassDrawQuad* quad,
     const SharedQuadState* shared_quad_state,
@@ skipping 43 matching lines @@
     case DrawQuad::RENDER_PASS:
     case DrawQuad::INVALID:
       LOG(FATAL) << "Invalid DrawQuad material " << quad->material;
       break;
   }
   quad_list.back()->shared_quad_state = shared_quad_state;
   return quad_list.back();
 }
 
 }  // namespace cc