Add builders for tracing event's structural arguments

The new classes allow building JSON-like structural arguments. Current implementation uses base::Value as backing store but that can be replaced in the future with something more efficient without changing client code.

All clients of cc/debug/traced_value.h should eventually switch to use the new builders.

BUG=361045

Committed: https://src.chromium.org/viewvc/chrome?view=rev&revision=286849

R=alph@chromium.org, dsinclair@chromium.org, nduca@chromium.org, willchan@chromium.org

Review URL: https://codereview.chromium.org/380763002

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@286984 0039d316-1c4b-4281-b951-d872f2087c98

30 files changed, 174 insertions, 86 deletions

diff --git a/cc/quads/checkerboard_draw_quad.cc b/cc/quads/checkerboard_draw_quad.cc
index b6c5f82..1451766 100644
--- a/cc/quads/checkerboard_draw_quad.cc
+++ b/cc/quads/checkerboard_draw_quad.cc
@@ -4,6 +4,7 @@
 
 #include "cc/quads/checkerboard_draw_quad.h"
 
+#include "base/debug/trace_event_argument.h"
 #include "base/logging.h"
 #include "base/values.h"
 
@@ -42,7 +43,7 @@ const CheckerboardDrawQuad* CheckerboardDrawQuad::MaterialCast(
   return static_cast<const CheckerboardDrawQuad*>(quad);
 }
 
-void CheckerboardDrawQuad::ExtendValue(base::DictionaryValue* value) const {
+void CheckerboardDrawQuad::ExtendValue(base::debug::TracedValue* value) const {
   value->SetInteger("color", color);
 }
 
diff --git a/cc/quads/checkerboard_draw_quad.h b/cc/quads/checkerboard_draw_quad.h
index ffbf698..f99531d 100644
--- a/cc/quads/checkerboard_draw_quad.h
+++ b/cc/quads/checkerboard_draw_quad.h
@@ -36,7 +36,7 @@ class CC_EXPORT CheckerboardDrawQuad : public DrawQuad {
   static const CheckerboardDrawQuad* MaterialCast(const DrawQuad*);
 
  private:
-  virtual void ExtendValue(base::DictionaryValue* value) const OVERRIDE;
+  virtual void ExtendValue(base::debug::TracedValue* value) const OVERRIDE;
 };
 
 }  // namespace cc
diff --git a/cc/quads/content_draw_quad_base.cc b/cc/quads/content_draw_quad_base.cc
index 18d3d10..fd6e91b 100644
--- a/cc/quads/content_draw_quad_base.cc
+++ b/cc/quads/content_draw_quad_base.cc
@@ -4,6 +4,7 @@
 
 #include "cc/quads/content_draw_quad_base.h"
 
+#include "base/debug/trace_event_argument.h"
 #include "base/logging.h"
 #include "base/values.h"
 #include "cc/base/math_util.h"
@@ -49,9 +50,15 @@ void ContentDrawQuadBase::SetAll(const SharedQuadState* shared_quad_state,
   this->swizzle_contents = swizzle_contents;
 }
 
-void ContentDrawQuadBase::ExtendValue(base::DictionaryValue* value) const {
-  value->Set("tex_coord_rect", MathUtil::AsValue(tex_coord_rect).release());
-  value->Set("texture_size", MathUtil::AsValue(texture_size).release());
+void ContentDrawQuadBase::ExtendValue(base::debug::TracedValue* value) const {
+  value->BeginArray("tex_coord_rect");
+  MathUtil::AddToTracedValue(tex_coord_rect, value);
+  value->EndArray();
+
+  value->BeginDictionary("texture_size");
+  MathUtil::AddToTracedValue(texture_size, value);
+  value->EndDictionary();
+
   value->SetBoolean("swizzle_contents", swizzle_contents);
 }
 
diff --git a/cc/quads/content_draw_quad_base.h b/cc/quads/content_draw_quad_base.h
index a286e10..5173d6c 100644
--- a/cc/quads/content_draw_quad_base.h
+++ b/cc/quads/content_draw_quad_base.h
@@ -42,7 +42,7 @@ class CC_EXPORT ContentDrawQuadBase : public DrawQuad {
  protected:
   ContentDrawQuadBase();
   virtual ~ContentDrawQuadBase();
-  virtual void ExtendValue(base::DictionaryValue* value) const OVERRIDE;
+  virtual void ExtendValue(base::debug::TracedValue* value) const OVERRIDE;
 };
 
 }  // namespace cc
