base::ListValue::Append cleanup: pass unique_ptr instead of the released pointer.

skia/ext/benchmarking_canvas.cc

 // Copyright (c) 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 "skia/ext/benchmarking_canvas.h"
 
 #include <memory>
 #include <utility>
 
 #include "base/logging.h"
@@ skipping 91 matching lines @@
   val->Set("rect", AsValue(rrect.rect()));
   val->Set("radii", std::move(radii_val));
 
   return std::move(val);
 }
 
 WARN_UNUSED_RESULT
 std::unique_ptr<base::Value> AsValue(const SkMatrix& matrix) {
   std::unique_ptr<base::ListValue> val(new base::ListValue());
   for (int i = 0; i < 9; ++i)
-    val->Append(AsValue(matrix[i]).release()); // no scoped_ptr-aware Append() variant
+    val->Append(AsValue(matrix[i]));  // no scoped_ptr-aware Append() variant
 
   return std::move(val);
 }
 
 WARN_UNUSED_RESULT
 std::unique_ptr<base::Value> AsValue(SkColor color) {
   std::unique_ptr<base::DictionaryValue> val(new base::DictionaryValue());
   val->SetInteger("a", SkColorGetA(color));
   val->SetInteger("r", SkColorGetR(color));
   val->SetInteger("g", SkColorGetG(color));
@@ skipping 40 matching lines @@
     builder.addFlag(flags & SkColorFilter::kAlphaUnchanged_Flag,
                     "kAlphaUnchanged_Flag");
 
     val->SetString("flags", builder.str());
   }
 
   SkScalar color_matrix[20];
   if (filter.asColorMatrix(color_matrix)) {
     std::unique_ptr<base::ListValue> color_matrix_val(new base::ListValue());
     for (unsigned i = 0; i < 20; ++i)
-      color_matrix_val->Append(AsValue(color_matrix[i]).release());
+      color_matrix_val->Append(AsValue(color_matrix[i]));
 
     val->Set("color_matrix", std::move(color_matrix_val));
   }
 
   SkColor color;
   SkXfermode::Mode mode;
   if (filter.asColorMode(&color, &mode)) {
     std::unique_ptr<base::DictionaryValue> color_mode_val(
         new base::DictionaryValue());
     color_mode_val->Set("color", AsValue(color));
@@ skipping 189 matching lines @@
 
   for(SkPath::Verb verb = iter.next(points, false);
       verb != SkPath::kDone_Verb; verb = iter.next(points, false)) {
       DCHECK_LT(static_cast<size_t>(verb), SK_ARRAY_COUNT(gVerbStrings));
 
       std::unique_ptr<base::DictionaryValue> verb_val(
           new base::DictionaryValue());
       std::unique_ptr<base::ListValue> pts_val(new base::ListValue());
 
       for (int i = 0; i < gPtsPerVerb[verb]; ++i)
-        pts_val->Append(AsValue(points[i + gPtOffsetPerVerb[verb]]).release());
+        pts_val->Append(AsValue(points[i + gPtOffsetPerVerb[verb]]));
 
       verb_val->Set(gVerbStrings[verb], std::move(pts_val));
 
       if (SkPath::kConic_Verb == verb)
         verb_val->Set("weight", AsValue(iter.conicWeight()));
 
-      verbs_val->Append(verb_val.release());
+      verbs_val->Append(std::move(verb_val));
   }
   val->Set("verbs", std::move(verbs_val));
 
   return std::move(val);
 }
 
 template <typename T>
 WARN_UNUSED_RESULT std::unique_ptr<base::Value> AsListValue(const T array[],
                                                             size_t count) {
   std::unique_ptr<base::ListValue> val(new base::ListValue());
 
   for (size_t i = 0; i < count; ++i)
-    val->Append(AsValue(array[i]).release());
+    val->Append(AsValue(array[i]));
 
   return std::move(val);
 }
 
 class OverdrawXfermode : public SkXfermode {
 public:
   SkPMColor xferColor(SkPMColor src, SkPMColor dst) const override {
     // This table encodes the color progression of the overdraw visualization
     static const SkPMColor gTable[] = {
       SkPackARGB32(0x00, 0x00, 0x00, 0x00),
@@ skipping 71 matching lines @@
     base::TimeDelta ticks = base::TimeTicks::Now() - start_ticks_;
     op_record_->SetDouble("cmd_time", ticks.InMillisecondsF());
 
     canvas_->op_records_.Append(op_record_);
   }
 
   void addParam(const char name[], std::unique_ptr<base::Value> value) {
     std::unique_ptr<base::DictionaryValue> param(new base::DictionaryValue());
     param->Set(name, std::move(value));
 
-    op_params_->Append(param.release());
+    op_params_->Append(std::move(param));
   }
 
   const SkPaint* paint() const { return &filtered_paint_; }
 
 private:
   BenchmarkingCanvas* canvas_;
   base::DictionaryValue* op_record_;
   base::ListValue* op_params_;
   base::TimeTicks start_ticks_;
 
@@ skipping 292 matching lines @@
   DCHECK(blob);
   AutoOp op(this, "DrawTextBlob", &paint);
   op.addParam("blob", AsValue(*blob));
   op.addParam("x", AsValue(x));
   op.addParam("y", AsValue(y));
 
   INHERITED::onDrawTextBlob(blob, x, y, *op.paint());
 }
 
 } // namespace skia