Prototype code that turns any/every flattenable into JSON

tools/debugger/SkDrawCommand.cpp

 /*
  * Copyright 2012 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 
 #include "SkDrawCommand.h"
 
 #include "SkBlurMaskFilter.h"
 #include "SkColorFilter.h"
 #include "SkDashPathEffect.h"
 #include "SkImageFilter.h"
+#include "SkJsonWriteBuffer.h"
 #include "SkMaskFilter.h"
 #include "SkObjectParser.h"
 #include "SkPaintDefaults.h"
 #include "SkPathEffect.h"
 #include "SkPicture.h"
 #include "SkTextBlob.h"
 #include "SkTextBlobRunIterator.h"
 #include "SkTHash.h"
 #include "SkTypeface.h"
 #include "SkValidatingReadBuffer.h"
@@ skipping 31 matching lines @@
 #define SKDEBUGCANVAS_ATTRIBUTE_TEXTSIZE          "textSize"
 #define SKDEBUGCANVAS_ATTRIBUTE_TEXTSCALEX        "textScaleX"
 #define SKDEBUGCANVAS_ATTRIBUTE_TEXTSKEWX         "textSkewX"
 #define SKDEBUGCANVAS_ATTRIBUTE_DASHING           "dashing"
 #define SKDEBUGCANVAS_ATTRIBUTE_INTERVALS         "intervals"
 #define SKDEBUGCANVAS_ATTRIBUTE_PHASE             "phase"
 #define SKDEBUGCANVAS_ATTRIBUTE_FILLTYPE          "fillType"
 #define SKDEBUGCANVAS_ATTRIBUTE_VERBS             "verbs"
 #define SKDEBUGCANVAS_ATTRIBUTE_NAME              "name"
 #define SKDEBUGCANVAS_ATTRIBUTE_DATA              "data"
+#define SKDEBUGCANVAS_ATTRIBUTE_VALUES            "values"
 #define SKDEBUGCANVAS_ATTRIBUTE_SHADER            "shader"
 #define SKDEBUGCANVAS_ATTRIBUTE_PATHEFFECT        "pathEffect"
 #define SKDEBUGCANVAS_ATTRIBUTE_MASKFILTER        "maskFilter"
 #define SKDEBUGCANVAS_ATTRIBUTE_XFERMODE          "xfermode"
 #define SKDEBUGCANVAS_ATTRIBUTE_LOOPER            "looper"
 #define SKDEBUGCANVAS_ATTRIBUTE_BACKDROP          "backdrop"
 #define SKDEBUGCANVAS_ATTRIBUTE_COLORFILTER       "colorfilter"
 #define SKDEBUGCANVAS_ATTRIBUTE_IMAGEFILTER       "imagefilter"
 #define SKDEBUGCANVAS_ATTRIBUTE_IMAGE             "image"
 #define SKDEBUGCANVAS_ATTRIBUTE_BITMAP            "bitmap"
@@ skipping 303 matching lines @@
     SkPaint p;
     p.setColor(SK_ColorBLACK);
     p.setStyle(SkPaint::kStroke_Style);
 
     canvas->drawDRRect(outer, inner, p);
     canvas->restore();
 }
 
 };
 
-static Json::Value make_json_color(const SkColor color) {
+Json::Value SkDrawCommand::MakeJsonColor(const SkColor color) {
     Json::Value result(Json::arrayValue);
     result.append(Json::Value(SkColorGetA(color)));
     result.append(Json::Value(SkColorGetR(color)));
     result.append(Json::Value(SkColorGetG(color)));
     result.append(Json::Value(SkColorGetB(color)));
     return result;
 }
 
-
-static Json::Value make_json_point(const SkPoint& point) {
+Json::Value SkDrawCommand::MakeJsonPoint(const SkPoint& point) {
     Json::Value result(Json::arrayValue);
     result.append(Json::Value(point.x()));
     result.append(Json::Value(point.y()));
     return result;
 }
 
-static Json::Value make_json_point(SkScalar x, SkScalar y) {
+Json::Value SkDrawCommand::MakeJsonPoint(SkScalar x, SkScalar y) {
     Json::Value result(Json::arrayValue);
     result.append(Json::Value(x));
     result.append(Json::Value(y));
     return result;
 }
 
-static Json::Value make_json_rect(const SkRect& rect) {
+Json::Value SkDrawCommand::MakeJsonRect(const SkRect& rect) {
     Json::Value result(Json::arrayValue);
     result.append(Json::Value(rect.left()));
     result.append(Json::Value(rect.top()));
     result.append(Json::Value(rect.right()));
     result.append(Json::Value(rect.bottom()));
     return result;
 }
 
 Json::Value SkDrawCommand::MakeJsonIRect(const SkIRect& rect) {
     Json::Value result(Json::arrayValue);
     result.append(Json::Value(rect.left()));
     result.append(Json::Value(rect.top()));
     result.append(Json::Value(rect.right()));
     result.append(Json::Value(rect.bottom()));
     return result;
 }
 
 static Json::Value make_json_rrect(const SkRRect& rrect) {
     Json::Value result(Json::arrayValue);
-    result.append(make_json_rect(rrect.rect()));
-    result.append(make_json_point(rrect.radii(SkRRect::kUpperLeft_Corner)));
-    result.append(make_json_point(rrect.radii(SkRRect::kUpperRight_Corner)));
-    result.append(make_json_point(rrect.radii(SkRRect::kLowerRight_Corner)));
-    result.append(make_json_point(rrect.radii(SkRRect::kLowerLeft_Corner)));
+    result.append(SkDrawCommand::MakeJsonRect(rrect.rect()));
+    result.append(SkDrawCommand::MakeJsonPoint(rrect.radii(SkRRect::kUpperLeft_Corner)));
+    result.append(SkDrawCommand::MakeJsonPoint(rrect.radii(SkRRect::kUpperRight_Corner)));
+    result.append(SkDrawCommand::MakeJsonPoint(rrect.radii(SkRRect::kLowerRight_Corner)));
+    result.append(SkDrawCommand::MakeJsonPoint(rrect.radii(SkRRect::kLowerLeft_Corner)));
     return result;
 }
 
 Json::Value SkDrawCommand::MakeJsonMatrix(const SkMatrix& matrix) {
     Json::Value result(Json::arrayValue);
     Json::Value row1(Json::arrayValue);
     row1.append(Json::Value(matrix[0]));
     row1.append(Json::Value(matrix[1]));
     row1.append(Json::Value(matrix[2]));
     result.append(row1);
     Json::Value row2(Json::arrayValue);
     row2.append(Json::Value(matrix[3]));
     row2.append(Json::Value(matrix[4]));
     row2.append(Json::Value(matrix[5]));
     result.append(row2);
     Json::Value row3(Json::arrayValue);
     row3.append(Json::Value(matrix[6]));
     row3.append(Json::Value(matrix[7]));
     row3.append(Json::Value(matrix[8]));
     result.append(row3);
     return result;
 }
 
-static Json::Value make_json_path(const SkPath& path) {
+Json::Value SkDrawCommand::MakeJsonPath(const SkPath& path) {
     Json::Value result(Json::objectValue);
     switch (path.getFillType()) {
         case SkPath::kWinding_FillType:
             result[SKDEBUGCANVAS_ATTRIBUTE_FILLTYPE] = SKDEBUGCANVAS_FILLTYPE_WINDING;
             break;
         case SkPath::kEvenOdd_FillType:
             result[SKDEBUGCANVAS_ATTRIBUTE_FILLTYPE] = SKDEBUGCANVAS_FILLTYPE_EVENODD;
             break;
         case SkPath::kInverseWinding_FillType:
             result[SKDEBUGCANVAS_ATTRIBUTE_FILLTYPE] = SKDEBUGCANVAS_FILLTYPE_INVERSEWINDING;
             break;
         case SkPath::kInverseEvenOdd_FillType:
             result[SKDEBUGCANVAS_ATTRIBUTE_FILLTYPE] = SKDEBUGCANVAS_FILLTYPE_INVERSEEVENODD;
             break;
     }
     Json::Value verbs(Json::arrayValue);
     SkPath::Iter iter(path, false);
     SkPoint pts[4];
     SkPath::Verb verb;
     while ((verb = iter.next(pts)) != SkPath::kDone_Verb) {
         switch (verb) {
             case SkPath::kLine_Verb: {
                 Json::Value line(Json::objectValue);
-                line[SKDEBUGCANVAS_VERB_LINE] = make_json_point(pts[1]);
+                line[SKDEBUGCANVAS_VERB_LINE] = MakeJsonPoint(pts[1]);
                 verbs.append(line);
                 break;
             }
             case SkPath::kQuad_Verb: {
                 Json::Value quad(Json::objectValue);
                 Json::Value coords(Json::arrayValue);
-                coords.append(make_json_point(pts[1]));
-                coords.append(make_json_point(pts[2]));
+                coords.append(MakeJsonPoint(pts[1]));
+                coords.append(MakeJsonPoint(pts[2]));
                 quad[SKDEBUGCANVAS_VERB_QUAD] = coords;
                 verbs.append(quad);
                 break;
             }
             case SkPath::kCubic_Verb: {
                 Json::Value cubic(Json::objectValue);
                 Json::Value coords(Json::arrayValue);
-                coords.append(make_json_point(pts[1]));
-                coords.append(make_json_point(pts[2]));
-                coords.append(make_json_point(pts[3]));
+                coords.append(MakeJsonPoint(pts[1]));
+                coords.append(MakeJsonPoint(pts[2]));
+                coords.append(MakeJsonPoint(pts[3]));
                 cubic[SKDEBUGCANVAS_VERB_CUBIC] = coords;
                 verbs.append(cubic);
                 break;
             }
             case SkPath::kConic_Verb: {
                 Json::Value conic(Json::objectValue);
                 Json::Value coords(Json::arrayValue);
-                coords.append(make_json_point(pts[1]));
-                coords.append(make_json_point(pts[2]));
+                coords.append(MakeJsonPoint(pts[1]));
+                coords.append(MakeJsonPoint(pts[2]));
                 coords.append(Json::Value(iter.conicWeight()));
                 conic[SKDEBUGCANVAS_VERB_CONIC] = coords;
                 verbs.append(conic);
                 break;
             }
             case SkPath::kMove_Verb: {
                 Json::Value move(Json::objectValue);
-                move[SKDEBUGCANVAS_VERB_MOVE] = make_json_point(pts[0]);
+                move[SKDEBUGCANVAS_VERB_MOVE] = MakeJsonPoint(pts[0]);
                 verbs.append(move);
                 break;
             }
             case SkPath::kClose_Verb:
                 verbs.append(Json::Value(SKDEBUGCANVAS_VERB_CLOSE));
                 break;
             case SkPath::kDone_Verb:
                 break;
         }
     }
     result[SKDEBUGCANVAS_ATTRIBUTE_VERBS] = verbs;
     return result;
 }
 
-static Json::Value make_json_region(const SkRegion& region) {
+Json::Value SkDrawCommand::MakeJsonRegion(const SkRegion& region) {
     return Json::Value("<unimplemented>");
 }
 
 static Json::Value make_json_regionop(SkRegion::Op op) {
     switch (op) {
         case SkRegion::kDifference_Op:
             return Json::Value(SKDEBUGCANVAS_REGIONOP_DIFFERENCE);
         case SkRegion::kIntersect_Op:
             return Json::Value(SKDEBUGCANVAS_REGIONOP_INTERSECT);
         case SkRegion::kUnion_Op:
@@ skipping 37 matching lines @@
     }
 }
 
 static void encode_data(const void* bytes, size_t count, const char* contentType,
                         UrlDataManager& urlDataManager, Json::Value* target) {
     SkAutoTUnref<SkData> data(SkData::NewWithCopy(bytes, count));
     SkString url = urlDataManager.addData(data, contentType);
     *target = Json::Value(url.c_str());
 }
 
-static void flatten(const SkFlattenable* flattenable, Json::Value* target,
-                    UrlDataManager& urlDataManager) {
-    SkWriteBuffer buffer;
+void SkDrawCommand::flatten(const SkFlattenable* flattenable, Json::Value* target,
+                            UrlDataManager& urlDataManager) {
+    SkBinaryWriteBuffer buffer;
     flattenable->flatten(buffer);
     void* data = sk_malloc_throw(buffer.bytesWritten());
     buffer.writeToMemory(data);
     Json::Value jsonData;
     encode_data(data, buffer.bytesWritten(), "application/octet-stream", urlDataManager, &jsonData);
     Json::Value jsonFlattenable;
     jsonFlattenable[SKDEBUGCANVAS_ATTRIBUTE_NAME] = Json::Value(flattenable->getTypeName());
     jsonFlattenable[SKDEBUGCANVAS_ATTRIBUTE_DATA] = jsonData;
+
+    SkJsonWriteBuffer jsonBuffer(&urlDataManager);
+    flattenable->flatten(jsonBuffer);
+    jsonFlattenable[SKDEBUGCANVAS_ATTRIBUTE_VALUES] = jsonBuffer.getValue();
+
     (*target) = jsonFlattenable;
     sk_free(data);
 }
 
 static void write_png_callback(png_structp png_ptr, png_bytep data, png_size_t length) {
     SkWStream* out = (SkWStream*) png_get_io_ptr(png_ptr);
     out->write(data, length);
 }
 
 void SkDrawCommand::WritePNG(const png_bytep rgba, png_uint_32 width, png_uint_32 height,
@@ skipping 22 matching lines @@
     }
     png_set_filter(png, 0, PNG_NO_FILTERS);
     png_set_rows(png, info_ptr, &rows[0]);
     png_set_write_fn(png, &out, write_png_callback, NULL);
     png_write_png(png, info_ptr, PNG_TRANSFORM_IDENTITY, NULL);
     png_destroy_write_struct(&png, NULL);
     sk_free(rows);
     sk_free(pixels);
 }
 
-static bool SK_WARN_UNUSED_RESULT flatten(const SkImage& image, Json::Value* target,
-                                          UrlDataManager& urlDataManager) {
+bool SkDrawCommand::flatten(const SkImage& image, Json::Value* target,
+                            UrlDataManager& urlDataManager) {
     size_t rowBytes = 4 * image.width();
     SkAutoFree buffer(sk_malloc_throw(rowBytes * image.height()));
     SkImageInfo dstInfo = SkImageInfo::Make(image.width(), image.height(),
                                             kN32_SkColorType, kPremul_SkAlphaType);
     if (!image.readPixels(dstInfo, buffer.get(), rowBytes, 0, 0)) {
         SkDebugf("readPixels failed\n");
         return false;
     }
     SkDynamicMemoryWStream out;
     SkDrawCommand::WritePNG((png_bytep) buffer.get(), image.width(), image.height(), out);
@@ skipping 150 matching lines @@
 static sk_sp<SkImage> load_image(const Json::Value& jsonImage, UrlDataManager& urlDataManager) {
     SkBitmap* bitmap = load_bitmap(jsonImage, urlDataManager);
     if (bitmap == nullptr) {
         return nullptr;
     }
     auto result = SkImage::MakeFromBitmap(*bitmap);
     delete bitmap;
     return result;
 }
 
-static bool SK_WARN_UNUSED_RESULT flatten(const SkBitmap& bitmap, Json::Value* target,
-                                          UrlDataManager& urlDataManager) {
+bool SkDrawCommand::flatten(const SkBitmap& bitmap, Json::Value* target,
+                            UrlDataManager& urlDataManager) {
     bitmap.lockPixels();
     sk_sp<SkImage> image(SkImage::MakeFromBitmap(bitmap));
     bitmap.unlockPixels();
     (*target)[SKDEBUGCANVAS_ATTRIBUTE_COLOR] = Json::Value(color_type_name(bitmap.colorType()));
     (*target)[SKDEBUGCANVAS_ATTRIBUTE_ALPHA] = Json::Value(alpha_type_name(bitmap.alphaType()));
     bool success = flatten(*image, target, urlDataManager);
     return success;
 }
 
 static void apply_paint_color(const SkPaint& paint, Json::Value* target) {
@@ skipping 122 matching lines @@
                 case SkBlurQuality::kHigh_SkBlurQuality:
                     blur[SKDEBUGCANVAS_ATTRIBUTE_QUALITY] = Json::Value(
                                                                     SKDEBUGCANVAS_BLURQUALITY_HIGH);
                     break;
                 default:
                     SkASSERT(false);
             }
             (*target)[SKDEBUGCANVAS_ATTRIBUTE_BLUR] = blur;
         } else {
             Json::Value jsonMaskFilter;
-            flatten(maskFilter, &jsonMaskFilter, urlDataManager);
+            SkDrawCommand::flatten(maskFilter, &jsonMaskFilter, urlDataManager);
             (*target)[SKDEBUGCANVAS_ATTRIBUTE_MASKFILTER] = jsonMaskFilter;
         }
     }
 }
 
 static void apply_paint_patheffect(const SkPaint& paint, Json::Value* target,
                                    UrlDataManager& urlDataManager) {
     SkPathEffect* pathEffect = paint.getPathEffect();
     if (pathEffect != nullptr) {
         SkPathEffect::DashInfo dashInfo;
         SkPathEffect::DashType dashType = pathEffect->asADash(&dashInfo);
         if (dashType == SkPathEffect::kDash_DashType) {
             dashInfo.fIntervals = (SkScalar*) sk_malloc_throw(dashInfo.fCount * sizeof(SkScalar));
             pathEffect->asADash(&dashInfo);
             Json::Value dashing(Json::objectValue);
             Json::Value intervals(Json::arrayValue);
             for (int32_t i = 0; i < dashInfo.fCount; i++) {
                 intervals.append(Json::Value(dashInfo.fIntervals[i]));
             }
             sk_free(dashInfo.fIntervals);
             dashing[SKDEBUGCANVAS_ATTRIBUTE_INTERVALS] = intervals;
             dashing[SKDEBUGCANVAS_ATTRIBUTE_PHASE] = dashInfo.fPhase;
             (*target)[SKDEBUGCANVAS_ATTRIBUTE_DASHING] = dashing;
         } else {
             Json::Value jsonPathEffect;
-            flatten(pathEffect, &jsonPathEffect, urlDataManager);
+            SkDrawCommand::flatten(pathEffect, &jsonPathEffect, urlDataManager);
             (*target)[SKDEBUGCANVAS_ATTRIBUTE_PATHEFFECT] = jsonPathEffect;
         }
     }
 }
 
 static void apply_paint_textalign(const SkPaint& paint, Json::Value* target) {
     SkPaint::Align textAlign = paint.getTextAlign();
     if (textAlign != SkPaint::kLeft_Align) {
         switch (textAlign) {
             case SkPaint::kCenter_Align: {
@@ skipping 25 matching lines @@
         sk_free(data);
         (*target)[SKDEBUGCANVAS_ATTRIBUTE_TYPEFACE] = jsonTypeface;
     }
 }
 
 static void apply_paint_shader(const SkPaint& paint, Json::Value* target,
                                UrlDataManager& urlDataManager) {
     SkFlattenable* shader = paint.getShader();
     if (shader != nullptr) {
         Json::Value jsonShader;
-        flatten(shader, &jsonShader, urlDataManager);
+        SkDrawCommand::flatten(shader, &jsonShader, urlDataManager);
         (*target)[SKDEBUGCANVAS_ATTRIBUTE_SHADER] = jsonShader;
     }
 }
 
 static void apply_paint_xfermode(const SkPaint& paint, Json::Value* target,
                                  UrlDataManager& urlDataManager) {
     SkFlattenable* xfermode = paint.getXfermode();
     if (xfermode != nullptr) {
         Json::Value jsonXfermode;
-        flatten(xfermode, &jsonXfermode, urlDataManager);
+        SkDrawCommand::flatten(xfermode, &jsonXfermode, urlDataManager);
         (*target)[SKDEBUGCANVAS_ATTRIBUTE_XFERMODE] = jsonXfermode;
     }
 }
 
 static void apply_paint_imagefilter(const SkPaint& paint, Json::Value* target,
                                     UrlDataManager& urlDataManager) {
     SkFlattenable* imageFilter = paint.getImageFilter();
     if (imageFilter != nullptr) {
         Json::Value jsonImageFilter;
-        flatten(imageFilter, &jsonImageFilter, urlDataManager);
+        SkDrawCommand::flatten(imageFilter, &jsonImageFilter, urlDataManager);
         (*target)[SKDEBUGCANVAS_ATTRIBUTE_IMAGEFILTER] = jsonImageFilter;
     }
 }
 
 static void apply_paint_colorfilter(const SkPaint& paint, Json::Value* target,
                                     UrlDataManager& urlDataManager) {
     SkFlattenable* colorFilter = paint.getColorFilter();
     if (colorFilter != nullptr) {
         Json::Value jsonColorFilter;
-        flatten(colorFilter, &jsonColorFilter, urlDataManager);
+        SkDrawCommand::flatten(colorFilter, &jsonColorFilter, urlDataManager);
         (*target)[SKDEBUGCANVAS_ATTRIBUTE_COLORFILTER] = jsonColorFilter;
     }
 }
 
 static void apply_paint_looper(const SkPaint& paint, Json::Value* target,
                                UrlDataManager& urlDataManager) {
     SkFlattenable* looper = paint.getLooper();
     if (looper != nullptr) {
         Json::Value jsonLooper;
-        flatten(looper, &jsonLooper, urlDataManager);
+        SkDrawCommand::flatten(looper, &jsonLooper, urlDataManager);
         (*target)[SKDEBUGCANVAS_ATTRIBUTE_LOOPER] = jsonLooper;
     }
 }
 
-Json::Value make_json_paint(const SkPaint& paint, UrlDataManager& urlDataManager) {
+Json::Value SkDrawCommand::MakeJsonPaint(const SkPaint& paint, UrlDataManager& urlDataManager) {
     Json::Value result(Json::objectValue);
     store_scalar(&result, SKDEBUGCANVAS_ATTRIBUTE_STROKEWIDTH, paint.getStrokeWidth(), 0.0f);
     store_scalar(&result, SKDEBUGCANVAS_ATTRIBUTE_STROKEMITER, paint.getStrokeMiter(),
                  SkPaintDefaults_MiterLimit);
     store_bool(&result, SKDEBUGCANVAS_ATTRIBUTE_ANTIALIAS, paint.isAntiAlias(), false);
     store_bool(&result, SKDEBUGCANVAS_ATTRIBUTE_DITHER, paint.isDither(), false);
     store_scalar(&result, SKDEBUGCANVAS_ATTRIBUTE_TEXTSIZE, paint.getTextSize(),
                  SkPaintDefaults_TextSize);
     store_scalar(&result, SKDEBUGCANVAS_ATTRIBUTE_TEXTSCALEX, paint.getTextScaleX(), SK_Scalar1);
     store_scalar(&result, SKDEBUGCANVAS_ATTRIBUTE_TEXTSCALEX, paint.getTextSkewX(), 0.0f);
@@ skipping 448 matching lines @@
     fColor = color;
     fInfo.push(SkObjectParser::CustomTextToString("No Parameters"));
 }
 
 void SkClearCommand::execute(SkCanvas* canvas) const {
     canvas->clear(fColor);
 }
 
 Json::Value SkClearCommand::toJSON(UrlDataManager& urlDataManager) const {
     Json::Value result = INHERITED::toJSON(urlDataManager);
-    result[SKDEBUGCANVAS_ATTRIBUTE_COLOR] = make_json_color(fColor);
+    result[SKDEBUGCANVAS_ATTRIBUTE_COLOR] = MakeJsonColor(fColor);
     return result;
 }
 
  SkClearCommand* SkClearCommand::fromJSON(Json::Value& command, UrlDataManager& urlDataManager) {
     Json::Value color = command[SKDEBUGCANVAS_ATTRIBUTE_COLOR];
     return new SkClearCommand(get_json_color(color));
 }
 
 SkClipPathCommand::SkClipPathCommand(const SkPath& path, SkRegion::Op op, bool doAA)
     : INHERITED(kClipPath_OpType) {
@@ skipping 10 matching lines @@
     canvas->clipPath(fPath, fOp, fDoAA);
 }
 
 bool SkClipPathCommand::render(SkCanvas* canvas) const {
     render_path(canvas, fPath);
     return true;
 }
 
 Json::Value SkClipPathCommand::toJSON(UrlDataManager& urlDataManager) const {
     Json::Value result = INHERITED::toJSON(urlDataManager);
-    result[SKDEBUGCANVAS_ATTRIBUTE_PATH] = make_json_path(fPath);
+    result[SKDEBUGCANVAS_ATTRIBUTE_PATH] = MakeJsonPath(fPath);
     result[SKDEBUGCANVAS_ATTRIBUTE_REGIONOP] = make_json_regionop(fOp);
     result[SKDEBUGCANVAS_ATTRIBUTE_ANTIALIAS] = fDoAA;
     return result;
 }
 
 SkClipPathCommand* SkClipPathCommand::fromJSON(Json::Value& command,
                                                UrlDataManager& urlDataManager) {
     SkPath path;
     extract_json_path(command[SKDEBUGCANVAS_ATTRIBUTE_PATH], &path);
     return new SkClipPathCommand(path, get_json_regionop(command[SKDEBUGCANVAS_ATTRIBUTE_REGIONOP]),
                                  command[SKDEBUGCANVAS_ATTRIBUTE_ANTIALIAS].asBool());
 }
 
 SkClipRegionCommand::SkClipRegionCommand(const SkRegion& region, SkRegion::Op op)
     : INHERITED(kClipRegion_OpType) {
     fRegion = region;
     fOp = op;
 
     fInfo.push(SkObjectParser::RegionToString(region));
     fInfo.push(SkObjectParser::RegionOpToString(op));
 }
 
 void SkClipRegionCommand::execute(SkCanvas* canvas) const {
     canvas->clipRegion(fRegion, fOp);
 }
 
 Json::Value SkClipRegionCommand::toJSON(UrlDataManager& urlDataManager) const {
     Json::Value result = INHERITED::toJSON(urlDataManager);
-    result[SKDEBUGCANVAS_ATTRIBUTE_REGION] = make_json_region(fRegion);
+    result[SKDEBUGCANVAS_ATTRIBUTE_REGION] = MakeJsonRegion(fRegion);
     result[SKDEBUGCANVAS_ATTRIBUTE_REGIONOP] = make_json_regionop(fOp);
     return result;
 }
 
 SkClipRegionCommand* SkClipRegionCommand::fromJSON(Json::Value& command,
                                                    UrlDataManager& urlDataManager) {
     SkASSERT(false);
     return nullptr;
 }
 
 SkClipRectCommand::SkClipRectCommand(const SkRect& rect, SkRegion::Op op, bool doAA)
     : INHERITED(kClipRect_OpType) {
     fRect = rect;
     fOp = op;
     fDoAA = doAA;
 
     fInfo.push(SkObjectParser::RectToString(rect));
     fInfo.push(SkObjectParser::RegionOpToString(op));
     fInfo.push(SkObjectParser::BoolToString(doAA));
 }
 
 void SkClipRectCommand::execute(SkCanvas* canvas) const {
     canvas->clipRect(fRect, fOp, fDoAA);
 }
 
 Json::Value SkClipRectCommand::toJSON(UrlDataManager& urlDataManager) const {
     Json::Value result = INHERITED::toJSON(urlDataManager);
-    result[SKDEBUGCANVAS_ATTRIBUTE_COORDS] = make_json_rect(fRect);
+    result[SKDEBUGCANVAS_ATTRIBUTE_COORDS] = MakeJsonRect(fRect);
     result[SKDEBUGCANVAS_ATTRIBUTE_REGIONOP] = make_json_regionop(fOp);
     result[SKDEBUGCANVAS_ATTRIBUTE_ANTIALIAS] = Json::Value(fDoAA);
     return result;
 }
 
 SkClipRectCommand* SkClipRectCommand::fromJSON(Json::Value& command,
                                                UrlDataManager& urlDataManager) {
     SkRect rect;
     extract_json_rect(command[SKDEBUGCANVAS_ATTRIBUTE_COORDS], &rect);
     return new SkClipRectCommand(rect, get_json_regionop(command[SKDEBUGCANVAS_ATTRIBUTE_REGIONOP]),
@@ skipping 89 matching lines @@
     render_bitmap(canvas, fBitmap);
     return true;
 }
 
 Json::Value SkDrawBitmapCommand::toJSON(UrlDataManager& urlDataManager) const {
     Json::Value result = INHERITED::toJSON(urlDataManager);
     Json::Value encoded;
     if (flatten(fBitmap, &encoded, urlDataManager)) {
         Json::Value command(Json::objectValue);
         result[SKDEBUGCANVAS_ATTRIBUTE_BITMAP] = encoded;
-        result[SKDEBUGCANVAS_ATTRIBUTE_COORDS] = make_json_point(fLeft, fTop);
+        result[SKDEBUGCANVAS_ATTRIBUTE_COORDS] = MakeJsonPoint(fLeft, fTop);
         if (fPaintPtr != nullptr) {
-            result[SKDEBUGCANVAS_ATTRIBUTE_PAINT] = make_json_paint(*fPaintPtr, urlDataManager);
+            result[SKDEBUGCANVAS_ATTRIBUTE_PAINT] = MakeJsonPaint(*fPaintPtr, urlDataManager);
         }
     }
     return result;
 }
 
 SkDrawBitmapCommand* SkDrawBitmapCommand::fromJSON(Json::Value& command,
                                                    UrlDataManager& urlDataManager) {
     SkBitmap* bitmap = load_bitmap(command[SKDEBUGCANVAS_ATTRIBUTE_BITMAP], urlDataManager);
     if (bitmap == nullptr) {
         return nullptr;
@@ skipping 44 matching lines @@
     render_bitmap(canvas, fBitmap, &tmp);
     return true;
 }
 
 Json::Value SkDrawBitmapNineCommand::toJSON(UrlDataManager& urlDataManager) const {
     Json::Value result = INHERITED::toJSON(urlDataManager);
     Json::Value encoded;
     if (flatten(fBitmap, &encoded, urlDataManager)) {
         result[SKDEBUGCANVAS_ATTRIBUTE_BITMAP] = encoded;
         result[SKDEBUGCANVAS_ATTRIBUTE_CENTER] = MakeJsonIRect(fCenter);
-        result[SKDEBUGCANVAS_ATTRIBUTE_DST] = make_json_rect(fDst);
+        result[SKDEBUGCANVAS_ATTRIBUTE_DST] = MakeJsonRect(fDst);
         if (fPaintPtr != nullptr) {
-            result[SKDEBUGCANVAS_ATTRIBUTE_PAINT] = make_json_paint(*fPaintPtr, urlDataManager);
+            result[SKDEBUGCANVAS_ATTRIBUTE_PAINT] = MakeJsonPaint(*fPaintPtr, urlDataManager);
         }
     }
     return result;
 }
 
 SkDrawBitmapNineCommand* SkDrawBitmapNineCommand::fromJSON(Json::Value& command,
                                                            UrlDataManager& urlDataManager) {
     SkBitmap* bitmap = load_bitmap(command[SKDEBUGCANVAS_ATTRIBUTE_BITMAP], urlDataManager);
     if (bitmap == nullptr) {
         return nullptr;
@@ skipping 55 matching lines @@
     render_bitmap(canvas, fBitmap, this->srcRect());
     return true;
 }
 
 Json::Value SkDrawBitmapRectCommand::toJSON(UrlDataManager& urlDataManager) const {
     Json::Value result = INHERITED::toJSON(urlDataManager);
     Json::Value encoded;
     if (flatten(fBitmap, &encoded, urlDataManager)) {
         result[SKDEBUGCANVAS_ATTRIBUTE_BITMAP] = encoded;
         if (!fSrc.isEmpty()) {
-            result[SKDEBUGCANVAS_ATTRIBUTE_SRC] = make_json_rect(fSrc);
+            result[SKDEBUGCANVAS_ATTRIBUTE_SRC] = MakeJsonRect(fSrc);
         }
-        result[SKDEBUGCANVAS_ATTRIBUTE_DST] = make_json_rect(fDst);
+        result[SKDEBUGCANVAS_ATTRIBUTE_DST] = MakeJsonRect(fDst);
         if (fPaintPtr != nullptr) {
-            result[SKDEBUGCANVAS_ATTRIBUTE_PAINT] = make_json_paint(*fPaintPtr, urlDataManager);
+            result[SKDEBUGCANVAS_ATTRIBUTE_PAINT] = MakeJsonPaint(*fPaintPtr, urlDataManager);
         }
         if (fConstraint == SkCanvas::kStrict_SrcRectConstraint) {
             result[SKDEBUGCANVAS_ATTRIBUTE_STRICT] = Json::Value(true);
         }
     }
     return result;
 }
 
 SkDrawBitmapRectCommand* SkDrawBitmapRectCommand::fromJSON(Json::Value& command,
                                                            UrlDataManager& urlDataManager) {
@@ skipping 65 matching lines @@
                                                        SkIntToScalar(fImage->height())));
     this->execute(canvas);
     return true;
 }
 
 Json::Value SkDrawImageCommand::toJSON(UrlDataManager& urlDataManager) const {
     Json::Value result = INHERITED::toJSON(urlDataManager);
     Json::Value encoded;
     if (flatten(*fImage, &encoded, urlDataManager)) {
         result[SKDEBUGCANVAS_ATTRIBUTE_IMAGE] = encoded;
-        result[SKDEBUGCANVAS_ATTRIBUTE_COORDS] = make_json_point(fLeft, fTop);
+        result[SKDEBUGCANVAS_ATTRIBUTE_COORDS] = MakeJsonPoint(fLeft, fTop);
         if (fPaint.isValid()) {
-            result[SKDEBUGCANVAS_ATTRIBUTE_PAINT] = make_json_paint(*fPaint.get(), urlDataManager);
+            result[SKDEBUGCANVAS_ATTRIBUTE_PAINT] = MakeJsonPaint(*fPaint.get(), urlDataManager);
         }
     }
     return result;
 }
 
 SkDrawImageCommand* SkDrawImageCommand::fromJSON(Json::Value& command,
                                                  UrlDataManager& urlDataManager) {
     sk_sp<SkImage> image = load_image(command[SKDEBUGCANVAS_ATTRIBUTE_IMAGE], urlDataManager);
     if (image == nullptr) {
         return nullptr;
@@ skipping 54 matching lines @@
     this->execute(canvas);
     return true;
 }
 
 Json::Value SkDrawImageRectCommand::toJSON(UrlDataManager& urlDataManager) const {
     Json::Value result = INHERITED::toJSON(urlDataManager);
     Json::Value encoded;
     if (flatten(*fImage.get(), &encoded, urlDataManager)) {
         result[SKDEBUGCANVAS_ATTRIBUTE_BITMAP] = encoded;
         if (fSrc.isValid()) {
-            result[SKDEBUGCANVAS_ATTRIBUTE_SRC] = make_json_rect(*fSrc.get());
+            result[SKDEBUGCANVAS_ATTRIBUTE_SRC] = MakeJsonRect(*fSrc.get());
         }
-        result[SKDEBUGCANVAS_ATTRIBUTE_DST] = make_json_rect(fDst);
+        result[SKDEBUGCANVAS_ATTRIBUTE_DST] = MakeJsonRect(fDst);
         if (fPaint.isValid()) {
-            result[SKDEBUGCANVAS_ATTRIBUTE_PAINT] = make_json_paint(*fPaint.get(), urlDataManager);
+            result[SKDEBUGCANVAS_ATTRIBUTE_PAINT] = MakeJsonPaint(*fPaint.get(), urlDataManager);
         }
         if (fConstraint == SkCanvas::kStrict_SrcRectConstraint) {
             result[SKDEBUGCANVAS_ATTRIBUTE_STRICT] = Json::Value(true);
         }
     }
     return result;
 }
 
 SkDrawImageRectCommand* SkDrawImageRectCommand::fromJSON(Json::Value& command,
                                                          UrlDataManager& urlDataManager) {
@@ skipping 58 matching lines @@
     p.setStyle(SkPaint::kStroke_Style);
 
     canvas->drawOval(fOval, p);
     canvas->restore();
 
     return true;
 }
 
 Json::Value SkDrawOvalCommand::toJSON(UrlDataManager& urlDataManager) const {
     Json::Value result = INHERITED::toJSON(urlDataManager);
-    result[SKDEBUGCANVAS_ATTRIBUTE_COORDS] = make_json_rect(fOval);
-    result[SKDEBUGCANVAS_ATTRIBUTE_PAINT] = make_json_paint(fPaint, urlDataManager);
+    result[SKDEBUGCANVAS_ATTRIBUTE_COORDS] = MakeJsonRect(fOval);
+    result[SKDEBUGCANVAS_ATTRIBUTE_PAINT] = MakeJsonPaint(fPaint, urlDataManager);
     return result;
 }
 
 SkDrawOvalCommand* SkDrawOvalCommand::fromJSON(Json::Value& command,
                                                UrlDataManager& urlDataManager) {
     SkRect coords;
     extract_json_rect(command[SKDEBUGCANVAS_ATTRIBUTE_COORDS], &coords);
     SkPaint paint;
     extract_json_paint(command[SKDEBUGCANVAS_ATTRIBUTE_PAINT], urlDataManager, &paint);
     return new SkDrawOvalCommand(coords, paint);
@@ skipping 11 matching lines @@
 }
 
 bool SkDrawPaintCommand::render(SkCanvas* canvas) const {
     canvas->clear(0xFFFFFFFF);
     canvas->drawPaint(fPaint);
     return true;
 }
 
 Json::Value SkDrawPaintCommand::toJSON(UrlDataManager& urlDataManager) const {
     Json::Value result = INHERITED::toJSON(urlDataManager);
-    result[SKDEBUGCANVAS_ATTRIBUTE_PAINT] = make_json_paint(fPaint, urlDataManager);
+    result[SKDEBUGCANVAS_ATTRIBUTE_PAINT] = MakeJsonPaint(fPaint, urlDataManager);
     return result;
 }
 
 SkDrawPaintCommand* SkDrawPaintCommand::fromJSON(Json::Value& command,
                                                  UrlDataManager& urlDataManager) {
     SkPaint paint;
     extract_json_paint(command[SKDEBUGCANVAS_ATTRIBUTE_PAINT], urlDataManager, &paint);
     return new SkDrawPaintCommand(paint);
 }
 
@@ skipping 10 matching lines @@
     canvas->drawPath(fPath, fPaint);
 }
 
 bool SkDrawPathCommand::render(SkCanvas* canvas) const {
     render_path(canvas, fPath);
     return true;
 }
 
 Json::Value SkDrawPathCommand::toJSON(UrlDataManager& urlDataManager) const {
     Json::Value result = INHERITED::toJSON(urlDataManager);
-    result[SKDEBUGCANVAS_ATTRIBUTE_PATH] = make_json_path(fPath);
-    result[SKDEBUGCANVAS_ATTRIBUTE_PAINT] = make_json_paint(fPaint, urlDataManager);
+    result[SKDEBUGCANVAS_ATTRIBUTE_PATH] = MakeJsonPath(fPath);
+    result[SKDEBUGCANVAS_ATTRIBUTE_PAINT] = MakeJsonPaint(fPaint, urlDataManager);
     return result;
 }
 
 SkDrawPathCommand* SkDrawPathCommand::fromJSON(Json::Value& command,
                                                UrlDataManager& urlDataManager) {
     SkPath path;
     extract_json_path(command[SKDEBUGCANVAS_ATTRIBUTE_PATH], &path);
     SkPaint paint;
     extract_json_paint(command[SKDEBUGCANVAS_ATTRIBUTE_PAINT], urlDataManager, &paint);
     return new SkDrawPathCommand(path, paint);
@@ skipping 103 matching lines @@
     canvas->restore();
 
     return true;
 }
 
 Json::Value SkDrawPointsCommand::toJSON(UrlDataManager& urlDataManager) const {
     Json::Value result = INHERITED::toJSON(urlDataManager);
     result[SKDEBUGCANVAS_ATTRIBUTE_MODE] = make_json_pointmode(fMode);
     Json::Value points(Json::arrayValue);
     for (size_t i = 0; i < fCount; i++) {
-        points.append(make_json_point(fPts[i]));
+        points.append(MakeJsonPoint(fPts[i]));
     }
     result[SKDEBUGCANVAS_ATTRIBUTE_POINTS] = points;
-    result[SKDEBUGCANVAS_ATTRIBUTE_PAINT] = make_json_paint(fPaint, urlDataManager);
+    result[SKDEBUGCANVAS_ATTRIBUTE_PAINT] = MakeJsonPaint(fPaint, urlDataManager);
     return result;
 }
 
 SkDrawPointsCommand* SkDrawPointsCommand::fromJSON(Json::Value& command,
                                                    UrlDataManager& urlDataManager) {
     SkCanvas::PointMode mode;
     const char* jsonMode = command[SKDEBUGCANVAS_ATTRIBUTE_MODE].asCString();
     if (!strcmp(jsonMode, SKDEBUGCANVAS_POINTMODE_POINTS)) {
         mode = SkCanvas::kPoints_PointMode;
     }
@@ skipping 44 matching lines @@
     canvas->drawPosText(fText, fByteLength, fPos, fPaint);
 }
 
 Json::Value SkDrawPosTextCommand::toJSON(UrlDataManager& urlDataManager) const {
     Json::Value result = INHERITED::toJSON(urlDataManager);
     result[SKDEBUGCANVAS_ATTRIBUTE_TEXT] = Json::Value((const char*) fText,
                                                        ((const char*) fText) + fByteLength);
     Json::Value coords(Json::arrayValue);
     size_t numCoords = fPaint.textToGlyphs(fText, fByteLength, nullptr);
     for (size_t i = 0; i < numCoords; i++) {
-        coords.append(make_json_point(fPos[i]));
+        coords.append(MakeJsonPoint(fPos[i]));
     }
     result[SKDEBUGCANVAS_ATTRIBUTE_COORDS] = coords;
-    result[SKDEBUGCANVAS_ATTRIBUTE_PAINT] = make_json_paint(fPaint, urlDataManager);
+    result[SKDEBUGCANVAS_ATTRIBUTE_PAINT] = MakeJsonPaint(fPaint, urlDataManager);
     return result;
 }
 
 SkDrawPosTextCommand* SkDrawPosTextCommand::fromJSON(Json::Value& command,
                                                      UrlDataManager& urlDataManager) {
     const char* text = command[SKDEBUGCANVAS_ATTRIBUTE_TEXT].asCString();
     SkPaint paint;
     extract_json_paint(command[SKDEBUGCANVAS_ATTRIBUTE_PAINT], urlDataManager, &paint);
     Json::Value coords = command[SKDEBUGCANVAS_ATTRIBUTE_COORDS];
     int count = (int) coords.size();
@@ skipping 34 matching lines @@
     Json::Value result = INHERITED::toJSON(urlDataManager);
     result[SKDEBUGCANVAS_ATTRIBUTE_TEXT] = Json::Value((const char*) fText,
                                                        ((const char*) fText) + fByteLength);
     result[SKDEBUGCANVAS_ATTRIBUTE_Y] = Json::Value(fConstY);
     Json::Value xpos(Json::arrayValue);
     size_t numXpos = fPaint.textToGlyphs(fText, fByteLength, nullptr);
     for (size_t i = 0; i < numXpos; i++) {
         xpos.append(Json::Value(fXpos[i]));
     }
     result[SKDEBUGCANVAS_ATTRIBUTE_POSITIONS] = xpos;
-    result[SKDEBUGCANVAS_ATTRIBUTE_PAINT] = make_json_paint(fPaint, urlDataManager);
+    result[SKDEBUGCANVAS_ATTRIBUTE_PAINT] = MakeJsonPaint(fPaint, urlDataManager);
     return result;
 }
 
 SkDrawPosTextHCommand* SkDrawPosTextHCommand::fromJSON(Json::Value& command,
                                                        UrlDataManager& urlDataManager) {
     const char* text = command[SKDEBUGCANVAS_ATTRIBUTE_TEXT].asCString();
     SkPaint paint;
     extract_json_paint(command[SKDEBUGCANVAS_ATTRIBUTE_PAINT], urlDataManager, &paint);
     Json::Value jsonXpos = command[SKDEBUGCANVAS_ATTRIBUTE_POSITIONS];
     int count = (int) jsonXpos.size();
@@ skipping 74 matching lines @@
     SkTextBlobRunIterator iter(fBlob.get());
     while (!iter.done()) {
         Json::Value run(Json::objectValue);
         Json::Value jsonPositions(Json::arrayValue);
         Json::Value jsonGlyphs(Json::arrayValue);
         const SkScalar* iterPositions = iter.pos();
         const uint16_t* iterGlyphs = iter.glyphs();
         for (uint32_t i = 0; i < iter.glyphCount(); i++) {
             switch (iter.positioning()) {
                 case SkTextBlob::kFull_Positioning:
-                    jsonPositions.append(make_json_point(iterPositions[i * 2],
-                                                         iterPositions[i * 2 + 1]));
+                    jsonPositions.append(MakeJsonPoint(iterPositions[i * 2],
+                                                       iterPositions[i * 2 + 1]));
                     break;
                 case SkTextBlob::kHorizontal_Positioning:
                     jsonPositions.append(Json::Value(iterPositions[i]));
                     break;
                 case SkTextBlob::kDefault_Positioning:
                     break;
             }
             jsonGlyphs.append(Json::Value(iterGlyphs[i]));
         }
         if (iter.positioning() != SkTextBlob::kDefault_Positioning) {
             run[SKDEBUGCANVAS_ATTRIBUTE_POSITIONS] = jsonPositions;
         }
         run[SKDEBUGCANVAS_ATTRIBUTE_GLYPHS] = jsonGlyphs;
         SkPaint fontPaint;
         iter.applyFontToPaint(&fontPaint);
-        run[SKDEBUGCANVAS_ATTRIBUTE_FONT] = make_json_paint(fontPaint, urlDataManager);
-        run[SKDEBUGCANVAS_ATTRIBUTE_COORDS] = make_json_point(iter.offset());
+        run[SKDEBUGCANVAS_ATTRIBUTE_FONT] = MakeJsonPaint(fontPaint, urlDataManager);
+        run[SKDEBUGCANVAS_ATTRIBUTE_COORDS] = MakeJsonPoint(iter.offset());
         runs.append(run);
         iter.next();
     }
     result[SKDEBUGCANVAS_ATTRIBUTE_RUNS] = runs;
     result[SKDEBUGCANVAS_ATTRIBUTE_X] = Json::Value(fXPos);
     result[SKDEBUGCANVAS_ATTRIBUTE_Y] = Json::Value(fYPos);
-    result[SKDEBUGCANVAS_ATTRIBUTE_PAINT] = make_json_paint(fPaint, urlDataManager);
+    result[SKDEBUGCANVAS_ATTRIBUTE_PAINT] = MakeJsonPaint(fPaint, urlDataManager);
     return result;
 }
 
 SkDrawTextBlobCommand* SkDrawTextBlobCommand::fromJSON(Json::Value& command,
                                                        UrlDataManager& urlDataManager) {
     SkTextBlobBuilder builder;
     Json::Value runs = command[SKDEBUGCANVAS_ATTRIBUTE_RUNS];
     for (Json::ArrayIndex i = 0 ; i < runs.size(); i++) {
         Json::Value run = runs[i];
         SkPaint font;
@@ skipping 62 matching lines @@
 }
 
 void SkDrawPatchCommand::execute(SkCanvas* canvas) const {
     canvas->drawPatch(fCubics, fColorsPtr, fTexCoordsPtr, fXfermode, fPaint);
 }
 
 Json::Value SkDrawPatchCommand::toJSON(UrlDataManager& urlDataManager) const {
     Json::Value result = INHERITED::toJSON(urlDataManager);
     Json::Value cubics = Json::Value(Json::arrayValue);
     for (int i = 0; i < 12; i++) {
-        cubics.append(make_json_point(fCubics[i]));
+        cubics.append(MakeJsonPoint(fCubics[i]));
     }
     result[SKDEBUGCANVAS_ATTRIBUTE_CUBICS] = cubics;
     if (fColorsPtr != nullptr) {
         Json::Value colors = Json::Value(Json::arrayValue);
         for (int i = 0; i < 4; i++) {
-            colors.append(make_json_color(fColorsPtr[i]));
+            colors.append(MakeJsonColor(fColorsPtr[i]));
         }
         result[SKDEBUGCANVAS_ATTRIBUTE_COLORS] = colors;
     }
     if (fTexCoordsPtr != nullptr) {
         Json::Value texCoords = Json::Value(Json::arrayValue);
         for (int i = 0; i < 4; i++) {
-            texCoords.append(make_json_point(fTexCoords[i]));
+            texCoords.append(MakeJsonPoint(fTexCoords[i]));
         }
         result[SKDEBUGCANVAS_ATTRIBUTE_TEXTURECOORDS] = texCoords;
     }
     if (fXfermode.get() != nullptr) {
         Json::Value jsonXfermode;
         flatten(fXfermode, &jsonXfermode, urlDataManager);
         result[SKDEBUGCANVAS_ATTRIBUTE_XFERMODE] = jsonXfermode;
     }
     return result;
 }
@@ skipping 47 matching lines @@
     fInfo.push(SkObjectParser::RectToString(rect));
     fInfo.push(SkObjectParser::PaintToString(paint));
 }
 
 void SkDrawRectCommand::execute(SkCanvas* canvas) const {
     canvas->drawRect(fRect, fPaint);
 }
 
 Json::Value SkDrawRectCommand::toJSON(UrlDataManager& urlDataManager) const {
     Json::Value result = INHERITED::toJSON(urlDataManager);
-    result[SKDEBUGCANVAS_ATTRIBUTE_COORDS] = make_json_rect(fRect);
-    result[SKDEBUGCANVAS_ATTRIBUTE_PAINT] = make_json_paint(fPaint, urlDataManager);
+    result[SKDEBUGCANVAS_ATTRIBUTE_COORDS] = MakeJsonRect(fRect);
+    result[SKDEBUGCANVAS_ATTRIBUTE_PAINT] = MakeJsonPaint(fPaint, urlDataManager);
     return result;
 }
 
 SkDrawRectCommand* SkDrawRectCommand::fromJSON(Json::Value& command,
                                                UrlDataManager& urlDataManager) {
     SkRect coords;
     extract_json_rect(command[SKDEBUGCANVAS_ATTRIBUTE_COORDS], &coords);
     SkPaint paint;
     extract_json_paint(command[SKDEBUGCANVAS_ATTRIBUTE_PAINT], urlDataManager, &paint);
     return new SkDrawRectCommand(coords, paint);
@@ skipping 13 matching lines @@
 }
 
 bool SkDrawRRectCommand::render(SkCanvas* canvas) const {
     render_rrect(canvas, fRRect);
     return true;
 }
 
 Json::Value SkDrawRRectCommand::toJSON(UrlDataManager& urlDataManager) const {
     Json::Value result = INHERITED::toJSON(urlDataManager);
     result[SKDEBUGCANVAS_ATTRIBUTE_COORDS] = make_json_rrect(fRRect);
-    result[SKDEBUGCANVAS_ATTRIBUTE_PAINT] = make_json_paint(fPaint, urlDataManager);
+    result[SKDEBUGCANVAS_ATTRIBUTE_PAINT] = MakeJsonPaint(fPaint, urlDataManager);
     return result;
 }
 
 SkDrawRRectCommand* SkDrawRRectCommand::fromJSON(Json::Value& command,
                                                  UrlDataManager& urlDataManager) {
     SkRRect coords;
     extract_json_rrect(command[SKDEBUGCANVAS_ATTRIBUTE_COORDS], &coords);
     SkPaint paint;
     extract_json_paint(command[SKDEBUGCANVAS_ATTRIBUTE_PAINT], urlDataManager, &paint);
     return new SkDrawRRectCommand(coords, paint);
@@ skipping 18 matching lines @@
 
 bool SkDrawDRRectCommand::render(SkCanvas* canvas) const {
     render_drrect(canvas, fOuter, fInner);
     return true;
 }
 
 Json::Value SkDrawDRRectCommand::toJSON(UrlDataManager& urlDataManager) const {
     Json::Value result = INHERITED::toJSON(urlDataManager);
     result[SKDEBUGCANVAS_ATTRIBUTE_OUTER] = make_json_rrect(fOuter);
     result[SKDEBUGCANVAS_ATTRIBUTE_INNER] = make_json_rrect(fInner);
-    result[SKDEBUGCANVAS_ATTRIBUTE_PAINT] = make_json_paint(fPaint, urlDataManager);
+    result[SKDEBUGCANVAS_ATTRIBUTE_PAINT] = MakeJsonPaint(fPaint, urlDataManager);
     return result;
 }
 
 SkDrawDRRectCommand* SkDrawDRRectCommand::fromJSON(Json::Value& command,
                                                    UrlDataManager& urlDataManager) {
     SkRRect outer;
     extract_json_rrect(command[SKDEBUGCANVAS_ATTRIBUTE_INNER], &outer);
     SkRRect inner;
     extract_json_rrect(command[SKDEBUGCANVAS_ATTRIBUTE_INNER], &inner);
     SkPaint paint;
@@ skipping 19 matching lines @@
 
 void SkDrawTextCommand::execute(SkCanvas* canvas) const {
     canvas->drawText(fText, fByteLength, fX, fY, fPaint);
 }
 
 Json::Value SkDrawTextCommand::toJSON(UrlDataManager& urlDataManager) const {
     Json::Value result = INHERITED::toJSON(urlDataManager);
     result[SKDEBUGCANVAS_ATTRIBUTE_TEXT] = Json::Value((const char*) fText,
                                                        ((const char*) fText) + fByteLength);
     Json::Value coords(Json::arrayValue);
-    result[SKDEBUGCANVAS_ATTRIBUTE_COORDS] = make_json_point(fX, fY);
-    result[SKDEBUGCANVAS_ATTRIBUTE_PAINT] = make_json_paint(fPaint, urlDataManager);
+    result[SKDEBUGCANVAS_ATTRIBUTE_COORDS] = MakeJsonPoint(fX, fY);
+    result[SKDEBUGCANVAS_ATTRIBUTE_PAINT] = MakeJsonPaint(fPaint, urlDataManager);
     return result;
 }
 
 SkDrawTextCommand* SkDrawTextCommand::fromJSON(Json::Value& command,
                                                UrlDataManager& urlDataManager) {
     const char* text = command[SKDEBUGCANVAS_ATTRIBUTE_TEXT].asCString();
     SkPaint paint;
     extract_json_paint(command[SKDEBUGCANVAS_ATTRIBUTE_PAINT], urlDataManager, &paint);
     Json::Value coords = command[SKDEBUGCANVAS_ATTRIBUTE_COORDS];
     return new SkDrawTextCommand(text, strlen(text), coords[0].asFloat(), coords[1].asFloat(),
@@ skipping 27 matching lines @@
     canvas->drawTextOnPath(fText, fByteLength, fPath,
                            fMatrix.isIdentity() ? nullptr : &fMatrix,
                            fPaint);
 }
 
 Json::Value SkDrawTextOnPathCommand::toJSON(UrlDataManager& urlDataManager) const {
     Json::Value result = INHERITED::toJSON(urlDataManager);
     result[SKDEBUGCANVAS_ATTRIBUTE_TEXT] = Json::Value((const char*) fText,
                                                        ((const char*) fText) + fByteLength);
     Json::Value coords(Json::arrayValue);
-    result[SKDEBUGCANVAS_ATTRIBUTE_PATH] = make_json_path(fPath);
+    result[SKDEBUGCANVAS_ATTRIBUTE_PATH] = MakeJsonPath(fPath);
     if (!fMatrix.isIdentity()) {
         result[SKDEBUGCANVAS_ATTRIBUTE_MATRIX] = MakeJsonMatrix(fMatrix);
     }
-    result[SKDEBUGCANVAS_ATTRIBUTE_PAINT] = make_json_paint(fPaint, urlDataManager);
+    result[SKDEBUGCANVAS_ATTRIBUTE_PAINT] = MakeJsonPaint(fPaint, urlDataManager);
     return result;
 }
 
 SkDrawTextOnPathCommand* SkDrawTextOnPathCommand::fromJSON(Json::Value& command,
                                                            UrlDataManager& urlDataManager) {
     const char* text = command[SKDEBUGCANVAS_ATTRIBUTE_TEXT].asCString();
     SkPaint paint;
     extract_json_paint(command[SKDEBUGCANVAS_ATTRIBUTE_PAINT], urlDataManager, &paint);
     SkPath path;
     extract_json_path(command[SKDEBUGCANVAS_ATTRIBUTE_PATH], &path);
@@ skipping 139 matching lines @@
                                              fSaveLayerFlags));
 }
 
 void SkSaveLayerCommand::vizExecute(SkCanvas* canvas) const {
     canvas->save();
 }
 
 Json::Value SkSaveLayerCommand::toJSON(UrlDataManager& urlDataManager) const {
     Json::Value result = INHERITED::toJSON(urlDataManager);
     if (!fBounds.isEmpty()) {
-        result[SKDEBUGCANVAS_ATTRIBUTE_BOUNDS] = make_json_rect(fBounds);
+        result[SKDEBUGCANVAS_ATTRIBUTE_BOUNDS] = MakeJsonRect(fBounds);
     }
     if (fPaintPtr != nullptr) {
-        result[SKDEBUGCANVAS_ATTRIBUTE_PAINT] = make_json_paint(*fPaintPtr,
+        result[SKDEBUGCANVAS_ATTRIBUTE_PAINT] = MakeJsonPaint(*fPaintPtr,
                                                                 urlDataManager);
     }
     if (fBackdrop != nullptr) {
         Json::Value jsonBackdrop;
         flatten(fBackdrop, &jsonBackdrop, urlDataManager);
         result[SKDEBUGCANVAS_ATTRIBUTE_BACKDROP] = jsonBackdrop;
     }
     if (fSaveLayerFlags != 0) {
         SkDebugf("unsupported: saveLayer flags\n");
         SkASSERT(false);
@@ skipping 46 matching lines @@
     result[SKDEBUGCANVAS_ATTRIBUTE_MATRIX] = MakeJsonMatrix(fMatrix);
     return result;
 }
 
 SkSetMatrixCommand* SkSetMatrixCommand::fromJSON(Json::Value& command,
                                                  UrlDataManager& urlDataManager) {
     SkMatrix matrix;
     extract_json_matrix(command[SKDEBUGCANVAS_ATTRIBUTE_MATRIX], &matrix);
     return new SkSetMatrixCommand(matrix);
 }