diff --git a/cc/quads/debug_border_draw_quad.cc b/cc/quads/debug_border_draw_quad.cc
index 4254e02..c907be7 100644
--- a/cc/quads/debug_border_draw_quad.cc
+++ b/cc/quads/debug_border_draw_quad.cc
@@ -4,6 +4,7 @@
 
 #include "cc/quads/debug_border_draw_quad.h"
 
+#include "base/debug/trace_event_argument.h"
 #include "base/logging.h"
 #include "base/values.h"
 
@@ -49,7 +50,7 @@ const DebugBorderDrawQuad* DebugBorderDrawQuad::MaterialCast(
   return static_cast<const DebugBorderDrawQuad*>(quad);
 }
 
-void DebugBorderDrawQuad::ExtendValue(base::DictionaryValue* value) const {
+void DebugBorderDrawQuad::ExtendValue(base::debug::TracedValue* value) const {
   value->SetInteger("color", color);
   value->SetInteger("width", width);
 }
diff --git a/cc/quads/debug_border_draw_quad.h b/cc/quads/debug_border_draw_quad.h
index 18dd869..828d4e0 100644
--- a/cc/quads/debug_border_draw_quad.h
+++ b/cc/quads/debug_border_draw_quad.h
@@ -39,7 +39,7 @@ class CC_EXPORT DebugBorderDrawQuad : public DrawQuad {
   static const DebugBorderDrawQuad* MaterialCast(const DrawQuad*);
 
  private:
-  virtual void ExtendValue(base::DictionaryValue* value) const OVERRIDE;
+  virtual void ExtendValue(base::debug::TracedValue* value) const OVERRIDE;
 };
 
 }  // namespace cc
diff --git a/cc/quads/draw_quad.cc b/cc/quads/draw_quad.cc
index b669ad7..38b24b0 100644
--- a/cc/quads/draw_quad.cc
+++ b/cc/quads/draw_quad.cc
@@ -4,6 +4,7 @@
 
 #include "cc/quads/draw_quad.h"
 
+#include "base/debug/trace_event_argument.h"
 #include "base/logging.h"
 #include "base/values.h"
 #include "cc/base/math_util.h"
