Remove more usage of the base::ListValue::Append(Value*) overload.

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"
+#include "base/memory/ptr_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/time/time.h"
 #include "third_party/skia/include/core/SkColorFilter.h"
 #include "third_party/skia/include/core/SkImageFilter.h"
 #include "third_party/skia/include/core/SkPaint.h"
 #include "third_party/skia/include/core/SkPath.h"
 #include "third_party/skia/include/core/SkPicture.h"
 #include "third_party/skia/include/core/SkRRect.h"
 #include "third_party/skia/include/core/SkRegion.h"
 #include "third_party/skia/include/core/SkString.h"
@@ skipping 18 matching lines @@
 
   std::string str() const {
     return oss_.str();
   }
 
 private:
   char separator_;
   std::ostringstream oss_;
 };
 
-WARN_UNUSED_RESULT
 std::unique_ptr<base::Value> AsValue(bool b) {
   std::unique_ptr<base::FundamentalValue> val(new base::FundamentalValue(b));
 
   return std::move(val);
 }
 
-WARN_UNUSED_RESULT
 std::unique_ptr<base::Value> AsValue(SkScalar scalar) {
   std::unique_ptr<base::FundamentalValue> val(
       new base::FundamentalValue(scalar));
 
   return std::move(val);
 }
 
-WARN_UNUSED_RESULT
 std::unique_ptr<base::Value> AsValue(const SkSize& size) {
   std::unique_ptr<base::DictionaryValue> val(new base::DictionaryValue());
   val->Set("width",  AsValue(size.width()));
   val->Set("height", AsValue(size.height()));
 
   return std::move(val);
 }
 
-WARN_UNUSED_RESULT
 std::unique_ptr<base::Value> AsValue(const SkPoint& point) {
   std::unique_ptr<base::DictionaryValue> val(new base::DictionaryValue());
   val->Set("x", AsValue(point.x()));
   val->Set("y", AsValue(point.y()));
 
   return std::move(val);
 }
 
-WARN_UNUSED_RESULT
 std::unique_ptr<base::Value> AsValue(const SkRect& rect) {
   std::unique_ptr<base::DictionaryValue> val(new base::DictionaryValue());
   val->Set("left", AsValue(rect.fLeft));
   val->Set("top", AsValue(rect.fTop));
   val->Set("right", AsValue(rect.fRight));
   val->Set("bottom", AsValue(rect.fBottom));
 
   return std::move(val);
 }
 
-WARN_UNUSED_RESULT
 std::unique_ptr<base::Value> AsValue(const SkRRect& rrect) {
   std::unique_ptr<base::DictionaryValue> radii_val(new base::DictionaryValue());
   radii_val->Set("upper-left", AsValue(rrect.radii(SkRRect::kUpperLeft_Corner)));
   radii_val->Set("upper-right", AsValue(rrect.radii(SkRRect::kUpperRight_Corner)));
   radii_val->Set("lower-right", AsValue(rrect.radii(SkRRect::kLowerRight_Corner)));
   radii_val->Set("lower-left", AsValue(rrect.radii(SkRRect::kLowerLeft_Corner)));
 
   std::unique_ptr<base::DictionaryValue> val(new base::DictionaryValue());
   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]));  // no scoped_ptr-aware Append() variant
+    val->Append(AsValue(matrix[i]));
 
   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));
   val->SetInteger("b", SkColorGetB(color));
 
   return std::move(val);
 }
 
-WARN_UNUSED_RESULT
 std::unique_ptr<base::Value> AsValue(SkXfermode::Mode mode) {
   std::unique_ptr<base::StringValue> val(
       new base::StringValue(SkXfermode::ModeName(mode)));
 
   return std::move(val);
 }
 
-WARN_UNUSED_RESULT
 std::unique_ptr<base::Value> AsValue(SkCanvas::PointMode mode) {
   static const char* gModeStrings[] = { "Points", "Lines", "Polygon" };
   DCHECK_LT(static_cast<size_t>(mode), SK_ARRAY_COUNT(gModeStrings));
 
   std::unique_ptr<base::StringValue> val(
       new base::StringValue(gModeStrings[mode]));
 
   return std::move(val);
 }
 
-WARN_UNUSED_RESULT
 std::unique_ptr<base::Value> AsValue(const SkXfermode& xfermode) {
   SkXfermode::Mode mode;
   if (xfermode.asMode(&mode))
     return AsValue(mode);
 
   std::unique_ptr<base::StringValue> val(new base::StringValue("unknown"));
   return std::move(val);
 }
 
-WARN_UNUSED_RESULT
 std::unique_ptr<base::Value> AsValue(const SkColorFilter& filter) {
   std::unique_ptr<base::DictionaryValue> val(new base::DictionaryValue());
 
   if (unsigned flags = filter.getFlags()) {
     FlagsBuilder builder('|');
     builder.addFlag(flags & SkColorFilter::kAlphaUnchanged_Flag,
                     "kAlphaUnchanged_Flag");
 
     val->SetString("flags", builder.str());
   }
@@ skipping 21 matching lines @@
   if (filter.asComponentTable(nullptr)) {
     std::unique_ptr<base::DictionaryValue> component_table_val(
         new base::DictionaryValue());
     // use this as a marker for now
     val->Set("component_table", std::move(component_table_val));
   }
 
   return std::move(val);
 }
 
-WARN_UNUSED_RESULT
 std::unique_ptr<base::Value> AsValue(const SkImageFilter& filter) {
   std::unique_ptr<base::DictionaryValue> val(new base::DictionaryValue());
   val->SetInteger("inputs", filter.countInputs());
 
   SkColorFilter* color_filter;
   if (filter.asColorFilter(&color_filter)) {
     val->Set("color_filter", AsValue(*color_filter));
     SkSafeUnref(color_filter); // ref'd in asColorFilter
   }
 
   return std::move(val);
 }
 
