cc: refactor of MathUtil::AddToTracedValue

Pass the name to MathUtilAddToTracedValue
and decide the json value type internally.
so that we could add the value without knowing
the value type.

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

Cr-Commit-Position: refs/heads/master@{#312339}

20 files changed, 117 insertions, 148 deletions

diff --git a/cc/base/math_util.cc b/cc/base/math_util.cc
index 816f6fc..99c3cf3 100644
--- a/cc/base/math_util.cc
+++ b/cc/base/math_util.cc
@@ -733,59 +733,85 @@ scoped_ptr<base::Value> MathUtil::AsValue(const gfx::PointF& pt) {
   return res.Pass();
 }
 
-void MathUtil::AddToTracedValue(const gfx::Size& s,
+void MathUtil::AddToTracedValue(const char* name,
+                                const gfx::Size& s,
                                 base::debug::TracedValue* res) {
+  res->BeginDictionary(name);
   res->SetDouble("width", s.width());
   res->SetDouble("height", s.height());
+  res->EndDictionary();
 }
 
-void MathUtil::AddToTracedValue(const gfx::SizeF& s,
+void MathUtil::AddToTracedValue(const char* name,
+                                const gfx::SizeF& s,
                                 base::debug::TracedValue* res) {
+  res->BeginDictionary(name);
   res->SetDouble("width", s.width());
   res->SetDouble("height", s.height());
+  res->EndDictionary();
 }
 
-void MathUtil::AddToTracedValue(const gfx::Rect& r,
+void MathUtil::AddToTracedValue(const char* name,
+                                const gfx::Rect& r,
                                 base::debug::TracedValue* res) {
+  res->BeginArray(name);
   res->AppendInteger(r.x());
   res->AppendInteger(r.y());
   res->AppendInteger(r.width());
   res->AppendInteger(r.height());
+  res->EndArray();
 }
 
-void MathUtil::AddToTracedValue(const gfx::PointF& pt,
+void MathUtil::AddToTracedValue(const char* name,
+                                const gfx::PointF& pt,
                                 base::debug::TracedValue* res) {
+  res->BeginArray(name);
   res->AppendDouble(pt.x());
   res->AppendDouble(pt.y());
+  res->EndArray();
 }
 
-void MathUtil::AddToTracedValue(const gfx::Point3F& pt,
+void MathUtil::AddToTracedValue(const char* name,
+                                const gfx::Point3F& pt,
                                 base::debug::TracedValue* res) {
+  res->BeginArray(name);
   res->AppendDouble(pt.x());
   res->AppendDouble(pt.y());
   res->AppendDouble(pt.z());
+  res->EndArray();
 }
 
-void MathUtil::AddToTracedValue(const gfx::Vector2d& v,
+void MathUtil::AddToTracedValue(const char* name,
+                                const gfx::Vector2d& v,
                                 base::debug::TracedValue* res) {
+  res->BeginArray(name);
   res->AppendInteger(v.x());
   res->AppendInteger(v.y());
+  res->EndArray();
 }
 
-void MathUtil::AddToTracedValue(const gfx::Vector2dF& v,
+void MathUtil::AddToTracedValue(const char* name,
+                                const gfx::Vector2dF& v,
                                 base::debug::TracedValue* res) {
+  res->BeginArray(name);
   res->AppendDouble(v.x());
   res->AppendDouble(v.y());
+  res->EndArray();
 }
 
-void MathUtil::AddToTracedValue(const gfx::ScrollOffset& v,
+void MathUtil::AddToTracedValue(const char* name,
+                                const gfx::ScrollOffset& v,
                                 base::debug::TracedValue* res) {
+  res->BeginArray(name);
   res->AppendDouble(v.x());
   res->AppendDouble(v.y());
+  res->EndArray();
 }
 
-void MathUtil::AddToTracedValue(const gfx::QuadF& q,
+void MathUtil::AddToTracedValue(const char* name,
+                                const gfx::QuadF& q,
                                 base::debug::TracedValue* res) {
+  res->BeginArray(name);
   res->AppendDouble(q.p1().x());
   res->AppendDouble(q.p1().y());
   res->AppendDouble(q.p2().x());
@@ -794,33 +820,43 @@ void MathUtil::AddToTracedValue(const gfx::QuadF& q,
   res->AppendDouble(q.p3().y());
   res->AppendDouble(q.p4().x());
   res->AppendDouble(q.p4().y());
+  res->EndArray();
 }
 
-void MathUtil::AddToTracedValue(const gfx::RectF& rect,
+void MathUtil::AddToTracedValue(const char* name,
+                                const gfx::RectF& rect,
                                 base::debug::TracedValue* res) {
+  res->BeginArray(name);
   res->AppendDouble(rect.x());
   res->AppendDouble(rect.y());
   res->AppendDouble(rect.width());
   res->AppendDouble(rect.height());
+  res->EndArray();
 }
 
-void MathUtil::AddToTracedValue(const gfx::Transform& transform,
+void MathUtil::AddToTracedValue(const char* name,
+                                const gfx::Transform& transform,
                                 base::debug::TracedValue* res) {
+  res->BeginArray(name);
   const SkMatrix44& m = transform.matrix();
   for (int row = 0; row < 4; ++row) {
     for (int col = 0; col < 4; ++col)
       res->AppendDouble(m.getDouble(row, col));
   }
+  res->EndArray();
 }
 
-void MathUtil::AddToTracedValue(const gfx::BoxF& box,
+void MathUtil::AddToTracedValue(const char* name,
+                                const gfx::BoxF& box,
                                 base::debug::TracedValue* res) {
+  res->BeginArray(name);
   res->AppendInteger(box.x());
   res->AppendInteger(box.y());
   res->AppendInteger(box.z());
   res->AppendInteger(box.width());
   res->AppendInteger(box.height());
   res->AppendInteger(box.depth());
+  res->EndArray();
 }
 
 double MathUtil::AsDoubleSafely(double value) {
diff --git a/cc/base/math_util.h b/cc/base/math_util.h
index 50494e1..d9cc43b 100644
--- a/cc/base/math_util.h
+++ b/cc/base/math_util.h
@@ -199,29 +199,41 @@ class CC_EXPORT MathUtil {
   static bool FromValue(const base::Value*, gfx::Rect* out_rect);
   static scoped_ptr<base::Value> AsValue(const gfx::PointF& q);
 
-  static void AddToTracedValue(const gfx::Size& s,
+  static void AddToTracedValue(const char* name,
+                               const gfx::Size& s,
                                base::debug::TracedValue* res);
-  static void AddToTracedValue(const gfx::SizeF& s,
+  static void AddToTracedValue(const char* name,
+                               const gfx::SizeF& s,
                                base::debug::TracedValue* res);
-  static void AddToTracedValue(const gfx::Rect& r,
+  static void AddToTracedValue(const char* name,
+                               const gfx::Rect& r,
                                base::debug::TracedValue* res);
-  static void AddToTracedValue(const gfx::PointF& q,
+  static void AddToTracedValue(const char* name,
+                               const gfx::PointF& q,
                                base::debug::TracedValue* res);
-  static void AddToTracedValue(const gfx::Point3F&,
+  static void AddToTracedValue(const char* name,
+                               const gfx::Point3F&,
                                base::debug::TracedValue* res);
-  static void AddToTracedValue(const gfx::Vector2d& v,
+  static void AddToTracedValue(const char* name,
+                               const gfx::Vector2d& v,
                                base::debug::TracedValue* res);
-  static void AddToTracedValue(const gfx::Vector2dF& v,
+  static void AddToTracedValue(const char* name,
+                               const gfx::Vector2dF& v,
                                base::debug::TracedValue* res);
-  static void AddToTracedValue(const gfx::ScrollOffset& v,
+  static void AddToTracedValue(const char* name,
+                               const gfx::ScrollOffset& v,
                                base::debug::TracedValue* res);
-  static void AddToTracedValue(const gfx::QuadF& q,
+  static void AddToTracedValue(const char* name,
+                               const gfx::QuadF& q,
                                base::debug::TracedValue* res);
-  static void AddToTracedValue(const gfx::RectF& rect,
+  static void AddToTracedValue(const char* name,
+                               const gfx::RectF& rect,
                                base::debug::TracedValue* res);
-  static void AddToTracedValue(const gfx::Transform& transform,
+  static void AddToTracedValue(const char* name,
+                               const gfx::Transform& transform,
                                base::debug::TracedValue* res);
-  static void AddToTracedValue(const gfx::BoxF& box,
+  static void AddToTracedValue(const char* name,
+                               const gfx::BoxF& box,
                                base::debug::TracedValue* res);
 
   // Returns a base::Value representation of the floating point value.
diff --git a/cc/layers/layer_impl.cc b/cc/layers/layer_impl.cc
index 8c7d972..d6e2a23 100644
--- a/cc/layers/layer_impl.cc
+++ b/cc/layers/layer_impl.cc
@@ -1466,35 +1466,24 @@ void LayerImpl::AsValueInto(base::debug::TracedValue* state) const {
       LayerTypeAsString(),
       this);
   state->SetInteger("layer_id", id());
-  state->BeginDictionary("bounds");
-  MathUtil::AddToTracedValue(bounds_, state);
-  state->EndDictionary();
+  MathUtil::AddToTracedValue("bounds", bounds_, state);
 
   state->SetDouble("opacity", opacity());
 
-  state->BeginArray("position");
-  MathUtil::AddToTracedValue(position_, state);
-  state->EndArray();
+  MathUtil::AddToTracedValue("position", position_, state);
 
   state->SetInteger("draws_content", DrawsContent());
   state->SetInteger("gpu_memory_usage", GPUMemoryUsageInBytes());
 
-  state->BeginArray("scroll_offset");
-  MathUtil::AddToTracedValue(scroll_offset_, state);
-  state->EndArray();
-
-  state->BeginArray("transform_origin");
-  MathUtil::AddToTracedValue(transform_origin_, state);
-  state->EndArray();
+  MathUtil::AddToTracedValue("scroll_offset", scroll_offset_, state);
+  MathUtil::AddToTracedValue("transform_origin", transform_origin_, state);
 
   bool clipped;
   gfx::QuadF layer_quad = MathUtil::MapQuad(
       screen_space_transform(),
       gfx::QuadF(gfx::Rect(content_bounds())),
       &clipped);
-  state->BeginArray("layer_quad");
-  MathUtil::AddToTracedValue(layer_quad, state);
-  state->EndArray();
+  MathUtil::AddToTracedValue("layer_quad", layer_quad, state);
   if (!touch_event_handler_region_.IsEmpty()) {
     state->BeginArray("touch_event_handler_region");
     touch_event_handler_region_.AsValueInto(state);
@@ -1552,11 +1541,8 @@ void LayerImpl::AsValueInto(base::debug::TracedValue* state) const {
       layer_animation_controller()->HasAnimationThatInflatesBounds());
 
   gfx::BoxF box;
-  if (LayerUtils::GetAnimationBounds(*this, &box)) {
-    state->BeginArray("animation_bounds");
-    MathUtil::AddToTracedValue(box, state);
-    state->EndArray();
-  }
+  if (LayerUtils::GetAnimationBounds(*this, &box))
+    MathUtil::AddToTracedValue("animation_bounds", box, state);
 
   if (debug_info_.get()) {
     std::string str;
diff --git a/cc/layers/picture_layer_impl.cc b/cc/layers/picture_layer_impl.cc
index 8db30c6..6845a07 100644
--- a/cc/layers/picture_layer_impl.cc
+++ b/cc/layers/picture_layer_impl.cc
@@ -1179,13 +1179,10 @@ void PictureLayerImpl::AsValueInto(base::debug::TracedValue* state) const {
   tilings_->AsValueInto(state);
   state->EndArray();
 
-  state->BeginArray("tile_priority_rect");
-  MathUtil::AddToTracedValue(GetViewportForTilePriorityInContentSpace(), state);
-  state->EndArray();
+  MathUtil::AddToTracedValue("tile_priority_rect",
+                             GetViewportForTilePriorityInContentSpace(), state);
 
-  state->BeginArray("visible_rect");
-  MathUtil::AddToTracedValue(visible_content_rect(), state);
-  state->EndArray();
+  MathUtil::AddToTracedValue("visible_rect", visible_content_rect(), state);
 
   state->BeginArray("pictures");
   raster_source_->AsValueInto(state);
@@ -1202,9 +1199,7 @@ void PictureLayerImpl::AsValueInto(base::debug::TracedValue* state) const {
        iter; ++iter) {
     state->BeginDictionary();
 
-    state->BeginArray("geometry_rect");
-    MathUtil::AddToTracedValue(iter.geometry_rect(), state);
-    state->EndArray();
+    MathUtil::AddToTracedValue("geometry_rect", iter.geometry_rect(), state);
 
     if (*iter)
       TracedValue::SetIDRef(*iter, state, "tile");
diff --git a/cc/layers/tiled_layer_impl.cc b/cc/layers/tiled_layer_impl.cc
index a36c030..5816fc5 100644
--- a/cc/layers/tiled_layer_impl.cc
+++ b/cc/layers/tiled_layer_impl.cc
@@ -107,9 +107,7 @@ scoped_ptr<LayerImpl> TiledLayerImpl::CreateLayerImpl(
 
 void TiledLayerImpl::AsValueInto(base::debug::TracedValue* state) const {
   LayerImpl::AsValueInto(state);
-  state->BeginArray("invalidation");
-  MathUtil::AddToTracedValue(update_rect(), state);
-  state->EndArray();
+  MathUtil::AddToTracedValue("invalidation", update_rect(), state);
 }
 
 size_t TiledLayerImpl::GPUMemoryUsageInBytes() const {
diff --git a/cc/output/filter_operation.cc b/cc/output/filter_operation.cc
index 173985b..b4a84bd 100644
--- a/cc/output/filter_operation.cc
+++ b/cc/output/filter_operation.cc
@@ -272,9 +272,7 @@ void FilterOperation::AsValueInto(base::debug::TracedValue* value) const {
       break;
     case FilterOperation::DROP_SHADOW:
       value->SetDouble("std_deviation", amount_);
-      value->BeginArray("offset");
-      MathUtil::AddToTracedValue(drop_shadow_offset_, value);
-      value->EndArray();
+      MathUtil::AddToTracedValue("offset", drop_shadow_offset_, value);
       value->SetInteger("color", drop_shadow_color_);
       break;
     case FilterOperation::COLOR_MATRIX: {
diff --git a/cc/quads/content_draw_quad_base.cc b/cc/quads/content_draw_quad_base.cc
index 7304498..0a2a2f4 100644
--- a/cc/quads/content_draw_quad_base.cc
+++ b/cc/quads/content_draw_quad_base.cc
@@ -55,13 +55,8 @@ void ContentDrawQuadBase::SetAll(const SharedQuadState* shared_quad_state,
 }
 
 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();
+  MathUtil::AddToTracedValue("tex_coord_rect", tex_coord_rect, value);
+  MathUtil::AddToTracedValue("texture_size", texture_size, value);
 
   value->SetBoolean("swizzle_contents", swizzle_contents);
   value->SetBoolean("nearest_neighbor", nearest_neighbor);
diff --git a/cc/quads/draw_quad.cc b/cc/quads/draw_quad.cc
index 7322a7a..f8f00b6 100644
--- a/cc/quads/draw_quad.cc
+++ b/cc/quads/draw_quad.cc
@@ -61,39 +61,31 @@ void DrawQuad::AsValueInto(base::debug::TracedValue* value) const {
   value->SetInteger("material", material);
   TracedValue::SetIDRef(shared_quad_state, value, "shared_state");
 
-  value->BeginArray("content_space_rect");
-  MathUtil::AddToTracedValue(rect, value);
-  value->EndArray();
+  MathUtil::AddToTracedValue("content_space_rect", rect, value);
 
   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->BeginArray("rect_as_target_space_quad");
-  MathUtil::AddToTracedValue(rect_as_target_space_quad, value);
-  value->EndArray();
+  MathUtil::AddToTracedValue("rect_as_target_space_quad",
+                             rect_as_target_space_quad, value);
 
   value->SetBoolean("rect_is_clipped", rect_is_clipped);
 
-  value->BeginArray("content_space_opaque_rect");
-  MathUtil::AddToTracedValue(opaque_rect, value);
-  value->EndArray();
+  MathUtil::AddToTracedValue("content_space_opaque_rect", opaque_rect, value);
 
   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->BeginArray("opaque_rect_as_target_space_quad");
-  MathUtil::AddToTracedValue(opaque_rect_as_target_space_quad, value);
-  value->EndArray();
+  MathUtil::AddToTracedValue("opaque_rect_as_target_space_quad",
+                             opaque_rect_as_target_space_quad, value);
 
   value->SetBoolean("opaque_rect_is_clipped", opaque_rect_is_clipped);
 
-  value->BeginArray("content_space_visible_rect");
-  MathUtil::AddToTracedValue(visible_rect, value);
-  value->EndArray();
+  MathUtil::AddToTracedValue("content_space_visible_rect", visible_rect, value);
 
   bool visible_rect_is_clipped;
   gfx::QuadF visible_rect_as_target_space_quad = MathUtil::MapQuad(
@@ -101,9 +93,8 @@ void DrawQuad::AsValueInto(base::debug::TracedValue* value) const {
       gfx::QuadF(visible_rect),
       &visible_rect_is_clipped);
 
-  value->BeginArray("visible_rect_as_target_space_quad");
-  MathUtil::AddToTracedValue(visible_rect_as_target_space_quad, value);
-  value->EndArray();
+  MathUtil::AddToTracedValue("visible_rect_as_target_space_quad",
+                             visible_rect_as_target_space_quad, value);
 
   value->SetBoolean("visible_rect_is_clipped", visible_rect_is_clipped);
 
diff --git a/cc/quads/io_surface_draw_quad.cc b/cc/quads/io_surface_draw_quad.cc
index e565a43..b0eba53 100644
--- a/cc/quads/io_surface_draw_quad.cc
+++ b/cc/quads/io_surface_draw_quad.cc
@@ -58,9 +58,7 @@ const IOSurfaceDrawQuad* IOSurfaceDrawQuad::MaterialCast(
 }
 
 void IOSurfaceDrawQuad::ExtendValue(base::debug::TracedValue* value) const {
-  value->BeginDictionary("io_surface_size");
-  MathUtil::AddToTracedValue(io_surface_size, value);
-  value->EndDictionary();
+  MathUtil::AddToTracedValue("io_surface_size", io_surface_size, value);
 
   value->SetInteger("io_surface_resource_id", io_surface_resource_id);
   const char* orientation_string = NULL;
diff --git a/cc/quads/picture_draw_quad.cc b/cc/quads/picture_draw_quad.cc
index 2171542..24c8c15 100644
--- a/cc/quads/picture_draw_quad.cc
+++ b/cc/quads/picture_draw_quad.cc
@@ -86,9 +86,7 @@ const PictureDrawQuad* PictureDrawQuad::MaterialCast(const DrawQuad* quad) {
 
 void PictureDrawQuad::ExtendValue(base::debug::TracedValue* value) const {
   ContentDrawQuadBase::ExtendValue(value);
-  value->BeginArray("content_rect");
-  MathUtil::AddToTracedValue(content_rect, value);
-  value->EndArray();
+  MathUtil::AddToTracedValue("content_rect", content_rect, value);
   value->SetDouble("contents_scale", contents_scale);
   value->SetInteger("texture_format", texture_format);
   // TODO(piman): raster_source?
diff --git a/cc/quads/render_pass.cc b/cc/quads/render_pass.cc
index a1426f5..0a77a90 100644
--- a/cc/quads/render_pass.cc
+++ b/cc/quads/render_pass.cc
@@ -181,13 +181,8 @@ void RenderPass::SetAll(RenderPassId id,
 }
 
 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();
+  MathUtil::AddToTracedValue("output_rect", output_rect, value);
+  MathUtil::AddToTracedValue("damage_rect", damage_rect, value);
 
   value->SetBoolean("has_transparent_background", has_transparent_background);
   value->SetInteger("copy_requests", copy_requests.size());
diff --git a/cc/quads/render_pass_draw_quad.cc b/cc/quads/render_pass_draw_quad.cc
index d3aeb05..ce5065f 100644
--- a/cc/quads/render_pass_draw_quad.cc
+++ b/cc/quads/render_pass_draw_quad.cc
@@ -98,22 +98,13 @@ const RenderPassDrawQuad* RenderPassDrawQuad::MaterialCast(
 void RenderPassDrawQuad::ExtendValue(base::debug::TracedValue* value) const {
   TracedValue::SetIDRef(render_pass_id.AsTracingId(), value, "render_pass_id");
   value->SetInteger("mask_resource_id", mask_resource_id);
-
-  value->BeginDictionary("mask_texture_size");
-  MathUtil::AddToTracedValue(mask_texture_size, value);
-  value->EndDictionary();
-
-  value->BeginArray("mask_uv_scale");
-  MathUtil::AddToTracedValue(mask_uv_scale, value);
-  value->EndArray();
+  MathUtil::AddToTracedValue("mask_texture_size", mask_texture_size, value);
+  MathUtil::AddToTracedValue("mask_uv_scale", mask_uv_scale, value);
 
   value->BeginDictionary("filters");
   filters.AsValueInto(value);
   value->EndDictionary();
-
-  value->BeginArray("filters_scale");
-  MathUtil::AddToTracedValue(filters_scale, value);
-  value->EndArray();
+  MathUtil::AddToTracedValue("filters_scale", filters_scale, value);
 
   value->BeginDictionary("background_filters");
   background_filters.AsValueInto(value);
diff --git a/cc/quads/shared_quad_state.cc b/cc/quads/shared_quad_state.cc
index 83df365..e13a122 100644
--- a/cc/quads/shared_quad_state.cc
+++ b/cc/quads/shared_quad_state.cc
@@ -47,23 +47,14 @@ void SharedQuadState::SetAll(const gfx::Transform& content_to_target_transform,
 }
 
 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();
+  MathUtil::AddToTracedValue("transform", content_to_target_transform, value);
+  MathUtil::AddToTracedValue("layer_content_bounds", content_bounds, value);
+  MathUtil::AddToTracedValue("layer_visible_content_rect", visible_content_rect,
+                             value);
 
   value->SetBoolean("is_clipped", is_clipped);
 
-  value->BeginArray("clip_rect");
-  MathUtil::AddToTracedValue(clip_rect, value);
-  value->EndArray();
+  MathUtil::AddToTracedValue("clip_rect", clip_rect, value);
 
   value->SetDouble("opacity", opacity);
   value->SetString("blend_mode", SkXfermode::ModeName(blend_mode));
diff --git a/cc/quads/stream_video_draw_quad.cc b/cc/quads/stream_video_draw_quad.cc
index 6b5a509..1f5f05e 100644
--- a/cc/quads/stream_video_draw_quad.cc
+++ b/cc/quads/stream_video_draw_quad.cc
@@ -52,9 +52,7 @@ const StreamVideoDrawQuad* StreamVideoDrawQuad::MaterialCast(
 
 void StreamVideoDrawQuad::ExtendValue(base::debug::TracedValue* value) const {
   value->SetInteger("resource_id", resource_id);
-  value->BeginArray("matrix");
-  MathUtil::AddToTracedValue(matrix, value);
-  value->EndArray();
+  MathUtil::AddToTracedValue("matrix", matrix, value);
 }
 
 }  // namespace cc
diff --git a/cc/quads/texture_draw_quad.cc b/cc/quads/texture_draw_quad.cc
index d430c72..5d01e81 100644
--- a/cc/quads/texture_draw_quad.cc
+++ b/cc/quads/texture_draw_quad.cc
@@ -94,13 +94,9 @@ const TextureDrawQuad* TextureDrawQuad::MaterialCast(const DrawQuad* quad) {
 void TextureDrawQuad::ExtendValue(base::debug::TracedValue* value) const {
   value->SetInteger("resource_id", resource_id);
   value->SetBoolean("premultiplied_alpha", premultiplied_alpha);
-  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();
+  MathUtil::AddToTracedValue("uv_top_left", uv_top_left, value);
+  MathUtil::AddToTracedValue("uv_bottom_right", uv_bottom_right, value);
 
   value->SetInteger("background_color", background_color);
 
diff --git a/cc/quads/yuv_video_draw_quad.cc b/cc/quads/yuv_video_draw_quad.cc
index 612362e..6d3a828 100644
--- a/cc/quads/yuv_video_draw_quad.cc
+++ b/cc/quads/yuv_video_draw_quad.cc
@@ -76,9 +76,7 @@ const YUVVideoDrawQuad* YUVVideoDrawQuad::MaterialCast(
 }
 
 void YUVVideoDrawQuad::ExtendValue(base::debug::TracedValue* value) const {
-  value->BeginArray("tex_coord_rect");
-  MathUtil::AddToTracedValue(tex_coord_rect, value);
-  value->EndArray();
+  MathUtil::AddToTracedValue("tex_coord_rect", tex_coord_rect, value);
   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/resources/picture.cc b/cc/resources/picture.cc
index d878ce3..b1ca99d 100644
--- a/cc/resources/picture.cc
+++ b/cc/resources/picture.cc
@@ -470,9 +470,7 @@ scoped_refptr<base::debug::ConvertableToTraceFormat>
   scoped_refptr<base::debug::TracedValue> record_data =
       new base::debug::TracedValue();
   TracedValue::SetIDRef(this, record_data.get(), "picture_id");
-  record_data->BeginArray("layer_rect");
-  MathUtil::AddToTracedValue(layer_rect_, record_data.get());
-  record_data->EndArray();
+  MathUtil::AddToTracedValue("layer_rect", layer_rect_, record_data.get());
   return record_data;
 }
 
diff --git a/cc/resources/picture_layer_tiling.cc b/cc/resources/picture_layer_tiling.cc
index 341e6e3..aab740a 100644
--- a/cc/resources/picture_layer_tiling.cc
+++ b/cc/resources/picture_layer_tiling.cc
@@ -869,9 +869,7 @@ void PictureLayerTiling::GetAllTilesForTracing(
 void PictureLayerTiling::AsValueInto(base::debug::TracedValue* state) const {
   state->SetInteger("num_tiles", tiles_.size());
   state->SetDouble("content_scale", contents_scale_);
-  state->BeginDictionary("tiling_size");
-  MathUtil::AddToTracedValue(tiling_size(), state);
-  state->EndDictionary();
+  MathUtil::AddToTracedValue("tiling_size", tiling_size(), state);
 }
 
 size_t PictureLayerTiling::GPUMemoryUsageInBytes() const {
diff --git a/cc/resources/tile.cc b/cc/resources/tile.cc
index 8a09cfc..6734bab 100644
--- a/cc/resources/tile.cc
+++ b/cc/resources/tile.cc
@@ -55,9 +55,7 @@ void Tile::AsValueInto(base::debug::TracedValue* res) const {
   TracedValue::SetIDRef(raster_source_.get(), res, "picture_pile");
   res->SetDouble("contents_scale", contents_scale_);
 
-  res->BeginArray("content_rect");
-  MathUtil::AddToTracedValue(content_rect_, res);
-  res->EndArray();
+  MathUtil::AddToTracedValue("content_rect", content_rect_, res);
 
   res->SetInteger("layer_id", layer_id_);
 
diff --git a/cc/trees/layer_tree_host_impl.cc b/cc/trees/layer_tree_host_impl.cc
index db9b072..526d456 100644
--- a/cc/trees/layer_tree_host_impl.cc
+++ b/cc/trees/layer_tree_host_impl.cc
@@ -3298,9 +3298,8 @@ void LayerTreeHostImpl::AsValueWithFrameInto(
     ActivationStateAsValueInto(state);
     state->EndDictionary();
   }
-  state->BeginDictionary("device_viewport_size");
-  MathUtil::AddToTracedValue(device_viewport_size_, state);
-  state->EndDictionary();
+  MathUtil::AddToTracedValue("device_viewport_size", device_viewport_size_,
+                             state);
 
   std::set<const Tile*> tiles;
   active_tree_->GetAllTilesForTracing(&tiles);