@@ -56,48 +57,59 @@ void DrawQuad::SetAll(const SharedQuadState* shared_quad_state,
 DrawQuad::~DrawQuad() {
 }
 
-scoped_ptr<base::Value> DrawQuad::AsValue() const {
-  scoped_ptr<base::DictionaryValue> value(new base::DictionaryValue());
+void DrawQuad::AsValueInto(base::debug::TracedValue* value) const {
   value->SetInteger("material", material);
-  value->Set("shared_state",
-             TracedValue::CreateIDRef(shared_quad_state).release());
+  TracedValue::SetIDRef(shared_quad_state, value, "shared_state");
+
+  value->BeginArray("content_space_rect");
+  MathUtil::AddToTracedValue(rect, value);
+  value->EndArray();
 
-  value->Set("content_space_rect", MathUtil::AsValue(rect).release());
   bool rect_is_clipped;
   gfx::QuadF rect_as_target_space_quad = MathUtil::MapQuad(
       shared_quad_state->content_to_target_transform,
       gfx::QuadF(rect),
       &rect_is_clipped);
-  value->Set("rect_as_target_space_quad",
-             MathUtil::AsValue(rect_as_target_space_quad).release());
+  value->BeginArray("rect_as_target_space_quad");
+  MathUtil::AddToTracedValue(rect_as_target_space_quad, value);
+  value->EndArray();
+
   value->SetBoolean("rect_is_clipped", rect_is_clipped);
 
-  value->Set("content_space_opaque_rect",
-             MathUtil::AsValue(opaque_rect).release());
+  value->BeginArray("content_space_opaque_rect");
+  MathUtil::AddToTracedValue(opaque_rect, value);
+  value->EndArray();
+
   bool opaque_rect_is_clipped;
   gfx::QuadF opaque_rect_as_target_space_quad = MathUtil::MapQuad(
       shared_quad_state->content_to_target_transform,
       gfx::QuadF(opaque_rect),
       &opaque_rect_is_clipped);
-  value->Set("opaque_rect_as_target_space_quad",
-             MathUtil::AsValue(opaque_rect_as_target_space_quad).release());
+  value->BeginArray("opaque_rect_as_target_space_quad");
+  MathUtil::AddToTracedValue(opaque_rect_as_target_space_quad, value);
+  value->EndArray();
+
   value->SetBoolean("opaque_rect_is_clipped", opaque_rect_is_clipped);
 
-  value->Set("content_space_visible_rect",
-             MathUtil::AsValue(visible_rect).release());
+  value->BeginArray("content_space_visible_rect");
+  MathUtil::AddToTracedValue(visible_rect, value);
+  value->EndArray();
+
   bool visible_rect_is_clipped;
   gfx::QuadF visible_rect_as_target_space_quad = MathUtil::MapQuad(
       shared_quad_state->content_to_target_transform,
       gfx::QuadF(visible_rect),
       &visible_rect_is_clipped);
-  value->Set("visible_rect_as_target_space_quad",
-             MathUtil::AsValue(visible_rect_as_target_space_quad).release());
+
+  value->BeginArray("visible_rect_as_target_space_quad");
+  MathUtil::AddToTracedValue(visible_rect_as_target_space_quad, value);
+  value->EndArray();
+
   value->SetBoolean("visible_rect_is_clipped", visible_rect_is_clipped);
 
   value->SetBoolean("needs_blending", needs_blending);
   value->SetBoolean("should_draw_with_blending", ShouldDrawWithBlending());
-  ExtendValue(value.get());
-  return value.PassAs<base::Value>();
+  ExtendValue(value);
 }
 
 }  // namespace cc
diff --git a/cc/quads/draw_quad.h b/cc/quads/draw_quad.h
index 07193cd..61ca358 100644
--- a/cc/quads/draw_quad.h
+++ b/cc/quads/draw_quad.h
@@ -11,6 +11,9 @@
 #include "cc/resources/resource_provider.h"
 
 namespace base {
+namespace debug {
+class TracedValue;
+}
 class Value;
 class DictionaryValue;
 }
@@ -123,7 +126,7 @@ class CC_EXPORT DrawQuad {
     return IsLeftEdge() || IsTopEdge() || IsRightEdge() || IsBottomEdge();
   }
 
-  scoped_ptr<base::Value> AsValue() const;
+  void AsValueInto(base::debug::TracedValue* value) const;
 
  protected:
   DrawQuad();
@@ -134,7 +137,7 @@ class CC_EXPORT DrawQuad {
               const gfx::Rect& opaque_rect,
               const gfx::Rect& visible_rect,
               bool needs_blending);
-  virtual void ExtendValue(base::DictionaryValue* value) const = 0;
+  virtual void ExtendValue(base::debug::TracedValue* value) const = 0;
 };
 
 }  // namespace cc
diff --git a/cc/quads/io_surface_draw_quad.cc b/cc/quads/io_surface_draw_quad.cc
index cc3581b..e565a43 100644
--- a/cc/quads/io_surface_draw_quad.cc
+++ b/cc/quads/io_surface_draw_quad.cc
@@ -4,6 +4,7 @@
 
 #include "cc/quads/io_surface_draw_quad.h"
 
+#include "base/debug/trace_event_argument.h"
 #include "base/logging.h"
 #include "base/values.h"
 #include "cc/base/math_util.h"
@@ -56,8 +57,11 @@ const IOSurfaceDrawQuad* IOSurfaceDrawQuad::MaterialCast(
   return static_cast<const IOSurfaceDrawQuad*>(quad);
 }
 
