Backporting JSONValues from protocol::Values

third_party/WebKit/Source/platform/graphics/LoggingCanvas.cpp

 /*
  * Copyright (C) 2013 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 44 matching lines @@
     String name;
     unsigned pointCount;
     unsigned pointOffset;
 
     VerbParams(const String& name, unsigned pointCount, unsigned pointOffset)
         : name(name)
         , pointCount(pointCount)
         , pointOffset(pointOffset) { }
 };
 
-PassRefPtr<JSONObject> objectForSkRect(const SkRect& rect)
+std::unique_ptr<JSONObject> objectForSkRect(const SkRect& rect)
 {
-    RefPtr<JSONObject> rectItem = JSONObject::create();
-    rectItem->setNumber("left", rect.left());
-    rectItem->setNumber("top", rect.top());
-    rectItem->setNumber("right", rect.right());
-    rectItem->setNumber("bottom", rect.bottom());
-    return rectItem.release();
+    std::unique_ptr<JSONObject> rectItem = JSONObject::create();
+    rectItem->setDouble("left", rect.left());
+    rectItem->setDouble("top", rect.top());
+    rectItem->setDouble("right", rect.right());
+    rectItem->setDouble("bottom", rect.bottom());
+    return rectItem;
 }
 
-PassRefPtr<JSONObject> objectForSkIRect(const SkIRect& rect)
+std::unique_ptr<JSONObject> objectForSkIRect(const SkIRect& rect)
 {
-    RefPtr<JSONObject> rectItem = JSONObject::create();
-    rectItem->setNumber("left", rect.left());
-    rectItem->setNumber("top", rect.top());
-    rectItem->setNumber("right", rect.right());
-    rectItem->setNumber("bottom", rect.bottom());
-    return rectItem.release();
+    std::unique_ptr<JSONObject> rectItem = JSONObject::create();
+    rectItem->setDouble("left", rect.left());
+    rectItem->setDouble("top", rect.top());
+    rectItem->setDouble("right", rect.right());
+    rectItem->setDouble("bottom", rect.bottom());
+    return rectItem;
 }
 
 String pointModeName(SkCanvas::PointMode mode)
 {
     switch (mode) {
     case SkCanvas::kPoints_PointMode: return "Points";
     case SkCanvas::kLines_PointMode: return "Lines";
     case SkCanvas::kPolygon_PointMode: return "Polygon";
     default:
         ASSERT_NOT_REACHED();
         return "?";
     };
 }
 
-PassRefPtr<JSONObject> objectForSkPoint(const SkPoint& point)
+std::unique_ptr<JSONObject> objectForSkPoint(const SkPoint& point)
 {
-    RefPtr<JSONObject> pointItem = JSONObject::create();
-    pointItem->setNumber("x", point.x());
-    pointItem->setNumber("y", point.y());
-    return pointItem.release();
+    std::unique_ptr<JSONObject> pointItem = JSONObject::create();
+    pointItem->setDouble("x", point.x());
+    pointItem->setDouble("y", point.y());
+    return pointItem;
 }
 
-PassRefPtr<JSONArray> arrayForSkPoints(size_t count, const SkPoint points[])
+std::unique_ptr<JSONArray> arrayForSkPoints(size_t count, const SkPoint points[])
 {
-    RefPtr<JSONArray> pointsArrayItem = JSONArray::create();
+    std::unique_ptr<JSONArray> pointsArrayItem = JSONArray::create();
     for (size_t i = 0; i < count; ++i)
         pointsArrayItem->pushObject(objectForSkPoint(points[i]));
-    return pointsArrayItem.release();
+    return pointsArrayItem;
 }
 
-PassRefPtr<JSONObject> objectForRadius(const SkRRect& rrect, SkRRect::Corner corner)
+std::unique_ptr<JSONObject> objectForRadius(const SkRRect& rrect, SkRRect::Corner corner)
 {
-    RefPtr<JSONObject> radiusItem = JSONObject::create();
+    std::unique_ptr<JSONObject> radiusItem = JSONObject::create();
     SkVector radius = rrect.radii(corner);
-    radiusItem->setNumber("xRadius", radius.x());
-    radiusItem->setNumber("yRadius", radius.y());
-    return radiusItem.release();
+    radiusItem->setDouble("xRadius", radius.x());
+    radiusItem->setDouble("yRadius", radius.y());
+    return radiusItem;
 }
 
 String rrectTypeName(SkRRect::Type type)
 {
     switch (type) {
     case SkRRect::kEmpty_Type: return "Empty";
     case SkRRect::kRect_Type: return "Rect";
     case SkRRect::kOval_Type: return "Oval";
     case SkRRect::kSimple_Type: return "Simple";
     case SkRRect::kNinePatch_Type: return "Nine-patch";
@@ skipping 10 matching lines @@
     case SkRRect::kUpperLeft_Corner: return "upperLeftRadius";
     case SkRRect::kUpperRight_Corner: return "upperRightRadius";
     case SkRRect::kLowerRight_Corner: return "lowerRightRadius";
     case SkRRect::kLowerLeft_Corner: return "lowerLeftRadius";
     default:
         ASSERT_NOT_REACHED();
         return "?";
     }
 }
 
-PassRefPtr<JSONObject> objectForSkRRect(const SkRRect& rrect)
+std::unique_ptr<JSONObject> objectForSkRRect(const SkRRect& rrect)
 {
-    RefPtr<JSONObject> rrectItem = JSONObject::create();
+    std::unique_ptr<JSONObject> rrectItem = JSONObject::create();
     rrectItem->setString("type", rrectTypeName(rrect.type()));
-    rrectItem->setNumber("left", rrect.rect().left());
-    rrectItem->setNumber("top", rrect.rect().top());
-    rrectItem->setNumber("right", rrect.rect().right());
-    rrectItem->setNumber("bottom", rrect.rect().bottom());
+    rrectItem->setDouble("left", rrect.rect().left());
+    rrectItem->setDouble("top", rrect.rect().top());
+    rrectItem->setDouble("right", rrect.rect().right());
+    rrectItem->setDouble("bottom", rrect.rect().bottom());
     for (int i = 0; i < 4; ++i)
         rrectItem->setObject(radiusName((SkRRect::Corner) i), objectForRadius(rrect, (SkRRect::Corner) i));
-    return rrectItem.release();
+    return rrectItem;
 }
 
 String fillTypeName(SkPath::FillType type)
 {
     switch (type) {
     case SkPath::kWinding_FillType: return "Winding";
     case SkPath::kEvenOdd_FillType: return "EvenOdd";
     case SkPath::kInverseWinding_FillType: return "InverseWinding";
     case SkPath::kInverseEvenOdd_FillType: return "InverseEvenOdd";
     default:
@@ skipping 23 matching lines @@
     case SkPath::kConic_Verb: return VerbParams("Conic", 2, 1);
     case SkPath::kCubic_Verb: return VerbParams("Cubic", 3, 1);
     case SkPath::kClose_Verb: return VerbParams("Close", 0, 0);
     case SkPath::kDone_Verb: return VerbParams("Done", 0, 0);
     default:
         ASSERT_NOT_REACHED();
         return VerbParams("?", 0, 0);
     };
 }
 
-PassRefPtr<JSONObject> objectForSkPath(const SkPath& path)
+std::unique_ptr<JSONObject> objectForSkPath(const SkPath& path)
 {
-    RefPtr<JSONObject> pathItem = JSONObject::create();
+    std::unique_ptr<JSONObject> pathItem = JSONObject::create();
     pathItem->setString("fillType", fillTypeName(path.getFillType()));
     pathItem->setString("convexity", convexityName(path.getConvexity()));
     pathItem->setBoolean("isRect", path.isRect(0));
     SkPath::Iter iter(path, false);
     SkPoint points[4];
-    RefPtr<JSONArray> pathPointsArray = JSONArray::create();
+    std::unique_ptr<JSONArray> pathPointsArray = JSONArray::create();
     for (SkPath::Verb verb = iter.next(points, false); verb != SkPath::kDone_Verb; verb = iter.next(points, false)) {
         VerbParams verbParams = segmentParams(verb);
-        RefPtr<JSONObject> pathPointItem = JSONObject::create();
+        std::unique_ptr<JSONObject> pathPointItem = JSONObject::create();
         pathPointItem->setString("verb", verbParams.name);
         ASSERT(verbParams.pointCount + verbParams.pointOffset <= WTF_ARRAY_LENGTH(points));
         pathPointItem->setArray("points", arrayForSkPoints(verbParams.pointCount, points + verbParams.pointOffset));
         if (SkPath::kConic_Verb == verb)
-            pathPointItem->setNumber("conicWeight", iter.conicWeight());
-        pathPointsArray->pushObject(pathPointItem);
+            pathPointItem->setDouble("conicWeight", iter.conicWeight());
+        pathPointsArray->pushObject(std::move(pathPointItem));
     }
-    pathItem->setArray("pathPoints", pathPointsArray);
+    pathItem->setArray("pathPoints", std::move(pathPointsArray));
     pathItem->setObject("bounds", objectForSkRect(path.getBounds()));
-    return pathItem.release();
+    return pathItem;
 }
 
 String colorTypeName(SkColorType colorType)
 {
     switch (colorType) {
     case kUnknown_SkColorType: return "None";
     case kAlpha_8_SkColorType: return "A8";
     case kIndex_8_SkColorType: return "Index8";
     case kRGB_565_SkColorType: return "RGB565";
     case kARGB_4444_SkColorType: return "ARGB4444";
     case kN32_SkColorType: return "ARGB8888";
     default:
         ASSERT_NOT_REACHED();
         return "?";
     };
 }
 
-PassRefPtr<JSONObject> objectForBitmapData(const SkBitmap& bitmap)
+std::unique_ptr<JSONObject> objectForBitmapData(const SkBitmap& bitmap)
 {
     Vector<unsigned char> output;
 
     if (RefPtr<SkImage> image = fromSkSp(SkImage::MakeFromBitmap(bitmap))) {
         ImagePixelLocker pixelLocker(image, kUnpremul_SkAlphaType, kRGBA_8888_SkColorType);
         ImageDataBuffer imageData(IntSize(image->width(), image->height()),
             static_cast<const unsigned char*>(pixelLocker.pixels()));
 
         PNGImageEncoder::encode(imageData, &output);
     }
 
-    RefPtr<JSONObject> dataItem = JSONObject::create();
+    std::unique_ptr<JSONObject> dataItem = JSONObject::create();
     dataItem->setString("base64", WTF::base64Encode(reinterpret_cast<char*>(output.data()), output.size()));
     dataItem->setString("mimeType", "image/png");
-    return dataItem.release();
+    return dataItem;
 }
 
-PassRefPtr<JSONObject> objectForSkBitmap(const SkBitmap& bitmap)
+std::unique_ptr<JSONObject> objectForSkBitmap(const SkBitmap& bitmap)
 {
-    RefPtr<JSONObject> bitmapItem = JSONObject::create();
-    bitmapItem->setNumber("width", bitmap.width());
-    bitmapItem->setNumber("height", bitmap.height());
+    std::unique_ptr<JSONObject> bitmapItem = JSONObject::create();
+    bitmapItem->setInteger("width", bitmap.width());
+    bitmapItem->setInteger("height", bitmap.height());
     bitmapItem->setString("config", colorTypeName(bitmap.colorType()));
     bitmapItem->setBoolean("opaque", bitmap.isOpaque());
     bitmapItem->setBoolean("immutable", bitmap.isImmutable());
     bitmapItem->setBoolean("volatile", bitmap.isVolatile());
-    bitmapItem->setNumber("genID", bitmap.getGenerationID());
+    bitmapItem->setInteger("genID", bitmap.getGenerationID());
     bitmapItem->setObject("data", objectForBitmapData(bitmap));
-    return bitmapItem.release();
+    return bitmapItem;
 }
 
-PassRefPtr<JSONObject> objectForSkImage(const SkImage* image)
+std::unique_ptr<JSONObject> objectForSkImage(const SkImage* image)
 {
-    RefPtr<JSONObject> imageItem = JSONObject::create();
-    imageItem->setNumber("width", image->width());
-    imageItem->setNumber("height", image->height());
+    std::unique_ptr<JSONObject> imageItem = JSONObject::create();
+    imageItem->setInteger("width", image->width());
+    imageItem->setInteger("height", image->height());
     imageItem->setBoolean("opaque", image->isOpaque());
-    imageItem->setNumber("uniqueID", image->uniqueID());
-    return imageItem.release();
+    imageItem->setInteger("uniqueID", image->uniqueID());
+    return imageItem;
 }
 
-PassRefPtr<JSONArray> arrayForSkMatrix(const SkMatrix& matrix)
+std::unique_ptr<JSONArray> arrayForSkMatrix(const SkMatrix& matrix)
 {
-    RefPtr<JSONArray> matrixArray = JSONArray::create();
+    std::unique_ptr<JSONArray> matrixArray = JSONArray::create();
     for (int i = 0; i < 9; ++i)
-        matrixArray->pushNumber(matrix[i]);
-    return matrixArray.release();
+        matrixArray->pushDouble(matrix[i]);
+    return matrixArray;
 }
 
-PassRefPtr<JSONObject> objectForSkShader(const SkShader& shader)
+std::unique_ptr<JSONObject> objectForSkShader(const SkShader& shader)
 {
-    RefPtr<JSONObject> shaderItem = JSONObject::create();
+    std::unique_ptr<JSONObject> shaderItem = JSONObject::create();
     const SkMatrix localMatrix = shader.getLocalMatrix();
     if (!localMatrix.isIdentity())
         shaderItem->setArray("localMatrix", arrayForSkMatrix(localMatrix));
-    return shaderItem.release();
+    return shaderItem;
 }
 
 String stringForSkColor(const SkColor& color)
 {
     String colorString = "#";
     appendUnsignedAsHex(color, colorString);
     return colorString;
 }
 
 void appendFlagToString(String* flagsString, bool isSet, const String& name)
@@ skipping 105 matching lines @@
     case SkPaint::kNo_Hinting: return "None";
     case SkPaint::kSlight_Hinting: return "Slight";
     case SkPaint::kNormal_Hinting: return "Normal";
     case SkPaint::kFull_Hinting: return "Full";
     default:
         ASSERT_NOT_REACHED();
         return "?";
     };
 }
 
-PassRefPtr<JSONObject> objectForSkPaint(const SkPaint& paint)
+std::unique_ptr<JSONObject> objectForSkPaint(const SkPaint& paint)
 {
-    RefPtr<JSONObject> paintItem = JSONObject::create();
-    paintItem->setNumber("textSize", paint.getTextSize());
-    paintItem->setNumber("textScaleX", paint.getTextScaleX());
-    paintItem->setNumber("textSkewX", paint.getTextSkewX());
+    std::unique_ptr<JSONObject> paintItem = JSONObject::create();
+    paintItem->setDouble("textSize", paint.getTextSize());
+    paintItem->setDouble("textScaleX", paint.getTextScaleX());
+    paintItem->setDouble("textSkewX", paint.getTextSkewX());
     if (SkShader* shader = paint.getShader())
         paintItem->setObject("shader", objectForSkShader(*shader));
     paintItem->setString("color", stringForSkColor(paint.getColor()));
-    paintItem->setNumber("strokeWidth", paint.getStrokeWidth());
-    paintItem->setNumber("strokeMiter", paint.getStrokeMiter());
+    paintItem->setDouble("strokeWidth", paint.getStrokeWidth());
+    paintItem->setDouble("strokeMiter", paint.getStrokeMiter());
     paintItem->setString("flags", stringForSkPaintFlags(paint));
     paintItem->setString("filterLevel", filterQualityName(paint.getFilterQuality()));
     paintItem->setString("textAlign", textAlignName(paint.getTextAlign()));
     paintItem->setString("strokeCap", strokeCapName(paint.getStrokeCap()));
     paintItem->setString("strokeJoin", strokeJoinName(paint.getStrokeJoin()));
     paintItem->setString("styleName", styleName(paint.getStyle()));
     paintItem->setString("textEncoding", textEncodingName(paint.getTextEncoding()));
     paintItem->setString("hinting", hintingName(paint.getHinting()));
-    return paintItem.release();
+    return paintItem;
 }
 
-PassRefPtr<JSONArray> arrayForSkScalars(size_t n, const SkScalar scalars[])
+std::unique_ptr<JSONArray> arrayForSkScalars(size_t n, const SkScalar scalars[])
 {
-    RefPtr<JSONArray> scalarsArray = JSONArray::create();
+    std::unique_ptr<JSONArray> scalarsArray = JSONArray::create();
     for (size_t i = 0; i < n; ++i)
-        scalarsArray->pushNumber(scalars[i]);
-    return scalarsArray.release();
+        scalarsArray->pushDouble(scalars[i]);
+    return scalarsArray;
 }
 
 String regionOpName(SkRegion::Op op)
 {
     switch (op) {
     case SkRegion::kDifference_Op: return "kDifference_Op";
     case SkRegion::kIntersect_Op: return "kIntersect_Op";
     case SkRegion::kUnion_Op: return "kUnion_Op";
     case SkRegion::kXOR_Op: return "kXOR_Op";
     case SkRegion::kReverseDifference_Op: return "kReverseDifference_Op";
@@ skipping 44 matching lines @@
         return "?";
     }
 }
 
 } // namespace
 
 class AutoLogger : InterceptingCanvasBase::CanvasInterceptorBase<LoggingCanvas> {
 public:
     explicit AutoLogger(LoggingCanvas* canvas) : InterceptingCanvasBase::CanvasInterceptorBase<LoggingCanvas>(canvas) { }
 
-    PassRefPtr<JSONObject> logItem(const String& name);
-    PassRefPtr<JSONObject> logItemWithParams(const String& name);
+    JSONObject* logItem(const String& name);
+    JSONObject* logItemWithParams(const String& name);
     ~AutoLogger()
     {
         if (topLevelCall())
-            canvas()->m_log->pushObject(m_logItem);
+            canvas()->m_log->pushObject(std::move(m_logItem));
     }
 
 private:
-    RefPtr<JSONObject> m_logItem;
+    std::unique_ptr<JSONObject> m_logItem;
 };
 
-PassRefPtr<JSONObject> AutoLogger::logItem(const String& name)
+JSONObject* AutoLogger::logItem(const String& name)
 {
-    RefPtr<JSONObject> item = JSONObject::create();
+    std::unique_ptr<JSONObject> item = JSONObject::create();
     item->setString("method", name);
-    m_logItem = item;
-    return item.release();
+    m_logItem = std::move(item);
+    return m_logItem.get();
 }
 
-PassRefPtr<JSONObject> AutoLogger::logItemWithParams(const String& name)
+JSONObject* AutoLogger::logItemWithParams(const String& name)
 {
-    RefPtr<JSONObject> item = logItem(name);
-    RefPtr<JSONObject> params = JSONObject::create();
-    item->setObject("params", params);
-    return params.release();
+    JSONObject* item = logItem(name);
+    std::unique_ptr<JSONObject> params = JSONObject::create();
+    item->setObject("params", std::move(params));
+    return item->getObject("params");
 }
 
 LoggingCanvas::LoggingCanvas(int width, int height)
     : InterceptingCanvasBase(width, height)
     , m_log(JSONArray::create())
 {
 }
 
 void LoggingCanvas::onDrawPaint(const SkPaint& paint)
 {
     AutoLogger logger(this);
     logger.logItemWithParams("drawPaint")->setObject("paint", objectForSkPaint(paint));
     this->SkCanvas::onDrawPaint(paint);
 }
 
 void LoggingCanvas::onDrawPoints(PointMode mode, size_t count, const SkPoint pts[], const SkPaint& paint)
 {
     AutoLogger logger(this);
-    RefPtr<JSONObject> params = logger.logItemWithParams("drawPoints");
+    JSONObject* params = logger.logItemWithParams("drawPoints");
     params->setString("pointMode", pointModeName(mode));
     params->setArray("points", arrayForSkPoints(count, pts));
     params->setObject("paint", objectForSkPaint(paint));
     this->SkCanvas::onDrawPoints(mode, count, pts, paint);
 }
 
 void LoggingCanvas::onDrawRect(const SkRect& rect, const SkPaint& paint)
 {
     AutoLogger logger(this);
-    RefPtr<JSONObject> params = logger.logItemWithParams("drawRect");
+    JSONObject* params = logger.logItemWithParams("drawRect");
     params->setObject("rect", objectForSkRect(rect));
     params->setObject("paint", objectForSkPaint(paint));
     this->SkCanvas::onDrawRect(rect, paint);
 }
 
 void LoggingCanvas::onDrawOval(const SkRect& oval, const SkPaint& paint)
 {
     AutoLogger logger(this);
-    RefPtr<JSONObject> params = logger.logItemWithParams("drawOval");
+    JSONObject* params = logger.logItemWithParams("drawOval");
     params->setObject("oval", objectForSkRect(oval));
     params->setObject("paint", objectForSkPaint(paint));
     this->SkCanvas::onDrawOval(oval, paint);
 }
 
 void LoggingCanvas::onDrawRRect(const SkRRect& rrect, const SkPaint& paint)
 {
     AutoLogger logger(this);
-    RefPtr<JSONObject> params = logger.logItemWithParams("drawRRect");
+    JSONObject* params = logger.logItemWithParams("drawRRect");
     params->setObject("rrect", objectForSkRRect(rrect));
     params->setObject("paint", objectForSkPaint(paint));
     this->SkCanvas::onDrawRRect(rrect, paint);
 }
 
 void LoggingCanvas::onDrawPath(const SkPath& path, const SkPaint& paint)
 {
     AutoLogger logger(this);
-    RefPtr<JSONObject> params = logger.logItemWithParams("drawPath");
+    JSONObject* params = logger.logItemWithParams("drawPath");
     params->setObject("path", objectForSkPath(path));
     params->setObject("paint", objectForSkPaint(paint));
     this->SkCanvas::onDrawPath(path, paint);
 }
 
 void LoggingCanvas::onDrawBitmap(const SkBitmap& bitmap, SkScalar left, SkScalar top, const SkPaint* paint)
 {
     AutoLogger logger(this);
-    RefPtr<JSONObject> params = logger.logItemWithParams("drawBitmap");
-    params->setNumber("left", left);
-    params->setNumber("top", top);
+    JSONObject* params = logger.logItemWithParams("drawBitmap");
+    params->setDouble("left", left);
+    params->setDouble("top", top);
     params->setObject("bitmap", objectForSkBitmap(bitmap));
     if (paint)
         params->setObject("paint", objectForSkPaint(*paint));
     this->SkCanvas::onDrawBitmap(bitmap, left, top, paint);
 }
 
 void LoggingCanvas::onDrawBitmapRect(const SkBitmap& bitmap, const SkRect* src, const SkRect& dst, const SkPaint* paint, SrcRectConstraint constraint)
 {
     AutoLogger logger(this);
-    RefPtr<JSONObject> params = logger.logItemWithParams("drawBitmapRectToRect");
+    JSONObject* params = logger.logItemWithParams("drawBitmapRectToRect");
     params->setObject("bitmap", objectForSkBitmap(bitmap));
     if (src)
         params->setObject("src", objectForSkRect(*src));
     params->setObject("dst", objectForSkRect(dst));
     if (paint)
         params->setObject("paint", objectForSkPaint(*paint));
-    params->setNumber("flags", constraint);
+    params->setInteger("flags", constraint);
     this->SkCanvas::onDrawBitmapRect(bitmap, src, dst, paint, constraint);
 }
 
 void LoggingCanvas::onDrawBitmapNine(const SkBitmap& bitmap, const SkIRect& center, const SkRect& dst, const SkPaint* paint)
 {
     AutoLogger logger(this);
-    RefPtr<JSONObject> params = logger.logItemWithParams("drawBitmapNine");
+    JSONObject* params = logger.logItemWithParams("drawBitmapNine");
     params->setObject("bitmap", objectForSkBitmap(bitmap));
     params->setObject("center", objectForSkIRect(center));
     params->setObject("dst", objectForSkRect(dst));
     if (paint)
         params->setObject("paint", objectForSkPaint(*paint));
     this->SkCanvas::onDrawBitmapNine(bitmap, center, dst, paint);
 }
 
 void LoggingCanvas::onDrawImage(const SkImage* image, SkScalar left, SkScalar top, const SkPaint* paint)
 {
     AutoLogger logger(this);
-    RefPtr<JSONObject> params = logger.logItemWithParams("drawImage");
-    params->setNumber("left", left);
-    params->setNumber("top", top);
+    JSONObject* params = logger.logItemWithParams("drawImage");
+    params->setDouble("left", left);
+    params->setDouble("top", top);
     params->setObject("image", objectForSkImage(image));
     if (paint)
         params->setObject("paint", objectForSkPaint(*paint));
     this->SkCanvas::onDrawImage(image, left, top, paint);
 }
 
 void LoggingCanvas::onDrawImageRect(const SkImage* image, const SkRect* src, const SkRect& dst, const SkPaint* paint, SrcRectConstraint constraint)
 {
     AutoLogger logger(this);
-    RefPtr<JSONObject> params = logger.logItemWithParams("drawImageRect");
+    JSONObject* params = logger.logItemWithParams("drawImageRect");
     params->setObject("image", objectForSkImage(image));
     if (src)
         params->setObject("src", objectForSkRect(*src));
     params->setObject("dst", objectForSkRect(dst));
     if (paint)
         params->setObject("paint", objectForSkPaint(*paint));
     this->SkCanvas::onDrawImageRect(image, src, dst, paint, constraint);
 }
 
 void LoggingCanvas::onDrawVertices(VertexMode vmode, int vertexCount, const SkPoint vertices[], const SkPoint texs[], const SkColor colors[], SkXfermode* xmode,
     const uint16_t indices[], int indexCount, const SkPaint& paint)
 {
     AutoLogger logger(this);
-    RefPtr<JSONObject> params = logger.logItemWithParams("drawVertices");
+    JSONObject* params = logger.logItemWithParams("drawVertices");
     params->setObject("paint", objectForSkPaint(paint));
     this->SkCanvas::onDrawVertices(vmode, vertexCount, vertices, texs, colors, xmode, indices, indexCount, paint);
 }
 
 void LoggingCanvas::onDrawDRRect(const SkRRect& outer, const SkRRect& inner, const SkPaint& paint)
 {
     AutoLogger logger(this);
-    RefPtr<JSONObject> params = logger.logItemWithParams("drawDRRect");
+    JSONObject* params = logger.logItemWithParams("drawDRRect");
     params->setObject("outer", objectForSkRRect(outer));
     params->setObject("inner", objectForSkRRect(inner));
     params->setObject("paint", objectForSkPaint(paint));
     this->SkCanvas::onDrawDRRect(outer, inner, paint);
 }
 
 void LoggingCanvas::onDrawText(const void* text, size_t byteLength, SkScalar x, SkScalar y, const SkPaint& paint)
 {
     AutoLogger logger(this);
-    RefPtr<JSONObject> params = logger.logItemWithParams("drawText");
+    JSONObject* params = logger.logItemWithParams("drawText");
     params->setString("text", stringForText(text, byteLength, paint));
-    params->setNumber("x", x);
-    params->setNumber("y", y);
+    params->setDouble("x", x);
+    params->setDouble("y", y);
     params->setObject("paint", objectForSkPaint(paint));
     this->SkCanvas::onDrawText(text, byteLength, x, y, paint);
 }
 
 void LoggingCanvas::onDrawPosText(const void* text, size_t byteLength, const SkPoint pos[], const SkPaint& paint)
 {
     AutoLogger logger(this);
-    RefPtr<JSONObject> params = logger.logItemWithParams("drawPosText");
+    JSONObject* params = logger.logItemWithParams("drawPosText");
     params->setString("text", stringForText(text, byteLength, paint));
     size_t pointsCount = paint.countText(text, byteLength);
     params->setArray("pos", arrayForSkPoints(pointsCount, pos));
     params->setObject("paint", objectForSkPaint(paint));
     this->SkCanvas::onDrawPosText(text, byteLength, pos, paint);
 }
 
 void LoggingCanvas::onDrawPosTextH(const void* text, size_t byteLength, const SkScalar xpos[], SkScalar constY, const SkPaint& paint)
 {
     AutoLogger logger(this);
-    RefPtr<JSONObject> params = logger.logItemWithParams("drawPosTextH");
+    JSONObject* params = logger.logItemWithParams("drawPosTextH");
     params->setString("text", stringForText(text, byteLength, paint));
     size_t pointsCount = paint.countText(text, byteLength);
     params->setArray("xpos", arrayForSkScalars(pointsCount, xpos));
-    params->setNumber("constY", constY);
+    params->setDouble("constY", constY);
     params->setObject("paint", objectForSkPaint(paint));
     this->SkCanvas::onDrawPosTextH(text, byteLength, xpos, constY, paint);
 }
 
 void LoggingCanvas::onDrawTextOnPath(const void* text, size_t byteLength, const SkPath& path, const SkMatrix* matrix, const SkPaint& paint)
 {
     AutoLogger logger(this);
-    RefPtr<JSONObject> params = logger.logItemWithParams("drawTextOnPath");
+    JSONObject* params = logger.logItemWithParams("drawTextOnPath");
     params->setString("text", stringForText(text, byteLength, paint));
     params->setObject("path", objectForSkPath(path));
     if (matrix)
         params->setArray("matrix", arrayForSkMatrix(*matrix));
     params->setObject("paint", objectForSkPaint(paint));
     this->SkCanvas::onDrawTextOnPath(text, byteLength, path, matrix, paint);
 }
 
 void LoggingCanvas::onDrawTextBlob(const SkTextBlob *blob, SkScalar x, SkScalar y, const SkPaint &paint)
 {
     AutoLogger logger(this);
-    RefPtr<JSONObject> params = logger.logItemWithParams("drawTextBlob");
-    params->setNumber("x", x);
-    params->setNumber("y", y);
+    JSONObject* params = logger.logItemWithParams("drawTextBlob");
+    params->setDouble("x", x);
+    params->setDouble("y", y);
     params->setObject("paint", objectForSkPaint(paint));
     this->SkCanvas::onDrawTextBlob(blob, x, y, paint);
 }
 
 void LoggingCanvas::onClipRect(const SkRect& rect, SkRegion::Op op, ClipEdgeStyle style)
 {
     AutoLogger logger(this);
-    RefPtr<JSONObject> params = logger.logItemWithParams("clipRect");
+    JSONObject* params = logger.logItemWithParams("clipRect");
     params->setObject("rect", objectForSkRect(rect));
     params->setString("SkRegion::Op", regionOpName(op));
     params->setBoolean("softClipEdgeStyle", kSoft_ClipEdgeStyle == style);
     this->SkCanvas::onClipRect(rect, op, style);
 }
 
 void LoggingCanvas::onClipRRect(const SkRRect& rrect, SkRegion::Op op, ClipEdgeStyle style)
 {
     AutoLogger logger(this);
-    RefPtr<JSONObject> params = logger.logItemWithParams("clipRRect");
+    JSONObject* params = logger.logItemWithParams("clipRRect");
     params->setObject("rrect", objectForSkRRect(rrect));
     params->setString("SkRegion::Op", regionOpName(op));
     params->setBoolean("softClipEdgeStyle", kSoft_ClipEdgeStyle == style);
     this->SkCanvas::onClipRRect(rrect, op, style);
 }
 
 void LoggingCanvas::onClipPath(const SkPath& path, SkRegion::Op op, ClipEdgeStyle style)
 {
     AutoLogger logger(this);
-    RefPtr<JSONObject> params = logger.logItemWithParams("clipPath");
+    JSONObject* params = logger.logItemWithParams("clipPath");
     params->setObject("path", objectForSkPath(path));
     params->setString("SkRegion::Op", regionOpName(op));
     params->setBoolean("softClipEdgeStyle", kSoft_ClipEdgeStyle == style);
     this->SkCanvas::onClipPath(path, op, style);
 }
 
 void LoggingCanvas::onClipRegion(const SkRegion& region, SkRegion::Op op)
 {
     AutoLogger logger(this);
-    RefPtr<JSONObject> params = logger.logItemWithParams("clipRegion");
+    JSONObject* params = logger.logItemWithParams("clipRegion");
     params->setString("op", regionOpName(op));
     this->SkCanvas::onClipRegion(region, op);
 }
 
 void LoggingCanvas::onDrawPicture(const SkPicture* picture, const SkMatrix* matrix, const SkPaint* paint)
 {
     this->unrollDrawPicture(picture, matrix, paint, nullptr);
 }
 
 void LoggingCanvas::didSetMatrix(const SkMatrix& matrix)
 {
     AutoLogger logger(this);
-    RefPtr<JSONObject> params = logger.logItemWithParams("setMatrix");
+    JSONObject* params = logger.logItemWithParams("setMatrix");
     params->setArray("matrix", arrayForSkMatrix(matrix));
     this->SkCanvas::didSetMatrix(matrix);
 }
 
 void LoggingCanvas::didConcat(const SkMatrix& matrix)
 {
     AutoLogger logger(this);
-    RefPtr<JSONObject> params;
+    JSONObject* params;
 
     switch (matrix.getType()) {
     case SkMatrix::kTranslate_Mask:
         params = logger.logItemWithParams("translate");
-        params->setNumber("dx", matrix.getTranslateX());
-        params->setNumber("dy", matrix.getTranslateY());
+        params->setDouble("dx", matrix.getTranslateX());
+        params->setDouble("dy", matrix.getTranslateY());
         break;
 
     case SkMatrix::kScale_Mask:
         params = logger.logItemWithParams("scale");
-        params->setNumber("scaleX", matrix.getScaleX());
-        params->setNumber("scaleY", matrix.getScaleY());
+        params->setDouble("scaleX", matrix.getScaleX());
+        params->setDouble("scaleY", matrix.getScaleY());
         break;
 
     default:
         params = logger.logItemWithParams("concat");
         params->setArray("matrix", arrayForSkMatrix(matrix));
     }
     this->SkCanvas::didConcat(matrix);
 }
 
 void LoggingCanvas::willSave()
 {
     AutoLogger logger(this);
-    RefPtr<JSONObject> params = logger.logItem("save");
+    logger.logItem("save");
     this->SkCanvas::willSave();
 }
 
 SkCanvas::SaveLayerStrategy LoggingCanvas::getSaveLayerStrategy(const SaveLayerRec& rec)
 {
     AutoLogger logger(this);
-    RefPtr<JSONObject> params = logger.logItemWithParams("saveLayer");
+    JSONObject* params = logger.logItemWithParams("saveLayer");
     if (rec.fBounds)
         params->setObject("bounds", objectForSkRect(*rec.fBounds));
     if (rec.fPaint)
         params->setObject("paint", objectForSkPaint(*rec.fPaint));
     params->setString("saveFlags", saveLayerFlagsToString(rec.fSaveLayerFlags));
     return this->SkCanvas::getSaveLayerStrategy(rec);
 }
 
 void LoggingCanvas::willRestore()
 {
     AutoLogger logger(this);
     logger.logItem("restore");
     this->SkCanvas::willRestore();
 }
 
-PassRefPtr<JSONArray> LoggingCanvas::log()
+std::unique_ptr<JSONArray> LoggingCanvas::log()
 {
-    return m_log;
+    return JSONArray::cast(m_log->clone());
 }
 
 #ifndef NDEBUG
 String pictureAsDebugString(const SkPicture* picture)
 {
     const SkIRect bounds = picture->cullRect().roundOut();
     LoggingCanvas canvas(bounds.width(), bounds.height());
     picture->playback(&canvas);
-    RefPtr<JSONObject> pictureAsJSON = JSONObject::create();
+    std::unique_ptr<JSONObject> pictureAsJSON = JSONObject::create();
     pictureAsJSON->setObject("cullRect", objectForSkRect(picture->cullRect()));
     pictureAsJSON->setArray("operations", canvas.log());
-    RefPtr<JSONArray> operationsInJson = canvas.log();
     return pictureAsJSON->toPrettyJSONString();
 }
 
 void showSkPicture(const SkPicture* picture)
 {
     WTFLogAlways("%s\n", pictureAsDebugString(picture).utf8().data());
 }
 #endif
 
 } // namespace blink