Add builders for tracing event's structural arguments

cc/output/filter_operation.cc

 // Copyright 2013 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 <algorithm>
 
+#include "base/debug/trace_event_argument.h"
 #include "base/values.h"
 #include "cc/base/math_util.h"
 #include "cc/output/filter_operation.h"
 #include "ui/gfx/animation/tween.h"
 
 namespace cc {
 
 bool FilterOperation::operator==(const FilterOperation& other) const {
   if (type_ != other.type_)
     return false;
@@ skipping 230 matching lines @@
             gfx::Tween::FloatValueBetween(progress,
                                           from_op.outer_threshold(),
                                           to_op.outer_threshold()),
             to_op.type()));
     blended_filter.set_region(to_op.region());
   }
 
   return blended_filter;
 }
 
-scoped_ptr<base::Value> FilterOperation::AsValue() const {
-  scoped_ptr<base::DictionaryValue> value(new base::DictionaryValue);
+void FilterOperation::AsValueInto(base::debug::TracedValue* value) const {
   value->SetInteger("type", type_);
   switch (type_) {
     case FilterOperation::GRAYSCALE:
     case FilterOperation::SEPIA:
     case FilterOperation::SATURATE:
     case FilterOperation::HUE_ROTATE:
     case FilterOperation::INVERT:
     case FilterOperation::BRIGHTNESS:
     case FilterOperation::CONTRAST:
     case FilterOperation::OPACITY:
     case FilterOperation::BLUR:
     case FilterOperation::SATURATING_BRIGHTNESS:
       value->SetDouble("amount", amount_);
       break;
     case FilterOperation::DROP_SHADOW:
       value->SetDouble("std_deviation", amount_);
-      value->Set("offset", MathUtil::AsValue(drop_shadow_offset_).release());
+      value->BeginArray("offset");
+      MathUtil::AddToTracedValue(drop_shadow_offset_, value);
+      value->EndArray();
       value->SetInteger("color", drop_shadow_color_);
       break;
     case FilterOperation::COLOR_MATRIX: {
-      scoped_ptr<base::ListValue> matrix(new base::ListValue);
+      value->BeginArray("matrix");
       for (size_t i = 0; i < arraysize(matrix_); ++i)
-        matrix->AppendDouble(matrix_[i]);
-      value->Set("matrix", matrix.release());
+        value->AppendDouble(matrix_[i]);
+      value->EndArray();
       break;
     }
     case FilterOperation::ZOOM:
       value->SetDouble("amount", amount_);
       value->SetDouble("inset", zoom_inset_);
       break;
     case FilterOperation::REFERENCE: {
       int count_inputs = 0;
       bool can_filter_image_gpu = false;
       if (image_filter_) {
         count_inputs = image_filter_->countInputs();
         can_filter_image_gpu = image_filter_->canFilterImageGPU();
       }
       value->SetBoolean("is_null", !image_filter_);
       value->SetInteger("count_inputs", count_inputs);
       value->SetBoolean("can_filter_image_gpu", can_filter_image_gpu);
       break;
     }
     case FilterOperation::ALPHA_THRESHOLD: {
         value->SetDouble("inner_threshold", amount_);
         value->SetDouble("outer_threshold", outer_threshold_);
         scoped_ptr<base::ListValue> region_value(new base::ListValue());
+        value->BeginArray("region");
         for (SkRegion::Iterator it(region_); !it.done(); it.next()) {
-          region_value->AppendInteger(it.rect().x());
-          region_value->AppendInteger(it.rect().y());
-          region_value->AppendInteger(it.rect().width());
-          region_value->AppendInteger(it.rect().height());
+          value->AppendInteger(it.rect().x());
+          value->AppendInteger(it.rect().y());
+          value->AppendInteger(it.rect().width());
+          value->AppendInteger(it.rect().height());
         }
-        value->Set("region", region_value.release());
+        value->EndArray();
       }
       break;
   }
-  return value.PassAs<base::Value>();
 }
 
 }  // namespace cc