-void IOSurfaceDrawQuad::ExtendValue(base::DictionaryValue* value) const {
-  value->Set("io_surface_size", MathUtil::AsValue(io_surface_size).release());
+void IOSurfaceDrawQuad::ExtendValue(base::debug::TracedValue* value) const {
+  value->BeginDictionary("io_surface_size");
+  MathUtil::AddToTracedValue(io_surface_size, value);
+  value->EndDictionary();
+
   value->SetInteger("io_surface_resource_id", io_surface_resource_id);
   const char* orientation_string = NULL;
   switch (orientation) {
diff --git a/cc/quads/io_surface_draw_quad.h b/cc/quads/io_surface_draw_quad.h
index 988afeb..86b4d52 100644
--- a/cc/quads/io_surface_draw_quad.h
+++ b/cc/quads/io_surface_draw_quad.h
@@ -49,7 +49,7 @@ class CC_EXPORT IOSurfaceDrawQuad : public DrawQuad {
   static const IOSurfaceDrawQuad* MaterialCast(const DrawQuad*);
 
  private:
-  virtual void ExtendValue(base::DictionaryValue* value) const OVERRIDE;
+  virtual void ExtendValue(base::debug::TracedValue* value) const OVERRIDE;
 };
 
 }  // namespace cc
diff --git a/cc/quads/picture_draw_quad.cc b/cc/quads/picture_draw_quad.cc
index cb1c2c1..af120a4 100644
--- a/cc/quads/picture_draw_quad.cc
+++ b/cc/quads/picture_draw_quad.cc
@@ -4,6 +4,7 @@
 
 #include "cc/quads/picture_draw_quad.h"
 
+#include "base/debug/trace_event_argument.h"
 #include "base/values.h"
 #include "cc/base/math_util.h"
 #include "cc/resources/platform_color.h"
@@ -79,9 +80,11 @@ const PictureDrawQuad* PictureDrawQuad::MaterialCast(const DrawQuad* quad) {
   return static_cast<const PictureDrawQuad*>(quad);
 }
 
-void PictureDrawQuad::ExtendValue(base::DictionaryValue* value) const {
+void PictureDrawQuad::ExtendValue(base::debug::TracedValue* value) const {
   ContentDrawQuadBase::ExtendValue(value);
-  value->Set("content_rect", MathUtil::AsValue(content_rect).release());
+  value->BeginArray("content_rect");
+  MathUtil::AddToTracedValue(content_rect, value);
+  value->EndArray();
   value->SetDouble("contents_scale", contents_scale);
   value->SetInteger("texture_format", texture_format);
   // TODO(piman): picture_pile?
diff --git a/cc/quads/picture_draw_quad.h b/cc/quads/picture_draw_quad.h
index 944a8fb..4fb6b4b 100644
--- a/cc/quads/picture_draw_quad.h
+++ b/cc/quads/picture_draw_quad.h
@@ -56,7 +56,7 @@ class CC_EXPORT PictureDrawQuad : public ContentDrawQuadBase {
   static const PictureDrawQuad* MaterialCast(const DrawQuad* quad);
 
  private:
-  virtual void ExtendValue(base::DictionaryValue* value) const OVERRIDE;
+  virtual void ExtendValue(base::debug::TracedValue* value) const OVERRIDE;
 };
 
 }  // namespace cc
diff --git a/cc/quads/render_pass.cc b/cc/quads/render_pass.cc
index c7f83a3..43bb7cd 100644
--- a/cc/quads/render_pass.cc
+++ b/cc/quads/render_pass.cc
@@ -4,6 +4,7 @@
 
 #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"
@@ -157,27 +158,39 @@ void RenderPass::SetAll(Id id,
   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() {
diff --git a/cc/quads/render_pass.h b/cc/quads/render_pass.h
index 3032f05..8d41142 100644
--- a/cc/quads/render_pass.h
+++ b/cc/quads/render_pass.h
@@ -18,6 +18,9 @@
 #include "ui/gfx/transform.h"
 
 namespace base {
+namespace debug {
+class TracedValue;
+}
 class Value;
 };
 
@@ -87,7 +90,7 @@ class CC_EXPORT RenderPass {
               const gfx::Transform& transform_to_root_target,
               bool has_transparent_background);
 
-  scoped_ptr<base::Value> AsValue() const;
+  void AsValueInto(base::debug::TracedValue* dict) const;
 
   SharedQuadState* CreateAndAppendSharedQuadState();
   template <typename DrawQuadType>
diff --git a/cc/quads/render_pass_draw_quad.cc b/cc/quads/render_pass_draw_quad.cc
index 6259fdf..380f2f6 100644
--- a/cc/quads/render_pass_draw_quad.cc
+++ b/cc/quads/render_pass_draw_quad.cc
@@ -4,6 +4,7 @@
 
 #include "cc/quads/render_pass_draw_quad.h"
 
+#include "base/debug/trace_event_argument.h"
 #include "base/values.h"
 #include "cc/base/math_util.h"
 #include "cc/debug/traced_value.h"
@@ -81,16 +82,24 @@ const RenderPassDrawQuad* RenderPassDrawQuad::MaterialCast(
   return static_cast<const RenderPassDrawQuad*>(quad);
 }
 
-void RenderPassDrawQuad::ExtendValue(base::DictionaryValue* value) const {
-  value->Set("render_pass_id",
-             TracedValue::CreateIDRef(render_pass_id.AsTracingId()).release());
+void RenderPassDrawQuad::ExtendValue(base::debug::TracedValue* value) const {
+  TracedValue::SetIDRef(render_pass_id.AsTracingId(), value, "render_pass_id");
   value->SetBoolean("is_replica", is_replica);
   value->SetInteger("mask_resource_id", mask_resource_id);
-  value->Set("contents_changed_since_last_frame",
-             MathUtil::AsValue(contents_changed_since_last_frame).release());
-  value->Set("mask_uv_rect", MathUtil::AsValue(mask_uv_rect).release());
-  value->Set("filters", filters.AsValue().release());
-  value->Set("background_filters", background_filters.AsValue().release());
+  value->BeginArray("contents_changed_since_last_frame");
+  MathUtil::AddToTracedValue(contents_changed_since_last_frame, value);
+  value->EndArray();
+
+  value->BeginArray("mask_uv_rect");
+  MathUtil::AddToTracedValue(mask_uv_rect, value);
+  value->EndArray();
+  value->BeginDictionary("filters");
+  filters.AsValueInto(value);
+  value->EndDictionary();
+
+  value->BeginDictionary("background_filters");
+  background_filters.AsValueInto(value);
+  value->EndDictionary();
 }
 
 }  // namespace cc
diff --git a/cc/quads/render_pass_draw_quad.h b/cc/quads/render_pass_draw_quad.h
index e3d6f14..7237a854 100644
--- a/cc/quads/render_pass_draw_quad.h
+++ b/cc/quads/render_pass_draw_quad.h
@@ -63,7 +63,7 @@ class CC_EXPORT RenderPassDrawQuad : public DrawQuad {
   static const RenderPassDrawQuad* MaterialCast(const DrawQuad*);
 
  private:
-  virtual void ExtendValue(base::DictionaryValue* value) const OVERRIDE;
+  virtual void ExtendValue(base::debug::TracedValue* value) const OVERRIDE;
 };
 
 }  // namespace cc
diff --git a/cc/quads/shared_quad_state.cc b/cc/quads/shared_quad_state.cc
index 57959e3..83df365 100644
--- a/cc/quads/shared_quad_state.cc
+++ b/cc/quads/shared_quad_state.cc
@@ -4,6 +4,7 @@
 
 #include "cc/quads/shared_quad_state.h"
 
+#include "base/debug/trace_event_argument.h"
 #include "base/values.h"
 #include "cc/base/math_util.h"
 #include "cc/debug/traced_value.h"
@@ -45,22 +46,32 @@ void SharedQuadState::SetAll(const gfx::Transform& content_to_target_transform,
   this->sorting_context_id = sorting_context_id;
 }
 
-scoped_ptr<base::Value> SharedQuadState::AsValue() const {
-  scoped_ptr<base::DictionaryValue> value(new base::DictionaryValue());
-  value->Set("transform",
-             MathUtil::AsValue(content_to_target_transform).release());
-  value->Set("layer_content_bounds",
-             MathUtil::AsValue(content_bounds).release());
-  value->Set("layer_visible_content_rect",
-             MathUtil::AsValue(visible_content_rect).release());
+void SharedQuadState::AsValueInto(base::debug::TracedValue* value) const {
+  value->BeginArray("transform");
+  MathUtil::AddToTracedValue(content_to_target_transform, value);
+  value->EndArray();
+
+  value->BeginDictionary("layer_content_bounds");
+  MathUtil::AddToTracedValue(content_bounds, value);
+  value->EndDictionary();
+
+  value->BeginArray("layer_visible_content_rect");
+  MathUtil::AddToTracedValue(visible_content_rect, value);
+  value->EndArray();
+
   value->SetBoolean("is_clipped", is_clipped);
-  value->Set("clip_rect", MathUtil::AsValue(clip_rect).release());
+
+  value->BeginArray("clip_rect");
+  MathUtil::AddToTracedValue(clip_rect, value);
+  value->EndArray();
+
   value->SetDouble("opacity", opacity);
   value->SetString("blend_mode", SkXfermode::ModeName(blend_mode));
   TracedValue::MakeDictIntoImplicitSnapshotWithCategory(
       TRACE_DISABLED_BY_DEFAULT("cc.debug.quads"),
-      value.get(), "cc::SharedQuadState", this);
-  return value.PassAs<base::Value>();
+      value,
+      "cc::SharedQuadState",
+      this);
 }
 
 }  // namespace cc
diff --git a/cc/quads/shared_quad_state.h b/cc/quads/shared_quad_state.h
index 30a1e25..dde87a8 100644
--- a/cc/quads/shared_quad_state.h
+++ b/cc/quads/shared_quad_state.h
@@ -12,6 +12,9 @@
 #include "ui/gfx/transform.h"
 
 namespace base {
+namespace debug {
+class TracedValue;
+}
 class Value;
 }
 
@@ -37,7 +40,7 @@ class CC_EXPORT SharedQuadState {
               float opacity,
               SkXfermode::Mode blend_mode,
               int sorting_context_id);
-  scoped_ptr<base::Value> AsValue() const;
+  void AsValueInto(base::debug::TracedValue* dict) const;
 
   // Transforms from quad's original content space to its target content space.
   gfx::Transform content_to_target_transform;
diff --git a/cc/quads/solid_color_draw_quad.cc b/cc/quads/solid_color_draw_quad.cc
index 333ee17..a11b151 100644
--- a/cc/quads/solid_color_draw_quad.cc
+++ b/cc/quads/solid_color_draw_quad.cc
@@ -4,6 +4,7 @@
 
 #include "cc/quads/solid_color_draw_quad.h"
 
+#include "base/debug/trace_event_argument.h"
 #include "base/logging.h"
 #include "base/values.h"
 
@@ -47,7 +48,7 @@ const SolidColorDrawQuad* SolidColorDrawQuad::MaterialCast(
   return static_cast<const SolidColorDrawQuad*>(quad);
 }
 
-void SolidColorDrawQuad::ExtendValue(base::DictionaryValue* value) const {
+void SolidColorDrawQuad::ExtendValue(base::debug::TracedValue* value) const {
   value->SetInteger("color", color);
   value->SetBoolean("force_anti_aliasing_off", force_anti_aliasing_off);
 }
diff --git a/cc/quads/solid_color_draw_quad.h b/cc/quads/solid_color_draw_quad.h
index 1e746e0..bfb6022 100644
--- a/cc/quads/solid_color_draw_quad.h
+++ b/cc/quads/solid_color_draw_quad.h
@@ -39,7 +39,7 @@ class CC_EXPORT SolidColorDrawQuad : public DrawQuad {
   static const SolidColorDrawQuad* MaterialCast(const DrawQuad*);
 
  private:
-  virtual void ExtendValue(base::DictionaryValue* value) const OVERRIDE;
+  virtual void ExtendValue(base::debug::TracedValue* value) const OVERRIDE;
 };
 
 }  // namespace cc
diff --git a/cc/quads/stream_video_draw_quad.cc b/cc/quads/stream_video_draw_quad.cc
index 683d4e5..6b5a509 100644
--- a/cc/quads/stream_video_draw_quad.cc
+++ b/cc/quads/stream_video_draw_quad.cc
@@ -4,6 +4,7 @@
 
 #include "cc/quads/stream_video_draw_quad.h"
 
+#include "base/debug/trace_event_argument.h"
 #include "base/logging.h"
 #include "base/values.h"
 #include "cc/base/math_util.h"
@@ -49,9 +50,11 @@ const StreamVideoDrawQuad* StreamVideoDrawQuad::MaterialCast(
   return static_cast<const StreamVideoDrawQuad*>(quad);
 }
 
-void StreamVideoDrawQuad::ExtendValue(base::DictionaryValue* value) const {
+void StreamVideoDrawQuad::ExtendValue(base::debug::TracedValue* value) const {
   value->SetInteger("resource_id", resource_id);
-  value->Set("matrix", MathUtil::AsValue(matrix).release());
+  value->BeginArray("matrix");
+  MathUtil::AddToTracedValue(matrix, value);
+  value->EndArray();
 }
 
 }  // namespace cc
diff --git a/cc/quads/stream_video_draw_quad.h b/cc/quads/stream_video_draw_quad.h
index 0570f31..5db7c3b 100644
--- a/cc/quads/stream_video_draw_quad.h
+++ b/cc/quads/stream_video_draw_quad.h
@@ -40,7 +40,7 @@ class CC_EXPORT StreamVideoDrawQuad : public DrawQuad {
   static const StreamVideoDrawQuad* MaterialCast(const DrawQuad*);
 
  private:
-  virtual void ExtendValue(base::DictionaryValue* value) const OVERRIDE;
+  virtual void ExtendValue(base::debug::TracedValue* value) const OVERRIDE;
 };
 
 }  // namespace cc
diff --git a/cc/quads/surface_draw_quad.cc b/cc/quads/surface_draw_quad.cc
index 04645da..7ed8f2e 100644
--- a/cc/quads/surface_draw_quad.cc
+++ b/cc/quads/surface_draw_quad.cc
@@ -4,6 +4,7 @@
 
 #include "cc/quads/surface_draw_quad.h"
 
+#include "base/debug/trace_event_argument.h"
 #include "base/logging.h"
 #include "base/values.h"
 
@@ -42,7 +43,7 @@ const SurfaceDrawQuad* SurfaceDrawQuad::MaterialCast(const DrawQuad* quad) {
   return static_cast<const SurfaceDrawQuad*>(quad);
 }
 
-void SurfaceDrawQuad::ExtendValue(base::DictionaryValue* value) const {
+void SurfaceDrawQuad::ExtendValue(base::debug::TracedValue* value) const {
   value->SetInteger("surface_id", surface_id.id);
 }
 
diff --git a/cc/quads/surface_draw_quad.h b/cc/quads/surface_draw_quad.h
index 7b22ed5..91e5668 100644
--- a/cc/quads/surface_draw_quad.h
+++ b/cc/quads/surface_draw_quad.h
@@ -36,7 +36,7 @@ class CC_EXPORT SurfaceDrawQuad : public DrawQuad {
   static const SurfaceDrawQuad* MaterialCast(const DrawQuad* quad);
 
  private:
-  virtual void ExtendValue(base::DictionaryValue* value) const OVERRIDE;
+  virtual void ExtendValue(base::debug::TracedValue* value) const OVERRIDE;
 };
 
 }  // namespace cc
diff --git a/cc/quads/texture_draw_quad.cc b/cc/quads/texture_draw_quad.cc
index 6637e4f..72435c2 100644
--- a/cc/quads/texture_draw_quad.cc
+++ b/cc/quads/texture_draw_quad.cc
@@ -4,6 +4,7 @@
 
 #include "cc/quads/texture_draw_quad.h"
 
+#include "base/debug/trace_event_argument.h"
 #include "base/logging.h"
 #include "base/values.h"
 #include "cc/base/math_util.h"
@@ -83,16 +84,24 @@ const TextureDrawQuad* TextureDrawQuad::MaterialCast(const DrawQuad* quad) {
   return static_cast<const TextureDrawQuad*>(quad);
 }
 
-void TextureDrawQuad::ExtendValue(base::DictionaryValue* value) const {
+void TextureDrawQuad::ExtendValue(base::debug::TracedValue* value) const {
   value->SetInteger("resource_id", resource_id);
   value->SetBoolean("premultiplied_alpha", premultiplied_alpha);
-  value->Set("uv_top_left", MathUtil::AsValue(uv_top_left).release());
-  value->Set("uv_bottom_right", MathUtil::AsValue(uv_bottom_right).release());
+  value->BeginArray("uv_top_left");
+  MathUtil::AddToTracedValue(uv_top_left, value);
+  value->EndArray();
+
+  value->BeginArray("uv_bottom_right");
+  MathUtil::AddToTracedValue(uv_bottom_right, value);
+  value->EndArray();
+
   value->SetInteger("background_color", background_color);
-  scoped_ptr<base::ListValue> vertex_opacity_value(new base::ListValue);
+
+  value->BeginArray("vertex_opacity");
   for (size_t i = 0; i < 4; ++i)
-    vertex_opacity_value->AppendDouble(vertex_opacity[i]);
-  value->Set("vertex_opacity", vertex_opacity_value.release());
+    value->AppendDouble(vertex_opacity[i]);
+  value->EndArray();
+
   value->SetBoolean("flipped", flipped);
 }
 
diff --git a/cc/quads/texture_draw_quad.h b/cc/quads/texture_draw_quad.h
index 409679b..ef8090c 100644
--- a/cc/quads/texture_draw_quad.h
+++ b/cc/quads/texture_draw_quad.h
@@ -55,7 +55,7 @@ class CC_EXPORT TextureDrawQuad : public DrawQuad {
   static const TextureDrawQuad* MaterialCast(const DrawQuad*);
 
  private:
-  virtual void ExtendValue(base::DictionaryValue* value) const OVERRIDE;
+  virtual void ExtendValue(base::debug::TracedValue* value) const OVERRIDE;
 };
 
 }  // namespace cc
diff --git a/cc/quads/tile_draw_quad.cc b/cc/quads/tile_draw_quad.cc
index 839f0de..ea3a14a 100644
--- a/cc/quads/tile_draw_quad.cc
+++ b/cc/quads/tile_draw_quad.cc
@@ -4,6 +4,7 @@
 
 #include "cc/quads/tile_draw_quad.h"
 
+#include "base/debug/trace_event_argument.h"
 #include "base/logging.h"
 #include "base/values.h"
 #include "third_party/khronos/GLES2/gl2.h"
@@ -61,7 +62,7 @@ const TileDrawQuad* TileDrawQuad::MaterialCast(const DrawQuad* quad) {
   return static_cast<const TileDrawQuad*>(quad);
 }
 
-void TileDrawQuad::ExtendValue(base::DictionaryValue* value) const {
+void TileDrawQuad::ExtendValue(base::debug::TracedValue* value) const {
   ContentDrawQuadBase::ExtendValue(value);
   value->SetInteger("resource_id", resource_id);
 }
diff --git a/cc/quads/tile_draw_quad.h b/cc/quads/tile_draw_quad.h
index 2d3c2ee..72e6bba 100644
--- a/cc/quads/tile_draw_quad.h
+++ b/cc/quads/tile_draw_quad.h
@@ -41,7 +41,7 @@ class CC_EXPORT TileDrawQuad : public ContentDrawQuadBase {
   static const TileDrawQuad* MaterialCast(const DrawQuad*);
 
  private:
-  virtual void ExtendValue(base::DictionaryValue* value) const OVERRIDE;
+  virtual void ExtendValue(base::debug::TracedValue* value) const OVERRIDE;
 };
 
 }  // namespace cc
diff --git a/cc/quads/yuv_video_draw_quad.cc b/cc/quads/yuv_video_draw_quad.cc
index d2443ba..612362e 100644
--- a/cc/quads/yuv_video_draw_quad.cc
+++ b/cc/quads/yuv_video_draw_quad.cc
@@ -4,6 +4,7 @@
 
 #include "cc/quads/yuv_video_draw_quad.h"
 
+#include "base/debug/trace_event_argument.h"
 #include "base/logging.h"
 #include "base/values.h"
 #include "cc/base/math_util.h"
@@ -74,8 +75,10 @@ const YUVVideoDrawQuad* YUVVideoDrawQuad::MaterialCast(
   return static_cast<const YUVVideoDrawQuad*>(quad);
 }
 
-void YUVVideoDrawQuad::ExtendValue(base::DictionaryValue* value) const {
-  value->Set("tex_coord_rect", MathUtil::AsValue(tex_coord_rect).release());
+void YUVVideoDrawQuad::ExtendValue(base::debug::TracedValue* value) const {
+  value->BeginArray("tex_coord_rect");
+  MathUtil::AddToTracedValue(tex_coord_rect, value);
+  value->EndArray();
   value->SetInteger("y_plane_resource_id", y_plane_resource_id);
   value->SetInteger("u_plane_resource_id", u_plane_resource_id);
   value->SetInteger("v_plane_resource_id", v_plane_resource_id);
diff --git a/cc/quads/yuv_video_draw_quad.h b/cc/quads/yuv_video_draw_quad.h
index 93975d7..930c821 100644
--- a/cc/quads/yuv_video_draw_quad.h
+++ b/cc/quads/yuv_video_draw_quad.h
@@ -61,7 +61,7 @@ class CC_EXPORT YUVVideoDrawQuad : public DrawQuad {
   static const YUVVideoDrawQuad* MaterialCast(const DrawQuad*);
 
  private:
-  virtual void ExtendValue(base::DictionaryValue* value) const OVERRIDE;
+  virtual void ExtendValue(base::debug::TracedValue* value) const OVERRIDE;
 };
 
 }  // namespace cc