diff --git a/cc/base/math_util.cc b/cc/base/math_util.cc
index 6533fb20548f5e..8e576e9af3c6ea 100644
--- a/cc/base/math_util.cc
+++ b/cc/base/math_util.cc
@@ -625,22 +625,6 @@ gfx::Vector2dF MathUtil::ProjectVector(const gfx::Vector2dF& source,
                         projected_length * destination.y());
 }
 
-std::unique_ptr<base::Value> MathUtil::AsValue(const gfx::Size& s) {
-  std::unique_ptr<base::DictionaryValue> res(new base::DictionaryValue());
-  res->SetDouble("width", s.width());
-  res->SetDouble("height", s.height());
-  return std::move(res);
-}
-
-std::unique_ptr<base::Value> MathUtil::AsValue(const gfx::Rect& r) {
-  std::unique_ptr<base::ListValue> res(new base::ListValue());
-  res->AppendInteger(r.x());
-  res->AppendInteger(r.y());
-  res->AppendInteger(r.width());
-  res->AppendInteger(r.height());
-  return std::move(res);
-}
-
 bool MathUtil::FromValue(const base::Value* raw_value, gfx::Rect* out_rect) {
   const base::ListValue* value = nullptr;
   if (!raw_value->GetAsList(&value))
@@ -662,13 +646,6 @@ bool MathUtil::FromValue(const base::Value* raw_value, gfx::Rect* out_rect) {
   return true;
 }
 
-std::unique_ptr<base::Value> MathUtil::AsValue(const gfx::PointF& pt) {
-  std::unique_ptr<base::ListValue> res(new base::ListValue());
-  res->AppendDouble(pt.x());
-  res->AppendDouble(pt.y());
-  return std::move(res);
-}
-
 void MathUtil::AddToTracedValue(const char* name,
                                 const gfx::Size& s,
                                 base::trace_event::TracedValue* res) {
diff --git a/cc/base/math_util.h b/cc/base/math_util.h
index 8b3ee3dcbe2cf7..d85bac59d6226b 100644
--- a/cc/base/math_util.h
+++ b/cc/base/math_util.h
@@ -234,11 +234,7 @@ class CC_BASE_EXPORT MathUtil {
   static gfx::Vector2dF ProjectVector(const gfx::Vector2dF& source,
                                       const gfx::Vector2dF& destination);
 
-  // Conversion to value.
-  static std::unique_ptr<base::Value> AsValue(const gfx::Size& s);
-  static std::unique_ptr<base::Value> AsValue(const gfx::Rect& r);
   static bool FromValue(const base::Value*, gfx::Rect* out_rect);
-  static std::unique_ptr<base::Value> AsValue(const gfx::PointF& q);
 
   static void AddToTracedValue(const char* name,
                                const gfx::Size& s,
diff --git a/cc/layers/layer.cc b/cc/layers/layer.cc
index 7983038e8d4305..bbbbc42e847d34 100644
--- a/cc/layers/layer.cc
+++ b/cc/layers/layer.cc
@@ -1535,7 +1535,7 @@ void Layer::SetElementId(ElementId id) {
   if (inputs_.element_id == id)
     return;
   TRACE_EVENT1(TRACE_DISABLED_BY_DEFAULT("cc.debug"), "Layer::SetElementId",
-               "element", id.AsValue().release());
+               "element", id.ToString());
   if (layer_tree_host_ && inputs_.element_id)
     layer_tree_host_->UnregisterElement(inputs_.element_id);
 
diff --git a/cc/layers/layer_impl.cc b/cc/layers/layer_impl.cc
index 93ef6e3579dbe0..84c69d287198e8 100644
--- a/cc/layers/layer_impl.cc
+++ b/cc/layers/layer_impl.cc
@@ -419,52 +419,6 @@ bool LayerImpl::IsAffectedByPageScale() const {
       ->in_subtree_of_page_scale_layer;
 }
 
-std::unique_ptr<base::DictionaryValue> LayerImpl::LayerAsJson() const {
-  std::unique_ptr<base::DictionaryValue> result(new base::DictionaryValue);
-  result->SetInteger("LayerId", id());
-  if (element_id())
-    result->SetString("ElementId", element_id().ToString());
-  result->SetString("LayerType", LayerTypeAsString());
-
-  auto list = std::make_unique<base::ListValue>();
-  list->AppendInteger(bounds().width());
-  list->AppendInteger(bounds().height());
-  result->Set("Bounds", std::move(list));
-
-  list = std::make_unique<base::ListValue>();
-  list->AppendInteger(offset_to_transform_parent().x());
-  list->AppendInteger(offset_to_transform_parent().y());
-  result->Set("OffsetToTransformParent", std::move(list));
-
-  result->SetBoolean("DrawsContent", draws_content_);
-  result->SetBoolean("HitTestable", hit_testable_);
-  result->SetBoolean("Is3dSorted", Is3dSorted());
-  result->SetDouble("Opacity", Opacity());
-  result->SetBoolean("ContentsOpaque", contents_opaque_);
-
-  result->SetInteger("transform_tree_index", transform_tree_index());
-  result->SetInteger("clip_tree_index", clip_tree_index());
-  result->SetInteger("effect_tree_index", effect_tree_index());
-  result->SetInteger("scroll_tree_index", scroll_tree_index());
-
-  if (!GetAllTouchActionRegions().IsEmpty()) {
-    std::unique_ptr<base::Value> region = GetAllTouchActionRegions().AsValue();
-    result->Set("TouchRegion", std::move(region));
-  }
-
-  if (!wheel_event_handler_region_.IsEmpty()) {
-    std::unique_ptr<base::Value> region = wheel_event_handler_region_.AsValue();
-    result->Set("WheelRegion", std::move(region));
-  }
-
-  if (!non_fast_scrollable_region_.IsEmpty()) {
-    std::unique_ptr<base::Value> region = non_fast_scrollable_region_.AsValue();
-    result->Set("NonFastScrollableRegion", std::move(region));
-  }
-
-  return result;
-}
-
 bool LayerImpl::LayerPropertyChanged() const {
   return layer_property_changed_not_from_property_trees_ ||
          LayerPropertyChangedFromPropertyTrees();
@@ -628,7 +582,7 @@ void LayerImpl::SetElementId(ElementId element_id) {
     return;
 
   TRACE_EVENT1(TRACE_DISABLED_BY_DEFAULT("cc.debug"), "LayerImpl::SetElementId",
-               "element", element_id.AsValue().release());
+               "element", element_id.ToString());
 
   layer_tree_impl_->RemoveFromElementLayerList(element_id_);
   element_id_ = element_id;
@@ -743,6 +697,7 @@ void LayerImpl::AsValueInto(base::trace_event::TracedValue* state) const {
     state->EndArray();
   }
 
+  state->SetBoolean("hit_testable", HitTestable());
   state->SetBoolean("can_use_lcd_text", CanUseLCDText());
   state->SetBoolean("contents_opaque", contents_opaque());
 
@@ -783,13 +738,9 @@ void LayerImpl::AsValueInto(base::trace_event::TracedValue* state) const {
 }
 
 std::string LayerImpl::ToString() const {
-  std::string str;
-  base::JSONWriter::WriteWithOptions(
-      *LayerAsJson(),
-      base::JSONWriter::OPTIONS_OMIT_DOUBLE_TYPE_PRESERVATION |
-          base::JSONWriter::OPTIONS_PRETTY_PRINT,
-      &str);
-  return str;
+  base::trace_event::TracedValueJSON value;
+  AsValueInto(&value);
+  return value.ToFormattedJSON();
 }
 
 size_t LayerImpl::GPUMemoryUsageInBytes() const { return 0; }
diff --git a/cc/layers/layer_impl.h b/cc/layers/layer_impl.h
index b78a35aa7d6469..c6ce557f7e4762 100644
--- a/cc/layers/layer_impl.h
+++ b/cc/layers/layer_impl.h
@@ -16,7 +16,6 @@
 
 #include "base/logging.h"
 #include "base/memory/ptr_util.h"
-#include "base/values.h"
 #include "cc/base/region.h"
 #include "cc/base/synced_property.h"
 #include "cc/cc_export.h"
@@ -40,10 +39,6 @@
 #include "ui/gfx/geometry/scroll_offset.h"
 #include "ui/gfx/transform.h"
 
-namespace base {
-class DictionaryValue;
-}
-
 namespace viz {
 class ClientResourceProvider;
 class RenderPass;
@@ -298,8 +293,6 @@ class CC_EXPORT LayerImpl {
   // as appropriate.
   virtual gfx::Rect GetDamageRect() const;
 
-  virtual std::unique_ptr<base::DictionaryValue> LayerAsJson() const;
-
   // This includes |layer_property_changed_not_from_property_trees_| and
   // property_trees changes.
   bool LayerPropertyChanged() const;
diff --git a/cc/layers/nine_patch_generator.cc b/cc/layers/nine_patch_generator.cc
index 30214034a44837..4a1f206b096f56 100644
--- a/cc/layers/nine_patch_generator.cc
+++ b/cc/layers/nine_patch_generator.cc
@@ -4,6 +4,8 @@
 
 #include "cc/layers/nine_patch_generator.h"
 
+#include "base/trace_event/traced_value.h"
+#include "cc/base/math_util.h"
 #include "cc/trees/layer_tree_impl.h"
 #include "components/viz/common/quads/render_pass.h"
 #include "components/viz/common/quads/texture_draw_quad.h"
@@ -368,29 +370,13 @@ void NinePatchGenerator::AppendQuads(LayerImpl* layer_impl,
   }
 }
 
-void NinePatchGenerator::AsJson(base::DictionaryValue* dictionary) const {
-  auto list = std::make_unique<base::ListValue>();
-  list->AppendInteger(image_aperture_.origin().x());
-  list->AppendInteger(image_aperture_.origin().y());
-  list->AppendInteger(image_aperture_.size().width());
-  list->AppendInteger(image_aperture_.size().height());
-  dictionary->Set("ImageAperture", std::move(list));
-
-  list = std::make_unique<base::ListValue>();
-  list->AppendInteger(image_bounds_.width());
-  list->AppendInteger(image_bounds_.height());
-  dictionary->Set("ImageBounds", std::move(list));
-
-  dictionary->Set("Border", MathUtil::AsValue(border_));
-
-  dictionary->SetBoolean("FillCenter", fill_center_);
-
-  list = std::make_unique<base::ListValue>();
-  list->AppendInteger(output_occlusion_.x());
-  list->AppendInteger(output_occlusion_.y());
-  list->AppendInteger(output_occlusion_.width());
-  list->AppendInteger(output_occlusion_.height());
-  dictionary->Set("OutputOcclusion", std::move(list));
+void NinePatchGenerator::AsValueInto(
+    base::trace_event::TracedValue* state) const {
+  MathUtil::AddToTracedValue("ImageAperture", image_aperture_, state);
+  MathUtil::AddToTracedValue("ImageBounds", image_bounds_, state);
+  MathUtil::AddToTracedValue("Border", border_, state);
+  state->SetBoolean("FillCenter", fill_center_);
+  MathUtil::AddToTracedValue("OutputOcclusion", output_occlusion_, state);
 }
 
 }  // namespace cc
diff --git a/cc/layers/nine_patch_generator.h b/cc/layers/nine_patch_generator.h
index afdcb27bff8d35..662b6685c96702 100644
--- a/cc/layers/nine_patch_generator.h
+++ b/cc/layers/nine_patch_generator.h
@@ -15,7 +15,9 @@
 #include "ui/gfx/geometry/size.h"
 
 namespace base {
-class DictionaryValue;
+namespace trace_event {
+class TracedValue;
+}
 }
 
 namespace viz {
@@ -103,7 +105,7 @@ class CC_EXPORT NinePatchGenerator {
                    viz::SharedQuadState* shared_quad_state,
                    const std::vector<Patch>& patches);
 
-  void AsJson(base::DictionaryValue* dictionary) const;
+  void AsValueInto(base::trace_event::TracedValue* state) const;
   void CheckGeometryLimitations();
 
  private:
diff --git a/cc/layers/nine_patch_layer_impl.cc b/cc/layers/nine_patch_layer_impl.cc
index 28a924103676d1..bb0ec4a9754e0f 100644
--- a/cc/layers/nine_patch_layer_impl.cc
+++ b/cc/layers/nine_patch_layer_impl.cc
@@ -5,7 +5,7 @@
 #include "cc/layers/nine_patch_layer_impl.h"
 
 #include "base/strings/stringprintf.h"
-#include "base/values.h"
+#include "base/trace_event/traced_value.h"
 #include "cc/base/math_util.h"
 #include "cc/trees/layer_tree_impl.h"
 #include "cc/trees/occlusion.h"
@@ -85,10 +85,10 @@ const char* NinePatchLayerImpl::LayerTypeAsString() const {
   return "cc::NinePatchLayerImpl";
 }
 
-std::unique_ptr<base::DictionaryValue> NinePatchLayerImpl::LayerAsJson() const {
-  std::unique_ptr<base::DictionaryValue> result = LayerImpl::LayerAsJson();
-  quad_generator_.AsJson(result.get());
-  return result;
+void NinePatchLayerImpl::AsValueInto(
+    base::trace_event::TracedValue* state) const {
+  LayerImpl::AsValueInto(state);
+  quad_generator_.AsValueInto(state);
 }
 
 }  // namespace cc
diff --git a/cc/layers/nine_patch_layer_impl.h b/cc/layers/nine_patch_layer_impl.h
index d63163df9c83ca..65316531c46d8f 100644
--- a/cc/layers/nine_patch_layer_impl.h
+++ b/cc/layers/nine_patch_layer_impl.h
@@ -16,10 +16,6 @@
 #include "ui/gfx/geometry/rect.h"
 #include "ui/gfx/geometry/size.h"
 
-namespace base {
-class DictionaryValue;
-}
-
 namespace cc {
 
 class CC_EXPORT NinePatchLayerImpl : public UIResourceLayerImpl {
@@ -46,7 +42,7 @@ class CC_EXPORT NinePatchLayerImpl : public UIResourceLayerImpl {
   void AppendQuads(viz::RenderPass* render_pass,
                    AppendQuadsData* append_quads_data) override;
 
-  std::unique_ptr<base::DictionaryValue> LayerAsJson() const override;
+  void AsValueInto(base::trace_event::TracedValue* state) const override;
 
  protected:
   NinePatchLayerImpl(LayerTreeImpl* tree_impl, int id);
diff --git a/cc/layers/picture_layer_impl.cc b/cc/layers/picture_layer_impl.cc
index f7d6852173a149..dcfe06400b7ada 100644
--- a/cc/layers/picture_layer_impl.cc
+++ b/cc/layers/picture_layer_impl.cc
@@ -1718,25 +1718,4 @@ gfx::ContentColorUsage PictureLayerImpl::GetContentColorUsage() const {
   return gfx::ContentColorUsage::kSRGB;
 }
 
-std::unique_ptr<base::DictionaryValue> PictureLayerImpl::LayerAsJson() const {
-  auto result = LayerImpl::LayerAsJson();
-  auto dictionary = std::make_unique<base::DictionaryValue>();
-  if (raster_source_) {
-    dictionary->SetBoolean("IsSolidColor", raster_source_->IsSolidColor());
-    auto list = std::make_unique<base::ListValue>();
-    list->AppendInteger(raster_source_->GetSize().width());
-    list->AppendInteger(raster_source_->GetSize().height());
-    dictionary->Set("Size", std::move(list));
-    dictionary->SetBoolean("HasRecordings", raster_source_->HasRecordings());
-
-    const auto& display_list = raster_source_->GetDisplayItemList();
-    size_t op_count = display_list ? display_list->TotalOpCount() : 0;
-    size_t bytes_used = display_list ? display_list->BytesUsed() : 0;
-    dictionary->SetInteger("OpCount", op_count);
-    dictionary->SetInteger("BytesUsed", bytes_used);
-  }
-  result->Set("RasterSource", std::move(dictionary));
-  return result;
-}
-
 }  // namespace cc
diff --git a/cc/layers/picture_layer_impl.h b/cc/layers/picture_layer_impl.h
index a37fa8092e8b71..1061fc68370673 100644
--- a/cc/layers/picture_layer_impl.h
+++ b/cc/layers/picture_layer_impl.h
@@ -189,8 +189,6 @@ class CC_EXPORT PictureLayerImpl
   void RegisterAnimatedImages();
   void UnregisterAnimatedImages();
 
-  std::unique_ptr<base::DictionaryValue> LayerAsJson() const override;
-
   // Set the collection of PaintWorkletInput as well as their PaintImageId that
   // are part of this layer.
   void SetPaintWorkletInputs(
diff --git a/cc/layers/ui_resource_layer_impl.cc b/cc/layers/ui_resource_layer_impl.cc
index cb3dea6c5bd628..d65eceddf67aa4 100644
--- a/cc/layers/ui_resource_layer_impl.cc
+++ b/cc/layers/ui_resource_layer_impl.cc
@@ -5,7 +5,7 @@
 #include "cc/layers/ui_resource_layer_impl.h"
 
 #include "base/strings/stringprintf.h"
-#include "base/values.h"
+#include "base/trace_event/traced_value.h"
 #include "cc/base/math_util.h"
 #include "cc/trees/layer_tree_impl.h"
 #include "cc/trees/occlusion.h"
@@ -138,23 +138,21 @@ const char* UIResourceLayerImpl::LayerTypeAsString() const {
   return "cc::UIResourceLayerImpl";
 }
 
-std::unique_ptr<base::DictionaryValue> UIResourceLayerImpl::LayerAsJson()
-    const {
-  std::unique_ptr<base::DictionaryValue> result = LayerImpl::LayerAsJson();
+void UIResourceLayerImpl::AsValueInto(
+    base::trace_event::TracedValue* state) const {
+  LayerImpl::AsValueInto(state);
 
-  result->Set("ImageBounds", MathUtil::AsValue(image_bounds_));
+  MathUtil::AddToTracedValue("ImageBounds", image_bounds_, state);
 
-  auto list = std::make_unique<base::ListValue>();
-  list->AppendDouble(vertex_opacity_[0]);
-  list->AppendDouble(vertex_opacity_[1]);
-  list->AppendDouble(vertex_opacity_[2]);
-  list->AppendDouble(vertex_opacity_[3]);
-  result->Set("VertexOpacity", std::move(list));
+  state->BeginArray("VertexOpacity");
+  state->AppendDouble(vertex_opacity_[0]);
+  state->AppendDouble(vertex_opacity_[1]);
+  state->AppendDouble(vertex_opacity_[2]);
+  state->AppendDouble(vertex_opacity_[3]);
+  state->EndArray();
 
-  result->Set("UVTopLeft", MathUtil::AsValue(uv_top_left_));
-  result->Set("UVBottomRight", MathUtil::AsValue(uv_bottom_right_));
-
-  return result;
+  MathUtil::AddToTracedValue("UVTopLeft", uv_top_left_, state);
+  MathUtil::AddToTracedValue("UVBottomRight", uv_bottom_right_, state);
 }
 
 }  // namespace cc
diff --git a/cc/layers/ui_resource_layer_impl.h b/cc/layers/ui_resource_layer_impl.h
index f1ad51d00fae7d..f4c37335fc7fff 100644
--- a/cc/layers/ui_resource_layer_impl.h
+++ b/cc/layers/ui_resource_layer_impl.h
@@ -14,10 +14,6 @@
 #include "ui/gfx/geometry/rect.h"
 #include "ui/gfx/geometry/size.h"
 
-namespace base {
-class DictionaryValue;
-}
-
 namespace viz {
 class ClientResourceProvider;
 }
@@ -54,7 +50,7 @@ class CC_EXPORT UIResourceLayerImpl : public LayerImpl {
   void AppendQuads(viz::RenderPass* render_pass,
                    AppendQuadsData* append_quads_data) override;
 
-  std::unique_ptr<base::DictionaryValue> LayerAsJson() const override;
+  void AsValueInto(base::trace_event::TracedValue* state) const override;
 
  protected:
   UIResourceLayerImpl(LayerTreeImpl* tree_impl, int id);
diff --git a/cc/paint/element_id.cc b/cc/paint/element_id.cc
index 69d3237012b03b..3465eb1117a689 100644
--- a/cc/paint/element_id.cc
+++ b/cc/paint/element_id.cc
@@ -10,7 +10,6 @@
 
 #include "base/strings/stringprintf.h"
 #include "base/trace_event/traced_value.h"
-#include "base/values.h"
 
 namespace cc {
 
@@ -34,12 +33,6 @@ std::string ElementId::ToString() const {
   return base::StringPrintf("(%" PRIu64 ")", id_);
 }
 
-std::unique_ptr<base::Value> ElementId::AsValue() const {
-  std::unique_ptr<base::DictionaryValue> res(new base::DictionaryValue());
-  res->SetInteger("id_", id_);
-  return std::move(res);
-}
-
 size_t ElementIdHash::operator()(ElementId key) const {
   return std::hash<int>()(key.id_);
 }
diff --git a/cc/paint/element_id.h b/cc/paint/element_id.h
index 05ecd232dba70d..b9e36acd592a67 100644
--- a/cc/paint/element_id.h
+++ b/cc/paint/element_id.h
@@ -16,7 +16,6 @@
 #include "cc/paint/paint_export.h"
 
 namespace base {
-class Value;
 namespace trace_event {
 class TracedValue;
 }  // namespace trace_event
@@ -59,7 +58,6 @@ struct CC_PAINT_EXPORT ElementId {
   explicit operator bool() const { return !!id_; }
 
   void AddToTracedValue(base::trace_event::TracedValue* res) const;
-  std::unique_ptr<base::Value> AsValue() const;
 
   ElementIdType GetStableId() const;
 
diff --git a/cc/trees/effect_node.cc b/cc/trees/effect_node.cc
index c670898d3c4db0..a412c237f1ce09 100644
--- a/cc/trees/effect_node.cc
+++ b/cc/trees/effect_node.cc
@@ -159,6 +159,8 @@ void EffectNode::AsValueInto(base::trace_event::TracedValue* value) const {
   value->SetBoolean("cache_render_surface", cache_render_surface);
   value->SetBoolean("has_copy_request", has_copy_request);
   value->SetBoolean("double_sided", double_sided);
+  value->SetBoolean("hidden_by_backface_visibility",
+                    hidden_by_backface_visibility);
   value->SetBoolean("trilinear_filtering", trilinear_filtering);
   value->SetBoolean("is_drawn", is_drawn);
   value->SetBoolean("has_potential_filter_animation",
diff --git a/cc/trees/layer_tree_impl.cc b/cc/trees/layer_tree_impl.cc
index d591789319c29d..053f446735587f 100644
--- a/cc/trees/layer_tree_impl.cc
+++ b/cc/trees/layer_tree_impl.cc
@@ -689,7 +689,7 @@ void LayerTreeImpl::AddToElementLayerList(ElementId element_id,
 
   TRACE_EVENT1(TRACE_DISABLED_BY_DEFAULT("layer-element"),
                "LayerTreeImpl::AddToElementLayerList", "element",
-               element_id.AsValue().release());
+               element_id.ToString());
 
   if (!settings().use_layer_lists) {
     host_impl_->mutator_host()->RegisterElementId(element_id,
@@ -703,7 +703,7 @@ void LayerTreeImpl::RemoveFromElementLayerList(ElementId element_id) {
 
   TRACE_EVENT1(TRACE_DISABLED_BY_DEFAULT("layer-element"),
                "LayerTreeImpl::RemoveFromElementLayerList", "element",
-               element_id.AsValue().release());
+               element_id.ToString());
 
   if (!settings().use_layer_lists) {
     host_impl_->mutator_host()->UnregisterElementId(
@@ -2414,16 +2414,15 @@ void LayerTreeImpl::ResetAllChangeTracking() {
 }
 
 std::string LayerTreeImpl::LayerListAsJson() const {
-  auto list = std::make_unique<base::ListValue>();
-  for (auto* layer : *this)
-    list->Append(layer->LayerAsJson());
-  std::string str;
-  base::JSONWriter::WriteWithOptions(
-      *list,
-      base::JSONWriter::OPTIONS_OMIT_DOUBLE_TYPE_PRESERVATION |
-          base::JSONWriter::OPTIONS_PRETTY_PRINT,
-      &str);
-  return str;
+  base::trace_event::TracedValueJSON value;
+  value.BeginArray("LayerTreeImpl");
+  for (auto* layer : *this) {
+    value.BeginDictionary();
+    layer->AsValueInto(&value);
+    value.EndDictionary();
+  }
+  value.EndArray();
+  return value.ToFormattedJSON();
 }
 
 }  // namespace cc