-WARN_UNUSED_RESULT
 std::unique_ptr<base::Value> AsValue(const SkPaint& paint) {
   std::unique_ptr<base::DictionaryValue> val(new base::DictionaryValue());
   SkPaint default_paint;
 
   if (paint.getColor() != default_paint.getColor())
     val->Set("Color", AsValue(paint.getColor()));
 
   if (paint.getStyle() != default_paint.getStyle()) {
     static const char* gStyleStrings[] = { "Fill", "Stroke", "StrokeFill" };
     DCHECK_LT(static_cast<size_t>(paint.getStyle()),
@@ skipping 44 matching lines @@
 
   if (paint.getColorFilter())
     val->Set("ColorFilter", AsValue(*paint.getColorFilter()));
 
   if (paint.getImageFilter())
     val->Set("ImageFilter", AsValue(*paint.getImageFilter()));
 
   return std::move(val);
 }
 
-WARN_UNUSED_RESULT
 std::unique_ptr<base::Value> SaveLayerFlagsAsValue(
     SkCanvas::SaveLayerFlags flags) {
   FlagsBuilder builder('|');
   builder.addFlag(flags & SkCanvas::kIsOpaque_SaveLayerFlag,
                   "kIsOpaque");
   builder.addFlag(flags & SkCanvas::kPreserveLCDText_SaveLayerFlag,
                   "kPreserveLCDText");
 
   std::unique_ptr<base::StringValue> val(new base::StringValue(builder.str()));
 
   return std::move(val);
 }
 
-WARN_UNUSED_RESULT
 std::unique_ptr<base::Value> AsValue(SkRegion::Op op) {
   static const char* gOpStrings[] = { "Difference",
                                       "Intersect",
                                       "Union",
                                       "XOR",
                                       "ReverseDifference",
                                       "Replace"
                                     };
   DCHECK_LT(static_cast<size_t>(op), SK_ARRAY_COUNT(gOpStrings));
   std::unique_ptr<base::StringValue> val(new base::StringValue(gOpStrings[op]));
   return std::move(val);
 }
 
-WARN_UNUSED_RESULT
 std::unique_ptr<base::Value> AsValue(const SkRegion& region) {
   std::unique_ptr<base::DictionaryValue> val(new base::DictionaryValue());
   val->Set("bounds", AsValue(SkRect::Make(region.getBounds())));
 
   return std::move(val);
 }
 
-WARN_UNUSED_RESULT
 std::unique_ptr<base::Value> AsValue(const SkBitmap& bitmap) {
   std::unique_ptr<base::DictionaryValue> val(new base::DictionaryValue());
   val->Set("size", AsValue(SkSize::Make(bitmap.width(), bitmap.height())));
 
   return std::move(val);
 }
 
-WARN_UNUSED_RESULT
 std::unique_ptr<base::Value> AsValue(const SkImage& image) {
   std::unique_ptr<base::DictionaryValue> val(new base::DictionaryValue());
   val->Set("size", AsValue(SkSize::Make(image.width(), image.height())));
 
   return std::move(val);
 }
 
-WARN_UNUSED_RESULT
 std::unique_ptr<base::Value> AsValue(const SkTextBlob& blob) {
   std::unique_ptr<base::DictionaryValue> val(new base::DictionaryValue());
   val->Set("bounds", AsValue(blob.bounds()));
 
   return std::move(val);
 }
 
-WARN_UNUSED_RESULT
 std::unique_ptr<base::Value> AsValue(const SkPath& path) {
   std::unique_ptr<base::DictionaryValue> val(new base::DictionaryValue());
 
   static const char* gFillStrings[] =
       { "winding", "even-odd", "inverse-winding", "inverse-even-odd" };
   DCHECK_LT(static_cast<size_t>(path.getFillType()),
       SK_ARRAY_COUNT(gFillStrings));
   val->SetString("fill-type", gFillStrings[path.getFillType()]);
 
   static const char* gConvexityStrings[] = { "Unknown", "Convex", "Concave" };
@@ skipping 39 matching lines @@
         verb_val->Set("weight", AsValue(iter.conicWeight()));
 
       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::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]));
 
   return std::move(val);
 }
 
 class OverdrawXfermode : public SkXfermode {
 public:
@@ skipping 68 matching lines @@
       filtered_paint_.setAntiAlias(false);
     }
 
     start_ticks_ = base::TimeTicks::Now();
   }
 
   ~AutoOp() {
     base::TimeDelta ticks = base::TimeTicks::Now() - start_ticks_;
     op_record_->SetDouble("cmd_time", ticks.InMillisecondsF());
 
-    canvas_->op_records_.Append(op_record_);
+    canvas_->op_records_.Append(std::move(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(std::move(param));
   }
 
   const SkPaint* paint() const { return &filtered_paint_; }
 
 private:
   BenchmarkingCanvas* canvas_;
-  base::DictionaryValue* op_record_;
+  std::unique_ptr<base::DictionaryValue> op_record_;
   base::ListValue* op_params_;
   base::TimeTicks start_ticks_;
 
   SkPaint filtered_paint_;
 };
 
 BenchmarkingCanvas::BenchmarkingCanvas(SkCanvas* canvas, unsigned flags)
     : INHERITED(canvas->imageInfo().width(),
                 canvas->imageInfo().height())
     , flags_(flags) {
@@ skipping 285 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