SkDrawCommand cleanup

- Remove fromJSON factories. These were unused, and many were
  incomplete or incorrect.
- Remove accessor methods (all unused) on command classes.
- Some commands used SkTLazy for optional params, others used
  manually initialized storage + pointer. (A few used strange
  sentinel values like empty rect or identity matrix). Switch
  to SkTLazy everywhere, and use the constructor that takes a
  pointer to simplify initialization in all cases.
- Use RAII for more fields (SkTDArray and sk_sp). There are a
  few of these left in the drawText commands, but that's it.

Change-Id: I34a87ad27c5efe0b94e5ae74b59a99f66a4e4cfa
Reviewed-on: https://skia-review.googlesource.com/130510
Reviewed-by: Mike Klein <mtklein@google.com>
Commit-Queue: Brian Osman <brianosman@google.com>

2 files changed, 101 insertions, 1509 deletions

diff --git a/tools/debugger/SkDrawCommand.cpp b/tools/debugger/SkDrawCommand.cpp
index 4740b4bf27..001911c975 100644
--- a/tools/debugger/SkDrawCommand.cpp
+++ b/tools/debugger/SkDrawCommand.cpp
@@ -200,15 +200,11 @@
 #define SKDEBUGCANVAS_SHADOWFLAG_TRANSPARENT_OCC  "transparentOccluder"
 #define SKDEBUGCANVAS_SHADOWFLAG_GEOMETRIC_ONLY   "geometricOnly"
 
-typedef SkDrawCommand* (*FROM_JSON)(Json::Value&, UrlDataManager&);
-
 static SkString* str_append(SkString* str, const SkRect& r) {
     str->appendf(" [%g %g %g %g]", r.left(), r.top(), r.right(), r.bottom());
     return str;
 }
 
-// TODO(chudy): Refactor into non subclass model.
-
 SkDrawCommand::SkDrawCommand(OpType type)
     : fOpType(type)
     , fVisible(true) {
@@ -272,58 +268,6 @@ Json::Value SkDrawCommand::toJSON(UrlDataManager& urlDataManager) const {
     return result;
 }
 
-#define INSTALL_FACTORY(name) factories.set(SkString(GetCommandString(k ## name ##_OpType)), \
-                                            (FROM_JSON) Sk ## name ## Command::fromJSON)
-SkDrawCommand* SkDrawCommand::fromJSON(Json::Value& command, UrlDataManager& urlDataManager) {
-    static SkTHashMap<SkString, FROM_JSON> factories;
-    static bool initialized = false;
-    if (!initialized) {
-        initialized = true;
-        INSTALL_FACTORY(Restore);
-        INSTALL_FACTORY(Clear);
-        INSTALL_FACTORY(ClipPath);
-        INSTALL_FACTORY(ClipRegion);
-        INSTALL_FACTORY(ClipRect);
-        INSTALL_FACTORY(ClipRRect);
-        INSTALL_FACTORY(Concat);
-        INSTALL_FACTORY(DrawAnnotation);
-        INSTALL_FACTORY(DrawBitmap);
-        INSTALL_FACTORY(DrawBitmapNine);
-        INSTALL_FACTORY(DrawBitmapRect);
-        INSTALL_FACTORY(DrawImage);
-        INSTALL_FACTORY(DrawImageLattice);
-        INSTALL_FACTORY(DrawImageNine);
-        INSTALL_FACTORY(DrawImageRect);
-        INSTALL_FACTORY(DrawOval);
-        INSTALL_FACTORY(DrawArc);
-        INSTALL_FACTORY(DrawPaint);
-        INSTALL_FACTORY(DrawPath);
-        INSTALL_FACTORY(DrawPoints);
-        INSTALL_FACTORY(DrawRegion);
-        INSTALL_FACTORY(DrawText);
-        INSTALL_FACTORY(DrawPosText);
-        INSTALL_FACTORY(DrawPosTextH);
-        INSTALL_FACTORY(DrawTextOnPath);
-        INSTALL_FACTORY(DrawTextRSXform);
-        INSTALL_FACTORY(DrawTextBlob);
-        INSTALL_FACTORY(DrawShadow);
-        INSTALL_FACTORY(DrawRect);
-        INSTALL_FACTORY(DrawRRect);
-        INSTALL_FACTORY(DrawDRRect);
-        INSTALL_FACTORY(DrawPatch);
-        INSTALL_FACTORY(Save);
-        INSTALL_FACTORY(SaveLayer);
-        INSTALL_FACTORY(SetMatrix);
-    }
-    SkString name = SkString(command[SKDEBUGCANVAS_ATTRIBUTE_COMMAND].asCString());
-    FROM_JSON* factory = factories.find(name);
-    if (factory == nullptr) {
-        SkDebugf("no JSON factory for '%s'\n", name.c_str());
-        return nullptr;
-    }
-    return (*factory)(command, urlDataManager);
-}
-
 namespace {
 
 void xlate_and_scale_to_bounds(SkCanvas* canvas, const SkRect& bounds) {
@@ -526,19 +470,6 @@ void apply_paint_blend_mode(const SkPaint& paint, Json::Value* target) {
     }
 }
 
-void extract_json_paint_blend_mode(Json::Value& jsonPaint, SkPaint* target) {
-    if (jsonPaint.isMember(SKDEBUGCANVAS_ATTRIBUTE_BLENDMODE)) {
-        const char* mode = jsonPaint[SKDEBUGCANVAS_ATTRIBUTE_BLENDMODE].asCString();
-
-        for (size_t i = 0; i < SK_ARRAY_COUNT(gBlendModeMap); ++i) {
-            if (!strcmp(mode, gBlendModeMap[i])) {
-                target->setBlendMode(static_cast<SkBlendMode>(i));
-                break;
-            }
-        }
-    }
-}
-
 };
 
 Json::Value SkDrawCommand::MakeJsonColor(const SkColor color) {
@@ -890,119 +821,6 @@ static const char* alpha_type_name(SkAlphaType alphaType) {
     }
 }
 
-static Json::ArrayIndex decode_data(Json::Value data, UrlDataManager& urlDataManager,
-                                    const void** target) {
-    UrlDataManager::UrlData* urlData = urlDataManager.getDataFromUrl(SkString(data.asCString()));
-    if (urlData == nullptr) {
-        SkASSERT(false);
-        *target = nullptr;
-        return 0;
-    }
-    *target = urlData->fData->data();
-    // cast should be safe for any reasonably-sized object...
-    return (Json::ArrayIndex) urlData->fData->size();
-}
-
-static SkFlattenable* load_flattenable(Json::Value jsonFlattenable,
-                                       UrlDataManager& urlDataManager) {
-    if (!jsonFlattenable.isMember(SKDEBUGCANVAS_ATTRIBUTE_NAME)) {
-        return nullptr;
-    }
-    const char* name = jsonFlattenable[SKDEBUGCANVAS_ATTRIBUTE_NAME].asCString();
-    SkFlattenable::Factory factory = SkFlattenable::NameToFactory(name);
-    if (factory == nullptr) {
-        SkDebugf("no factory for loading '%s'\n", name);
-        return nullptr;
-    }
-    const void* data;
-    int size = decode_data(jsonFlattenable[SKDEBUGCANVAS_ATTRIBUTE_DATA], urlDataManager, &data);
-    SkReadBuffer buffer(data, size);
-    sk_sp<SkFlattenable> result = factory(buffer);
-    if (!buffer.isValid()) {
-        SkDebugf("invalid buffer loading flattenable\n");
-        return nullptr;
-    }
-    return result.release();
-}
-
-static SkColorType colortype_from_name(const char* name) {
-    if (!strcmp(name, SKDEBUGCANVAS_COLORTYPE_ARGB4444)) {
-        return kARGB_4444_SkColorType;
-    }
-    else if (!strcmp(name, SKDEBUGCANVAS_COLORTYPE_RGBA8888)) {
-        return kRGBA_8888_SkColorType;
-    }
-    else if (!strcmp(name, SKDEBUGCANVAS_COLORTYPE_BGRA8888)) {
-        return kBGRA_8888_SkColorType;
-    }
-    else if (!strcmp(name, SKDEBUGCANVAS_COLORTYPE_565)) {
-        return kRGB_565_SkColorType;
-    }
-    else if (!strcmp(name, SKDEBUGCANVAS_COLORTYPE_GRAY8)) {
-        return kGray_8_SkColorType;
-    }
-    else if (!strcmp(name, SKDEBUGCANVAS_COLORTYPE_ALPHA8)) {
-        return kAlpha_8_SkColorType;
-    }
-    SkASSERT(false);
-    return kN32_SkColorType;
-}
-
-static SkBitmap* convert_colortype(SkBitmap* bitmap, SkColorType colorType) {
-    if (bitmap->colorType() == colorType  ) {
-        return bitmap;
-    }
-    SkBitmap* dst = new SkBitmap();
-    if (dst->tryAllocPixels(bitmap->info().makeColorType(colorType)) &&
-        bitmap->readPixels(dst->info(), dst->getPixels(), dst->rowBytes(), 0, 0))
-    {
-        delete bitmap;
-        return dst;
-    }
-    SkASSERT(false);
-    delete dst;
-    return bitmap;
-}
-
-// caller is responsible for freeing return value
-static SkBitmap* load_bitmap(const Json::Value& jsonBitmap, UrlDataManager& urlDataManager) {
-    if (!jsonBitmap.isMember(SKDEBUGCANVAS_ATTRIBUTE_DATA)) {
-        SkDebugf("invalid bitmap\n");
-        return nullptr;
-    }
-    const void* data;
-    int size = decode_data(jsonBitmap[SKDEBUGCANVAS_ATTRIBUTE_DATA], urlDataManager, &data);
-    sk_sp<SkData> encoded(SkData::MakeWithoutCopy(data, size));
-    sk_sp<SkImage> image(SkImage::MakeFromEncoded(std::move(encoded), nullptr));
-
-    std::unique_ptr<SkBitmap> bitmap(new SkBitmap());
-    if (nullptr != image) {
-        if (!image->asLegacyBitmap(bitmap.get())) {
-            SkDebugf("image decode failed\n");
-            return nullptr;
-        }
-
-        if (jsonBitmap.isMember(SKDEBUGCANVAS_ATTRIBUTE_COLOR)) {
-            const char* ctName = jsonBitmap[SKDEBUGCANVAS_ATTRIBUTE_COLOR].asCString();
-            SkColorType ct = colortype_from_name(ctName);
-            bitmap.reset(convert_colortype(bitmap.release(), ct));
-        }
-        return bitmap.release();
-    }
-    SkDebugf("image decode failed\n");
-    return nullptr;
-}
-
-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;
-}
-
 bool SkDrawCommand::flatten(const SkBitmap& bitmap, Json::Value* target,
                             UrlDataManager& urlDataManager) {
     sk_sp<SkImage> image(SkImage::MakeFromBitmap(bitmap));
@@ -1330,493 +1148,6 @@ Json::Value SkDrawCommand::MakeJsonLattice(const SkCanvas::Lattice& lattice) {
     return result;
 }
 
-static SkPoint get_json_point(Json::Value point) {
-    return SkPoint::Make(point[0].asFloat(), point[1].asFloat());
-}
-
-static SkPoint3 get_json_point3(Json::Value point) {
-    return SkPoint3::Make(point[0].asFloat(), point[1].asFloat(), point[2].asFloat());
-}
-
-static SkColor get_json_color(Json::Value color) {
-    return SkColorSetARGB(color[0].asInt(), color[1].asInt(), color[2].asInt(), color[3].asInt());
-}
-
-static void extract_json_paint_color(Json::Value& jsonPaint, SkPaint* target) {
-    if (jsonPaint.isMember(SKDEBUGCANVAS_ATTRIBUTE_COLOR)) {
-        target->setColor(get_json_color(jsonPaint[SKDEBUGCANVAS_ATTRIBUTE_COLOR]));
-    }
-}
-
-static void extract_json_paint_shader(Json::Value& jsonPaint, UrlDataManager& urlDataManager,
-                                      SkPaint* target) {
-    if (jsonPaint.isMember(SKDEBUGCANVAS_ATTRIBUTE_SHADER)) {
-        Json::Value jsonShader = jsonPaint[SKDEBUGCANVAS_ATTRIBUTE_SHADER];
-        SkShader* shader = (SkShader*) load_flattenable(jsonShader, urlDataManager);
-        if (shader != nullptr) {
-            target->setShader(sk_ref_sp(shader));
-        }
-    }
-}
-
-static void extract_json_paint_patheffect(Json::Value& jsonPaint, UrlDataManager& urlDataManager,
-                                          SkPaint* target) {
-    if (jsonPaint.isMember(SKDEBUGCANVAS_ATTRIBUTE_PATHEFFECT)) {
-        Json::Value jsonPathEffect = jsonPaint[SKDEBUGCANVAS_ATTRIBUTE_PATHEFFECT];
-        sk_sp<SkPathEffect> pathEffect((SkPathEffect*)load_flattenable(jsonPathEffect,
-                                                                       urlDataManager));
-        if (pathEffect != nullptr) {
-            target->setPathEffect(pathEffect);
-        }
-    }
-}
-
-static void extract_json_paint_maskfilter(Json::Value& jsonPaint, UrlDataManager& urlDataManager,
-                                          SkPaint* target) {
-    if (jsonPaint.isMember(SKDEBUGCANVAS_ATTRIBUTE_MASKFILTER)) {
-        Json::Value jsonMaskFilter = jsonPaint[SKDEBUGCANVAS_ATTRIBUTE_MASKFILTER];
-        sk_sp<SkMaskFilter> maskFilter((SkMaskFilter*)load_flattenable(jsonMaskFilter,
-                                                                       urlDataManager));
-        if (maskFilter) {
-            target->setMaskFilter(std::move(maskFilter));
-        }
-    }
-}
-
-static void extract_json_paint_colorfilter(Json::Value& jsonPaint, UrlDataManager& urlDataManager,
-                                           SkPaint* target) {
-    if (jsonPaint.isMember(SKDEBUGCANVAS_ATTRIBUTE_COLORFILTER)) {
-        Json::Value jsonColorFilter = jsonPaint[SKDEBUGCANVAS_ATTRIBUTE_COLORFILTER];
-        sk_sp<SkColorFilter> colorFilter((SkColorFilter*)load_flattenable(jsonColorFilter,
-                                                                          urlDataManager));
-        if (colorFilter != nullptr) {
-            target->setColorFilter(colorFilter);
-        }
-    }
-}
-
-static void extract_json_paint_looper(Json::Value& jsonPaint, UrlDataManager& urlDataManager,
-                                      SkPaint* target) {
-    if (jsonPaint.isMember(SKDEBUGCANVAS_ATTRIBUTE_LOOPER)) {
-        Json::Value jsonLooper = jsonPaint[SKDEBUGCANVAS_ATTRIBUTE_LOOPER];
-        sk_sp<SkDrawLooper> looper((SkDrawLooper*) load_flattenable(jsonLooper, urlDataManager));
-        if (looper != nullptr) {
-            target->setLooper(std::move(looper));
-        }
-    }
-}
-
-static void extract_json_paint_imagefilter(Json::Value& jsonPaint, UrlDataManager& urlDataManager,
-                                           SkPaint* target) {
-    if (jsonPaint.isMember(SKDEBUGCANVAS_ATTRIBUTE_IMAGEFILTER)) {
-        Json::Value jsonImageFilter = jsonPaint[SKDEBUGCANVAS_ATTRIBUTE_IMAGEFILTER];
-        sk_sp<SkImageFilter> imageFilter((SkImageFilter*) load_flattenable(jsonImageFilter,
-                                                                           urlDataManager));
-        if (imageFilter != nullptr) {
-            target->setImageFilter(imageFilter);
-        }
-    }
-}
-
-static void extract_json_paint_typeface(Json::Value& jsonPaint, UrlDataManager& urlDataManager,
-                                        SkPaint* target) {
-    if (jsonPaint.isMember(SKDEBUGCANVAS_ATTRIBUTE_TYPEFACE)) {
-        Json::Value jsonTypeface = jsonPaint[SKDEBUGCANVAS_ATTRIBUTE_TYPEFACE];
-        Json::Value jsonData = jsonTypeface[SKDEBUGCANVAS_ATTRIBUTE_DATA];
-        const void* data;
-        Json::ArrayIndex length = decode_data(jsonData, urlDataManager, &data);
-        SkMemoryStream buffer(data, length);
-        target->setTypeface(SkTypeface::MakeDeserialize(&buffer));
-    }
-}
-
-static void extract_json_paint_hinting(Json::Value& jsonPaint, SkPaint* target) {
-    if (jsonPaint.isMember(SKDEBUGCANVAS_ATTRIBUTE_HINTING)) {
-        const char* hinting = jsonPaint[SKDEBUGCANVAS_ATTRIBUTE_HINTING].asCString();
-        if (!strcmp(hinting, SKDEBUGCANVAS_HINTING_NONE)) {
-            target->setHinting(SkPaint::kNo_Hinting);
-        } else if (!strcmp(hinting, SKDEBUGCANVAS_HINTING_SLIGHT)) {
-            target->setHinting(SkPaint::kSlight_Hinting);
-        } else if (!strcmp(hinting, SKDEBUGCANVAS_HINTING_NORMAL)) {
-            target->setHinting(SkPaint::kNormal_Hinting);
-        } else if (!strcmp(hinting, SKDEBUGCANVAS_HINTING_FULL)) {
-            target->setHinting(SkPaint::kFull_Hinting);
-        }
-    }
-}
-
-static void extract_json_paint_style(Json::Value& jsonPaint, SkPaint* target) {
-    if (jsonPaint.isMember(SKDEBUGCANVAS_ATTRIBUTE_STYLE)) {
-        const char* style = jsonPaint[SKDEBUGCANVAS_ATTRIBUTE_STYLE].asCString();
-        if (!strcmp(style, SKDEBUGCANVAS_STYLE_FILL)) {
-            target->setStyle(SkPaint::kFill_Style);
-        }
-        else if (!strcmp(style, SKDEBUGCANVAS_STYLE_STROKE)) {
-            target->setStyle(SkPaint::kStroke_Style);
-        }
-        else if (!strcmp(style, SKDEBUGCANVAS_STYLE_STROKEANDFILL)) {
-            target->setStyle(SkPaint::kStrokeAndFill_Style);
-        }
-    }
-}
-
-static void extract_json_paint_strokewidth(Json::Value& jsonPaint, SkPaint* target) {
-    if (jsonPaint.isMember(SKDEBUGCANVAS_ATTRIBUTE_STROKEWIDTH)) {
-        float strokeWidth = jsonPaint[SKDEBUGCANVAS_ATTRIBUTE_STROKEWIDTH].asFloat();
-        target->setStrokeWidth(strokeWidth);
-    }
-}
-
-static void extract_json_paint_strokemiter(Json::Value& jsonPaint, SkPaint* target) {
-    if (jsonPaint.isMember(SKDEBUGCANVAS_ATTRIBUTE_STROKEMITER)) {
-        float strokeMiter = jsonPaint[SKDEBUGCANVAS_ATTRIBUTE_STROKEMITER].asFloat();
-        target->setStrokeMiter(strokeMiter);
-    }
-}
-
-static void extract_json_paint_strokejoin(Json::Value& jsonPaint, SkPaint* target) {
-    if (jsonPaint.isMember(SKDEBUGCANVAS_ATTRIBUTE_STROKEJOIN)) {
-        const char* join = jsonPaint[SKDEBUGCANVAS_ATTRIBUTE_STROKEJOIN].asCString();
-        if (!strcmp(join, SKDEBUGCANVAS_MITER_JOIN)) {
-            target->setStrokeJoin(SkPaint::kMiter_Join);
-        }
-        else if (!strcmp(join, SKDEBUGCANVAS_ROUND_JOIN)) {
-            target->setStrokeJoin(SkPaint::kRound_Join);
-        }
-        else if (!strcmp(join, SKDEBUGCANVAS_BEVEL_JOIN)) {
-            target->setStrokeJoin(SkPaint::kBevel_Join);
-        }
-        else {
-            SkASSERT(false);
-        }
-    }
-}
-
-static void extract_json_paint_cap(Json::Value& jsonPaint, SkPaint* target) {
-    if (jsonPaint.isMember(SKDEBUGCANVAS_ATTRIBUTE_CAP)) {
-        const char* cap = jsonPaint[SKDEBUGCANVAS_ATTRIBUTE_CAP].asCString();
-        if (!strcmp(cap, SKDEBUGCANVAS_CAP_BUTT)) {
-            target->setStrokeCap(SkPaint::kButt_Cap);
-        }
-        else if (!strcmp(cap, SKDEBUGCANVAS_CAP_ROUND)) {
-            target->setStrokeCap(SkPaint::kRound_Cap);
-        }
-        else if (!strcmp(cap, SKDEBUGCANVAS_CAP_SQUARE)) {
-            target->setStrokeCap(SkPaint::kSquare_Cap);
-        }
-    }
-}
-
-static void extract_json_paint_filterquality(Json::Value& jsonPaint, SkPaint* target) {
-    if (jsonPaint.isMember(SKDEBUGCANVAS_ATTRIBUTE_FILTERQUALITY)) {
-        const char* quality = jsonPaint[SKDEBUGCANVAS_ATTRIBUTE_FILTERQUALITY].asCString();
-        if (!strcmp(quality, SKDEBUGCANVAS_FILTERQUALITY_NONE)) {
-            target->setFilterQuality(kNone_SkFilterQuality);
-        }
-        else if (!strcmp(quality, SKDEBUGCANVAS_FILTERQUALITY_LOW)) {
-            target->setFilterQuality(kLow_SkFilterQuality);
-        }
-        else if (!strcmp(quality, SKDEBUGCANVAS_FILTERQUALITY_MEDIUM)) {
-            target->setFilterQuality(kMedium_SkFilterQuality);
-        }
-        else if (!strcmp(quality, SKDEBUGCANVAS_FILTERQUALITY_HIGH)) {
-            target->setFilterQuality(kHigh_SkFilterQuality);
-        }
-    }
-}
-
-static void extract_json_paint_antialias(Json::Value& jsonPaint, SkPaint* target) {
-    if (jsonPaint.isMember(SKDEBUGCANVAS_ATTRIBUTE_ANTIALIAS)) {
-        target->setAntiAlias(jsonPaint[SKDEBUGCANVAS_ATTRIBUTE_ANTIALIAS].asBool());
-    }
-}
-
-static void extract_json_paint_dither(Json::Value& jsonPaint, SkPaint* target) {
-    if (jsonPaint.isMember(SKDEBUGCANVAS_ATTRIBUTE_DITHER)) {
-        target->setDither(jsonPaint[SKDEBUGCANVAS_ATTRIBUTE_DITHER].asBool());
-    }
-}
-
-static void extract_json_paint_fakeboldtext(Json::Value& jsonPaint, SkPaint* target) {
-    if (jsonPaint.isMember(SKDEBUGCANVAS_ATTRIBUTE_FAKEBOLDTEXT)) {
-        target->setFakeBoldText(jsonPaint[SKDEBUGCANVAS_ATTRIBUTE_FAKEBOLDTEXT].asBool());
-    }
-}
-
-static void extract_json_paint_lineartext(Json::Value& jsonPaint, SkPaint* target) {
-    if (jsonPaint.isMember(SKDEBUGCANVAS_ATTRIBUTE_LINEARTEXT)) {
-        target->setLinearText(jsonPaint[SKDEBUGCANVAS_ATTRIBUTE_LINEARTEXT].asBool());
-    }
-}
-
-static void extract_json_paint_subpixeltext(Json::Value& jsonPaint, SkPaint* target) {
-    if (jsonPaint.isMember(SKDEBUGCANVAS_ATTRIBUTE_SUBPIXELTEXT)) {
-        target->setSubpixelText(jsonPaint[SKDEBUGCANVAS_ATTRIBUTE_SUBPIXELTEXT].asBool());
-    }
-}
-
-static void extract_json_paint_devkerntext(Json::Value& jsonPaint, SkPaint* target) {
-    if (jsonPaint.isMember(SKDEBUGCANVAS_ATTRIBUTE_DEVKERNTEXT)) {
-        target->setDevKernText(jsonPaint[SKDEBUGCANVAS_ATTRIBUTE_DEVKERNTEXT].asBool());
-    }
-}
-
-static void extract_json_paint_lcdrendertext(Json::Value& jsonPaint, SkPaint* target) {
-    if (jsonPaint.isMember(SKDEBUGCANVAS_ATTRIBUTE_LCDRENDERTEXT)) {
-        target->setLCDRenderText(jsonPaint[SKDEBUGCANVAS_ATTRIBUTE_LCDRENDERTEXT].asBool());
-    }
-}
-
-static void extract_json_paint_embeddedbitmaptext(Json::Value& jsonPaint, SkPaint* target) {
-    if (jsonPaint.isMember(SKDEBUGCANVAS_ATTRIBUTE_EMBEDDEDBITMAPTEXT)) {
-        target->setEmbeddedBitmapText(jsonPaint[SKDEBUGCANVAS_ATTRIBUTE_EMBEDDEDBITMAPTEXT].asBool());
-    }
-}
-
-static void extract_json_paint_autohinting(Json::Value& jsonPaint, SkPaint* target) {
-    if (jsonPaint.isMember(SKDEBUGCANVAS_ATTRIBUTE_AUTOHINTING)) {
-        target->setAutohinted(jsonPaint[SKDEBUGCANVAS_ATTRIBUTE_AUTOHINTING].asBool());
-    }
-}
-
-static void extract_json_paint_verticaltext(Json::Value& jsonPaint, SkPaint* target) {
-    if (jsonPaint.isMember(SKDEBUGCANVAS_ATTRIBUTE_VERTICALTEXT)) {
-        target->setVerticalText(jsonPaint[SKDEBUGCANVAS_ATTRIBUTE_VERTICALTEXT].asBool());
-    }
-}
-
-static void extract_json_paint_blur(Json::Value& jsonPaint, SkPaint* target) {
-    if (jsonPaint.isMember(SKDEBUGCANVAS_ATTRIBUTE_BLUR)) {
-        Json::Value blur = jsonPaint[SKDEBUGCANVAS_ATTRIBUTE_BLUR];
-        SkScalar sigma = blur[SKDEBUGCANVAS_ATTRIBUTE_SIGMA].asFloat();
-        SkBlurStyle style;
-        const char* jsonStyle = blur[SKDEBUGCANVAS_ATTRIBUTE_STYLE].asCString();
-        if (!strcmp(jsonStyle, SKDEBUGCANVAS_BLURSTYLE_NORMAL)) {
-            style = SkBlurStyle::kNormal_SkBlurStyle;
-        }
-        else if (!strcmp(jsonStyle, SKDEBUGCANVAS_BLURSTYLE_SOLID)) {
-            style = SkBlurStyle::kSolid_SkBlurStyle;
-        }
-        else if (!strcmp(jsonStyle, SKDEBUGCANVAS_BLURSTYLE_OUTER)) {
-            style = SkBlurStyle::kOuter_SkBlurStyle;
-        }
-        else if (!strcmp(jsonStyle, SKDEBUGCANVAS_BLURSTYLE_INNER)) {
-            style = SkBlurStyle::kInner_SkBlurStyle;
-        }
-        else {
-            SkASSERT(false);
-            style = SkBlurStyle::kNormal_SkBlurStyle;
-        }
-        target->setMaskFilter(SkMaskFilter::MakeBlur(style, sigma));
-    }
-}
-
-static void extract_json_paint_dashing(Json::Value& jsonPaint, SkPaint* target) {
-    if (jsonPaint.isMember(SKDEBUGCANVAS_ATTRIBUTE_DASHING)) {
-        Json::Value dash = jsonPaint[SKDEBUGCANVAS_ATTRIBUTE_DASHING];
-        Json::Value jsonIntervals = dash[SKDEBUGCANVAS_ATTRIBUTE_INTERVALS];
-        Json::ArrayIndex count = jsonIntervals.size();
-        SkScalar* intervals = (SkScalar*) sk_malloc_throw(count * sizeof(SkScalar));
-        for (Json::ArrayIndex i = 0; i < count; i++) {
-            intervals[i] = jsonIntervals[i].asFloat();
-        }
-        SkScalar phase = dash[SKDEBUGCANVAS_ATTRIBUTE_PHASE].asFloat();
-        target->setPathEffect(SkDashPathEffect::Make(intervals, count, phase));
-        sk_free(intervals);
-    }
-}
-
-static void extract_json_paint_textalign(Json::Value& jsonPaint, SkPaint* target) {
-    if (jsonPaint.isMember(SKDEBUGCANVAS_ATTRIBUTE_TEXTALIGN)) {
-        SkPaint::Align textAlign;
-        const char* jsonAlign = jsonPaint[SKDEBUGCANVAS_ATTRIBUTE_TEXTALIGN].asCString();
-        if (!strcmp(jsonAlign, SKDEBUGCANVAS_ALIGN_LEFT)) {
-            textAlign = SkPaint::kLeft_Align;
-        }
-        else if (!strcmp(jsonAlign, SKDEBUGCANVAS_ALIGN_CENTER)) {
-            textAlign = SkPaint::kCenter_Align;
-        }
-        else if (!strcmp(jsonAlign, SKDEBUGCANVAS_ALIGN_RIGHT)) {
-            textAlign = SkPaint::kRight_Align;
-        }
-        else {
-            SkASSERT(false);
-            textAlign = SkPaint::kLeft_Align;
-        }
-        target->setTextAlign(textAlign);
-    }
-}
-
-static void extract_json_paint_textsize(Json::Value& jsonPaint, SkPaint* target) {
-    if (jsonPaint.isMember(SKDEBUGCANVAS_ATTRIBUTE_TEXTSIZE)) {
-        float textSize = jsonPaint[SKDEBUGCANVAS_ATTRIBUTE_TEXTSIZE].asFloat();
-        target->setTextSize(textSize);
-    }
-}
-
-static void extract_json_paint_textscalex(Json::Value& jsonPaint, SkPaint* target) {
-    if (jsonPaint.isMember(SKDEBUGCANVAS_ATTRIBUTE_TEXTSCALEX)) {
-        float textScaleX = jsonPaint[SKDEBUGCANVAS_ATTRIBUTE_TEXTSCALEX].asFloat();
-        target->setTextScaleX(textScaleX);
-    }
-}
-
-static void extract_json_paint_textskewx(Json::Value& jsonPaint, SkPaint* target) {
-    if (jsonPaint.isMember(SKDEBUGCANVAS_ATTRIBUTE_TEXTSKEWX)) {
-        float textSkewX = jsonPaint[SKDEBUGCANVAS_ATTRIBUTE_TEXTSKEWX].asFloat();
-        target->setTextSkewX(textSkewX);
-    }
-}
-
-static void extract_json_paint(Json::Value& paint, UrlDataManager& urlDataManager,
-                               SkPaint* result) {
-    extract_json_paint_hinting(paint, result);
-    extract_json_paint_color(paint, result);
-    extract_json_paint_shader(paint, urlDataManager, result);
-    extract_json_paint_patheffect(paint, urlDataManager, result);
-    extract_json_paint_maskfilter(paint, urlDataManager, result);
-    extract_json_paint_colorfilter(paint, urlDataManager, result);
-    extract_json_paint_looper(paint, urlDataManager, result);
-    extract_json_paint_imagefilter(paint, urlDataManager, result);
-    extract_json_paint_typeface(paint, urlDataManager, result);
-    extract_json_paint_style(paint, result);
-    extract_json_paint_blend_mode(paint, result);
-    extract_json_paint_strokewidth(paint, result);
-    extract_json_paint_strokemiter(paint, result);
-    extract_json_paint_strokejoin(paint, result);
-    extract_json_paint_cap(paint, result);
-    extract_json_paint_filterquality(paint, result);
-    extract_json_paint_antialias(paint, result);
-    extract_json_paint_dither(paint, result);
-    extract_json_paint_fakeboldtext(paint, result);
-    extract_json_paint_lineartext(paint, result);
-    extract_json_paint_subpixeltext(paint, result);
-    extract_json_paint_devkerntext(paint, result);
-    extract_json_paint_lcdrendertext(paint, result);
-    extract_json_paint_embeddedbitmaptext(paint, result);
-    extract_json_paint_autohinting(paint, result);
-    extract_json_paint_verticaltext(paint, result);
-    extract_json_paint_blur(paint, result);
-    extract_json_paint_dashing(paint, result);
-    extract_json_paint_textalign(paint, result);
-    extract_json_paint_textsize(paint, result);
-    extract_json_paint_textscalex(paint, result);
-    extract_json_paint_textskewx(paint, result);
-}
-
-static void extract_json_rect(Json::Value& rect, SkRect* result) {
-    result->set(rect[0].asFloat(), rect[1].asFloat(), rect[2].asFloat(), rect[3].asFloat());
-}
-
-static void extract_json_irect(Json::Value& rect, SkIRect* result) {
-    result->set(rect[0].asInt(), rect[1].asInt(), rect[2].asInt(), rect[3].asInt());
-}
-
-static void extract_json_rrect(Json::Value& rrect, SkRRect* result) {
-    SkVector radii[4] = {
-                            { rrect[1][0].asFloat(), rrect[1][1].asFloat() },
-                            { rrect[2][0].asFloat(), rrect[2][1].asFloat() },
-                            { rrect[3][0].asFloat(), rrect[3][1].asFloat() },
-                            { rrect[4][0].asFloat(), rrect[4][1].asFloat() }
-                        };
-    result->setRectRadii(SkRect::MakeLTRB(rrect[0][0].asFloat(), rrect[0][1].asFloat(),
-                                          rrect[0][2].asFloat(), rrect[0][3].asFloat()),
-                                          radii);
-}
-
-static void extract_json_matrix(Json::Value& matrix, SkMatrix* result) {
-    SkScalar values[] = {
-        matrix[0][0].asFloat(), matrix[0][1].asFloat(), matrix[0][2].asFloat(),
-        matrix[1][0].asFloat(), matrix[1][1].asFloat(), matrix[1][2].asFloat(),
-        matrix[2][0].asFloat(), matrix[2][1].asFloat(), matrix[2][2].asFloat()
-    };
-    result->set9(values);
-}
-
-static void extract_json_path(Json::Value& path, SkPath* result) {
-    const char* fillType = path[SKDEBUGCANVAS_ATTRIBUTE_FILLTYPE].asCString();
-    if (!strcmp(fillType, SKDEBUGCANVAS_FILLTYPE_WINDING)) {
-        result->setFillType(SkPath::kWinding_FillType);
-    }
-    else if (!strcmp(fillType, SKDEBUGCANVAS_FILLTYPE_EVENODD)) {
-        result->setFillType(SkPath::kEvenOdd_FillType);
-    }
-    else if (!strcmp(fillType, SKDEBUGCANVAS_FILLTYPE_INVERSEWINDING)) {
-        result->setFillType(SkPath::kInverseWinding_FillType);
-    }
-    else if (!strcmp(fillType, SKDEBUGCANVAS_FILLTYPE_INVERSEEVENODD)) {
-        result->setFillType(SkPath::kInverseEvenOdd_FillType);
-    }
-    Json::Value verbs = path[SKDEBUGCANVAS_ATTRIBUTE_VERBS];
-    for (Json::ArrayIndex i = 0; i < verbs.size(); i++) {
-        Json::Value verb = verbs[i];
-        if (verb.isString()) {
-            SkASSERT(!strcmp(verb.asCString(), SKDEBUGCANVAS_VERB_CLOSE));
-            result->close();
-        }
-        else {
-            if (verb.isMember(SKDEBUGCANVAS_VERB_MOVE)) {
-                Json::Value move = verb[SKDEBUGCANVAS_VERB_MOVE];
-                result->moveTo(move[0].asFloat(), move[1].asFloat());
-            }
-            else if (verb.isMember(SKDEBUGCANVAS_VERB_LINE)) {
-                Json::Value line = verb[SKDEBUGCANVAS_VERB_LINE];
-                result->lineTo(line[0].asFloat(), line[1].asFloat());
-            }
-            else if (verb.isMember(SKDEBUGCANVAS_VERB_QUAD)) {
-                Json::Value quad = verb[SKDEBUGCANVAS_VERB_QUAD];
-                result->quadTo(quad[0][0].asFloat(), quad[0][1].asFloat(),
-                               quad[1][0].asFloat(), quad[1][1].asFloat());
-            }
-            else if (verb.isMember(SKDEBUGCANVAS_VERB_CUBIC)) {
-                Json::Value cubic = verb[SKDEBUGCANVAS_VERB_CUBIC];
-                result->cubicTo(cubic[0][0].asFloat(), cubic[0][1].asFloat(),
-                                cubic[1][0].asFloat(), cubic[1][1].asFloat(),
-                                cubic[2][0].asFloat(), cubic[2][1].asFloat());
-            }
-            else if (verb.isMember(SKDEBUGCANVAS_VERB_CONIC)) {
-                Json::Value conic = verb[SKDEBUGCANVAS_VERB_CONIC];
-                result->conicTo(conic[0][0].asFloat(), conic[0][1].asFloat(),
-                                conic[1][0].asFloat(), conic[1][1].asFloat(),
-                                conic[2].asFloat());
-            }
-            else {
-                SkASSERT(false);
-            }
-        }
-    }
-}
-
-static void extract_json_region(Json::Value& region, SkRegion* result) {
-    SkPath path;
-    extract_json_path(region, &path);
-    result->setPath(path, SkRegion(path.getBounds().roundOut()));
-}
-
-SkClipOp get_json_clipop(Json::Value& jsonOp) {
-    const char* op = jsonOp.asCString();
-    if (!strcmp(op, SKDEBUGCANVAS_REGIONOP_DIFFERENCE)) {
-        return kDifference_SkClipOp;
-    }
-    else if (!strcmp(op, SKDEBUGCANVAS_REGIONOP_INTERSECT)) {
-        return kIntersect_SkClipOp;
-    }
-    else if (!strcmp(op, SKDEBUGCANVAS_REGIONOP_UNION)) {
-        return kUnion_SkClipOp;
-    }
-    else if (!strcmp(op, SKDEBUGCANVAS_REGIONOP_XOR)) {
-        return kXOR_SkClipOp;
-    }
-    else if (!strcmp(op, SKDEBUGCANVAS_REGIONOP_REVERSE_DIFFERENCE)) {
-        return kReverseDifference_SkClipOp;
-    }
-    else if (!strcmp(op, SKDEBUGCANVAS_REGIONOP_REPLACE)) {
-        return kReplace_SkClipOp;
-    }
-    SkASSERT(false);
-    return kIntersect_SkClipOp;
-}
-
 SkClearCommand::SkClearCommand(SkColor color) : INHERITED(kClear_OpType) {
     fColor = color;
 }
@@ -1831,11 +1162,6 @@ Json::Value SkClearCommand::toJSON(UrlDataManager& urlDataManager) const {
     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, SkClipOp op, bool doAA)
     : INHERITED(kClipPath_OpType) {
     fPath = path;
@@ -1860,14 +1186,6 @@ Json::Value SkClipPathCommand::toJSON(UrlDataManager& urlDataManager) const {
     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_clipop(command[SKDEBUGCANVAS_ATTRIBUTE_REGIONOP]),
-                                 command[SKDEBUGCANVAS_ATTRIBUTE_ANTIALIAS].asBool());
-}
-
 SkClipRegionCommand::SkClipRegionCommand(const SkRegion& region, SkClipOp op)
     : INHERITED(kClipRegion_OpType) {
     fRegion = region;
@@ -1885,14 +1203,6 @@ Json::Value SkClipRegionCommand::toJSON(UrlDataManager& urlDataManager) const {
     return result;
 }
 
-SkClipRegionCommand* SkClipRegionCommand::fromJSON(Json::Value& command,
-                                                   UrlDataManager& urlDataManager) {
-    SkRegion region;
-    extract_json_region(command[SKDEBUGCANVAS_ATTRIBUTE_REGION], &region);
-    return new SkClipRegionCommand(region,
-                                   get_json_clipop(command[SKDEBUGCANVAS_ATTRIBUTE_REGIONOP]));
-}
-
 SkClipRectCommand::SkClipRectCommand(const SkRect& rect, SkClipOp op, bool doAA)
     : INHERITED(kClipRect_OpType) {
     fRect = rect;
@@ -1916,14 +1226,6 @@ Json::Value SkClipRectCommand::toJSON(UrlDataManager& urlDataManager) const {
     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_clipop(command[SKDEBUGCANVAS_ATTRIBUTE_REGIONOP]),
-                                 command[SKDEBUGCANVAS_ATTRIBUTE_ANTIALIAS].asBool());
-}
-
 SkClipRRectCommand::SkClipRRectCommand(const SkRRect& rrect, SkClipOp op, bool doAA)
     : INHERITED(kClipRRect_OpType) {
     fRRect = rrect;
@@ -1948,15 +1250,6 @@ Json::Value SkClipRRectCommand::toJSON(UrlDataManager& urlDataManager) const {
     return result;
 }
 
-SkClipRRectCommand* SkClipRRectCommand::fromJSON(Json::Value& command,
-                                                 UrlDataManager& urlDataManager) {
-    SkRRect rrect;
-    extract_json_rrect(command[SKDEBUGCANVAS_ATTRIBUTE_COORDS], &rrect);
-    return new SkClipRRectCommand(rrect,
-                                  get_json_clipop(command[SKDEBUGCANVAS_ATTRIBUTE_REGIONOP]),
-                                  command[SKDEBUGCANVAS_ATTRIBUTE_ANTIALIAS].asBool());
-}
-
 SkConcatCommand::SkConcatCommand(const SkMatrix& matrix)
     : INHERITED(kConcat_OpType) {
     fMatrix = matrix;
@@ -1972,12 +1265,6 @@ Json::Value SkConcatCommand::toJSON(UrlDataManager& urlDataManager) const {
     return result;
 }
 
-SkConcatCommand* SkConcatCommand::fromJSON(Json::Value& command, UrlDataManager& urlDataManager) {
-    SkMatrix matrix;
-    extract_json_matrix(command[SKDEBUGCANVAS_ATTRIBUTE_MATRIX], &matrix);
-    return new SkConcatCommand(matrix);
-}
-
 ////
 
 SkDrawAnnotationCommand::SkDrawAnnotationCommand(const SkRect& rect, const char key[],
@@ -2009,32 +1296,18 @@ Json::Value SkDrawAnnotationCommand::toJSON(UrlDataManager& urlDataManager) cons
     return result;
 }
 
-SkDrawAnnotationCommand* SkDrawAnnotationCommand::fromJSON(Json::Value& command,
-                                                           UrlDataManager& urlDataManager) {
-    SkRect rect;
-    extract_json_rect(command[SKDEBUGCANVAS_ATTRIBUTE_COORDS], &rect);
-    sk_sp<SkData> data(nullptr); // TODO: extract "value" from the Json
-    return new SkDrawAnnotationCommand(rect, command["key"].asCString(), data);
-}
-
 ////
 
 SkDrawBitmapCommand::SkDrawBitmapCommand(const SkBitmap& bitmap, SkScalar left, SkScalar top,
                                          const SkPaint* paint)
-    : INHERITED(kDrawBitmap_OpType) {
-    fBitmap = bitmap;
-    fLeft = left;
-    fTop = top;
-    if (paint) {
-        fPaint = *paint;
-        fPaintPtr = &fPaint;
-    } else {
-        fPaintPtr = nullptr;
-    }
-}
+    : INHERITED(kDrawBitmap_OpType)
+    , fBitmap(bitmap)
+    , fLeft(left)
+    , fTop(top)
+    , fPaint(paint) {}
 
 void SkDrawBitmapCommand::execute(SkCanvas* canvas) const {
-    canvas->drawBitmap(fBitmap, fLeft, fTop, fPaintPtr);
+    canvas->drawBitmap(fBitmap, fLeft, fTop, fPaint.getMaybeNull());
 }
 
 bool SkDrawBitmapCommand::render(SkCanvas* canvas) const {
@@ -2049,47 +1322,21 @@ Json::Value SkDrawBitmapCommand::toJSON(UrlDataManager& urlDataManager) const {
         Json::Value command(Json::objectValue);
         result[SKDEBUGCANVAS_ATTRIBUTE_BITMAP] = encoded;
         result[SKDEBUGCANVAS_ATTRIBUTE_COORDS] = MakeJsonPoint(fLeft, fTop);
-        if (fPaintPtr != nullptr) {
-            result[SKDEBUGCANVAS_ATTRIBUTE_PAINT] = MakeJsonPaint(*fPaintPtr, urlDataManager);
+        if (fPaint.isValid()) {
+            result[SKDEBUGCANVAS_ATTRIBUTE_PAINT] = MakeJsonPaint(*fPaint.get(), 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;
-    }
-    Json::Value point = command[SKDEBUGCANVAS_ATTRIBUTE_COORDS];
-    SkPaint* paintPtr;
-    SkPaint paint;
-    if (command.isMember(SKDEBUGCANVAS_ATTRIBUTE_PAINT)) {
-        extract_json_paint(command[SKDEBUGCANVAS_ATTRIBUTE_PAINT], urlDataManager, &paint);
-        paintPtr = &paint;
-    }
-    else {
-        paintPtr = nullptr;
-    }
-    SkDrawBitmapCommand* result = new SkDrawBitmapCommand(*bitmap, point[0].asFloat(),
-                                                          point[1].asFloat(), paintPtr);
-    delete bitmap;
-    return result;
-}
-
 SkDrawBitmapLatticeCommand::SkDrawBitmapLatticeCommand(const SkBitmap& bitmap,
                                                        const SkCanvas::Lattice& lattice,
                                                        const SkRect& dst, const SkPaint* paint)
     : INHERITED(kDrawBitmapLattice_OpType)
     , fBitmap(bitmap)
     , fLattice(lattice)
-    , fDst(dst) {
-
-    if (paint) {
-        fPaint.set(*paint);
-    }
-}
+    , fDst(dst)
+    , fPaint(paint) {}
 
 void SkDrawBitmapLatticeCommand::execute(SkCanvas* canvas) const {
     canvas->drawBitmapLattice(fBitmap, fLattice, fDst, fPaint.getMaybeNull());
@@ -2123,28 +1370,16 @@ Json::Value SkDrawBitmapLatticeCommand::toJSON(UrlDataManager& urlDataManager) c
     return result;
 }
 
-SkDrawBitmapLatticeCommand* SkDrawBitmapLatticeCommand::fromJSON(Json::Value& command,
-                                                                 UrlDataManager& urlDataManager) {
-    SkDEBUGFAIL("Not implemented yet.");
-    return nullptr;
-}
-
 SkDrawBitmapNineCommand::SkDrawBitmapNineCommand(const SkBitmap& bitmap, const SkIRect& center,
                                                  const SkRect& dst, const SkPaint* paint)
-    : INHERITED(kDrawBitmapNine_OpType) {
-    fBitmap = bitmap;
-    fCenter = center;
-    fDst = dst;
-    if (paint) {
-        fPaint = *paint;
-        fPaintPtr = &fPaint;
-    } else {
-        fPaintPtr = nullptr;
-    }
-}
+    : INHERITED(kDrawBitmapNine_OpType)
+    , fBitmap(bitmap)
+    , fCenter(center)
+    , fDst(dst)
+    , fPaint(paint) {}
 
 void SkDrawBitmapNineCommand::execute(SkCanvas* canvas) const {
-    canvas->drawBitmapNine(fBitmap, fCenter, fDst, fPaintPtr);
+    canvas->drawBitmapNine(fBitmap, fCenter, fDst, fPaint.getMaybeNull());
 }
 
 bool SkDrawBitmapNineCommand::render(SkCanvas* canvas) const {
@@ -2160,64 +1395,30 @@ Json::Value SkDrawBitmapNineCommand::toJSON(UrlDataManager& urlDataManager) cons
         result[SKDEBUGCANVAS_ATTRIBUTE_BITMAP] = encoded;
         result[SKDEBUGCANVAS_ATTRIBUTE_CENTER] = MakeJsonIRect(fCenter);
         result[SKDEBUGCANVAS_ATTRIBUTE_DST] = MakeJsonRect(fDst);
-        if (fPaintPtr != nullptr) {
-            result[SKDEBUGCANVAS_ATTRIBUTE_PAINT] = MakeJsonPaint(*fPaintPtr, urlDataManager);
+        if (fPaint.isValid()) {
+            result[SKDEBUGCANVAS_ATTRIBUTE_PAINT] = MakeJsonPaint(*fPaint.get(), 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;
-    }
-    SkIRect center;
-    extract_json_irect(command[SKDEBUGCANVAS_ATTRIBUTE_CENTER], &center);
-    SkRect dst;
-    extract_json_rect(command[SKDEBUGCANVAS_ATTRIBUTE_DST], &dst);
-    SkPaint* paintPtr;
-    SkPaint paint;
-    if (command.isMember(SKDEBUGCANVAS_ATTRIBUTE_PAINT)) {
-        extract_json_paint(command[SKDEBUGCANVAS_ATTRIBUTE_PAINT], urlDataManager, &paint);
-        paintPtr = &paint;
-    }
-    else {
-        paintPtr = nullptr;
-    }
-    SkDrawBitmapNineCommand* result = new SkDrawBitmapNineCommand(*bitmap, center, dst, paintPtr);
-    delete bitmap;
-    return result;
-}
-
 SkDrawBitmapRectCommand::SkDrawBitmapRectCommand(const SkBitmap& bitmap, const SkRect* src,
                                                  const SkRect& dst, const SkPaint* paint,
                                                  SkCanvas::SrcRectConstraint constraint)
-    : INHERITED(kDrawBitmapRect_OpType) {
-    fBitmap = bitmap;
-    if (src) {
-        fSrc = *src;
-    } else {
-        fSrc.setEmpty();
-    }
-    fDst = dst;
-
-    if (paint) {
-        fPaint = *paint;
-        fPaintPtr = &fPaint;
-    } else {
-        fPaintPtr = nullptr;
-    }
-    fConstraint = constraint;
-}
+    : INHERITED(kDrawBitmapRect_OpType)
+    , fBitmap(bitmap)
+    , fSrc(src)
+    , fDst(dst)
+    , fPaint(paint)
+    , fConstraint(constraint) {}
 
 void SkDrawBitmapRectCommand::execute(SkCanvas* canvas) const {
-    canvas->legacy_drawBitmapRect(fBitmap, this->srcRect(), fDst, fPaintPtr, fConstraint);
+    canvas->legacy_drawBitmapRect(fBitmap, fSrc.getMaybeNull(), fDst, fPaint.getMaybeNull(),
+                                  fConstraint);
 }
 
 bool SkDrawBitmapRectCommand::render(SkCanvas* canvas) const {
-    render_bitmap(canvas, fBitmap, this->srcRect());
+    render_bitmap(canvas, fBitmap, fSrc.getMaybeNull());
     return true;
 }
 
@@ -2226,12 +1427,12 @@ Json::Value SkDrawBitmapRectCommand::toJSON(UrlDataManager& urlDataManager) cons
     Json::Value encoded;
     if (flatten(fBitmap, &encoded, urlDataManager)) {
         result[SKDEBUGCANVAS_ATTRIBUTE_BITMAP] = encoded;
-        if (!fSrc.isEmpty()) {
-            result[SKDEBUGCANVAS_ATTRIBUTE_SRC] = MakeJsonRect(fSrc);
+        if (fSrc.isValid()) {
+            result[SKDEBUGCANVAS_ATTRIBUTE_SRC] = MakeJsonRect(*fSrc.get());
         }
         result[SKDEBUGCANVAS_ATTRIBUTE_DST] = MakeJsonRect(fDst);
-        if (fPaintPtr != nullptr) {
-            result[SKDEBUGCANVAS_ATTRIBUTE_PAINT] = MakeJsonPaint(*fPaintPtr, urlDataManager);
+        if (fPaint.isValid()) {
+            result[SKDEBUGCANVAS_ATTRIBUTE_PAINT] = MakeJsonPaint(*fPaint.get(), urlDataManager);
         }
         if (fConstraint == SkCanvas::kStrict_SrcRectConstraint) {
             result[SKDEBUGCANVAS_ATTRIBUTE_STRICT] = Json::Value(true);
@@ -2244,57 +1445,13 @@ Json::Value SkDrawBitmapRectCommand::toJSON(UrlDataManager& urlDataManager) cons
     return result;
 }
 
-SkDrawBitmapRectCommand* SkDrawBitmapRectCommand::fromJSON(Json::Value& command,
-                                                           UrlDataManager& urlDataManager) {
-    SkBitmap* bitmap = load_bitmap(command[SKDEBUGCANVAS_ATTRIBUTE_BITMAP], urlDataManager);
-    if (bitmap == nullptr) {
-        return nullptr;
-    }
-    SkRect dst;
-    extract_json_rect(command[SKDEBUGCANVAS_ATTRIBUTE_DST], &dst);
-    SkPaint* paintPtr;
-    SkPaint paint;
-    if (command.isMember(SKDEBUGCANVAS_ATTRIBUTE_PAINT)) {
-        extract_json_paint(command[SKDEBUGCANVAS_ATTRIBUTE_PAINT], urlDataManager, &paint);
-        paintPtr = &paint;
-    }
-    else {
-        paintPtr = nullptr;
-    }
-    SkCanvas::SrcRectConstraint constraint;
-    if (command.isMember(SKDEBUGCANVAS_ATTRIBUTE_STRICT) &&
-        command[SKDEBUGCANVAS_ATTRIBUTE_STRICT].asBool()) {
-        constraint = SkCanvas::kStrict_SrcRectConstraint;
-    }
-    else {
-        constraint = SkCanvas::kFast_SrcRectConstraint;
-    }
-    SkRect* srcPtr;
-    SkRect src;
-    if (command.isMember(SKDEBUGCANVAS_ATTRIBUTE_SRC)) {
-        extract_json_rect(command[SKDEBUGCANVAS_ATTRIBUTE_SRC], &src);
-        srcPtr = &src;
-    }
-    else {
-        srcPtr = nullptr;
-    }
-    SkDrawBitmapRectCommand* result = new SkDrawBitmapRectCommand(*bitmap, srcPtr, dst, paintPtr,
-                                                                  constraint);
-    delete bitmap;
-    return result;
-}
-
 SkDrawImageCommand::SkDrawImageCommand(const SkImage* image, SkScalar left, SkScalar top,
                                        const SkPaint* paint)
     : INHERITED(kDrawImage_OpType)
     , fImage(SkRef(image))
     , fLeft(left)
-    , fTop(top) {
-
-    if (paint) {
-        fPaint.set(*paint);
-    }
-}
+    , fTop(top)
+    , fPaint(paint) {}
 
 void SkDrawImageCommand::execute(SkCanvas* canvas) const {
     canvas->drawImage(fImage.get(), fLeft, fTop, fPaint.getMaybeNull());
@@ -2342,39 +1499,14 @@ Json::Value SkDrawImageCommand::toJSON(UrlDataManager& urlDataManager) const {
     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;
-    }
-    Json::Value point = command[SKDEBUGCANVAS_ATTRIBUTE_COORDS];
-    SkPaint* paintPtr;
-    SkPaint paint;
-    if (command.isMember(SKDEBUGCANVAS_ATTRIBUTE_PAINT)) {
-        extract_json_paint(command[SKDEBUGCANVAS_ATTRIBUTE_PAINT], urlDataManager, &paint);
-        paintPtr = &paint;
-    }
-    else {
-        paintPtr = nullptr;
-    }
-    SkDrawImageCommand* result = new SkDrawImageCommand(image.get(), point[0].asFloat(),
-                                                        point[1].asFloat(), paintPtr);
-    return result;
-}
-
 SkDrawImageLatticeCommand::SkDrawImageLatticeCommand(const SkImage* image,
                                                      const SkCanvas::Lattice& lattice,
                                                      const SkRect& dst, const SkPaint* paint)
     : INHERITED(kDrawImageLattice_OpType)
     , fImage(SkRef(image))
     , fLattice(lattice)
-    , fDst(dst) {
-
-      if (paint) {
-          fPaint.set(*paint);
-      }
-}
+    , fDst(dst)
+    , fPaint(paint) {}
 
 void SkDrawImageLatticeCommand::execute(SkCanvas* canvas) const {
     canvas->drawImageLattice(fImage.get(), fLattice, fDst, fPaint.getMaybeNull());
@@ -2408,28 +1540,15 @@ Json::Value SkDrawImageLatticeCommand::toJSON(UrlDataManager& urlDataManager) co
     return result;
 }
 
-SkDrawImageLatticeCommand* SkDrawImageLatticeCommand::fromJSON(Json::Value& command,
-                                                               UrlDataManager& urlDataManager) {
-    SkDEBUGFAIL("Not implemented yet.");
-    return nullptr;
-}
-
 SkDrawImageRectCommand::SkDrawImageRectCommand(const SkImage* image, const SkRect* src,
                                                const SkRect& dst, const SkPaint* paint,
                                                SkCanvas::SrcRectConstraint constraint)
     : INHERITED(kDrawImageRect_OpType)
     , fImage(SkRef(image))
+    , fSrc(src)
     , fDst(dst)
-    , fConstraint(constraint) {
-
-    if (src) {
-        fSrc.set(*src);
-    }
-
-    if (paint) {
-        fPaint.set(*paint);
-    }
-}
+    , fPaint(paint)
+    , fConstraint(constraint) {}
 
 void SkDrawImageRectCommand::execute(SkCanvas* canvas) const {
     canvas->legacy_drawImageRect(fImage.get(), fSrc.getMaybeNull(), fDst,
@@ -2469,61 +1588,16 @@ Json::Value SkDrawImageRectCommand::toJSON(UrlDataManager& urlDataManager) const
     return result;
 }
 
-SkDrawImageRectCommand* SkDrawImageRectCommand::fromJSON(Json::Value& command,
-                                                         UrlDataManager& urlDataManager) {
-    sk_sp<SkImage> image = load_image(command[SKDEBUGCANVAS_ATTRIBUTE_IMAGE], urlDataManager);
-    if (image == nullptr) {
-        return nullptr;
-    }
-    SkRect dst;
-    extract_json_rect(command[SKDEBUGCANVAS_ATTRIBUTE_DST], &dst);
-    SkPaint* paintPtr;
-    SkPaint paint;
-    if (command.isMember(SKDEBUGCANVAS_ATTRIBUTE_PAINT)) {
-        extract_json_paint(command[SKDEBUGCANVAS_ATTRIBUTE_PAINT], urlDataManager, &paint);
-        paintPtr = &paint;
-    }
-    else {
-        paintPtr = nullptr;
-    }
-    SkCanvas::SrcRectConstraint constraint;
-    if (command.isMember(SKDEBUGCANVAS_ATTRIBUTE_STRICT) &&
-        command[SKDEBUGCANVAS_ATTRIBUTE_STRICT].asBool()) {
-        constraint = SkCanvas::kStrict_SrcRectConstraint;
-    }
-    else {
-        constraint = SkCanvas::kFast_SrcRectConstraint;
-    }
-    SkRect* srcPtr;
-    SkRect src;
-    if (command.isMember(SKDEBUGCANVAS_ATTRIBUTE_SRC)) {
-        extract_json_rect(command[SKDEBUGCANVAS_ATTRIBUTE_SRC], &src);
-        srcPtr = &src;
-    }
-    else {
-        srcPtr = nullptr;
-    }
-    SkDrawImageRectCommand* result = new SkDrawImageRectCommand(image.get(), srcPtr, dst, paintPtr,
-                                                                constraint);
-    return result;
-}
-
 SkDrawImageNineCommand::SkDrawImageNineCommand(const SkImage* image, const SkIRect& center,
                                                const SkRect& dst, const SkPaint* paint)
-        : INHERITED(kDrawImageNine_OpType)
-        , fImage(SkRef(image))
-        , fCenter(center)
-        , fDst(dst) {
-    if (paint) {
-        fPaint = *paint;
-        fPaintPtr = &fPaint;
-    } else {
-        fPaintPtr = nullptr;
-    }
-}
+    : INHERITED(kDrawImageNine_OpType)
+    , fImage(SkRef(image))
+    , fCenter(center)
+    , fDst(dst)
+    , fPaint(paint) {}
 
 void SkDrawImageNineCommand::execute(SkCanvas* canvas) const {
-    canvas->drawImageNine(fImage.get(), fCenter, fDst, fPaintPtr);
+    canvas->drawImageNine(fImage.get(), fCenter, fDst, fPaint.getMaybeNull());
 }
 
 bool SkDrawImageNineCommand::render(SkCanvas* canvas) const {
@@ -2543,35 +1617,13 @@ Json::Value SkDrawImageNineCommand::toJSON(UrlDataManager& urlDataManager) const
         result[SKDEBUGCANVAS_ATTRIBUTE_IMAGE] = encoded;
         result[SKDEBUGCANVAS_ATTRIBUTE_CENTER] = MakeJsonIRect(fCenter);
         result[SKDEBUGCANVAS_ATTRIBUTE_DST] = MakeJsonRect(fDst);
-        if (fPaintPtr != nullptr) {
-            result[SKDEBUGCANVAS_ATTRIBUTE_PAINT] = MakeJsonPaint(*fPaintPtr, urlDataManager);
+        if (fPaint.isValid()) {
+            result[SKDEBUGCANVAS_ATTRIBUTE_PAINT] = MakeJsonPaint(*fPaint.get(), urlDataManager);
         }
     }
     return result;
 }
 
-SkDrawImageNineCommand* SkDrawImageNineCommand::fromJSON(Json::Value& command,
-                                                         UrlDataManager& urlDataManager) {
-    sk_sp<SkImage> image = load_image(command[SKDEBUGCANVAS_ATTRIBUTE_IMAGE], urlDataManager);
-    if (image == nullptr) {
-        return nullptr;
-    }
-    SkIRect center;
-    extract_json_irect(command[SKDEBUGCANVAS_ATTRIBUTE_CENTER], &center);
-    SkRect dst;
-    extract_json_rect(command[SKDEBUGCANVAS_ATTRIBUTE_DST], &dst);
-    SkPaint* paintPtr;
-    SkPaint paint;
-    if (command.isMember(SKDEBUGCANVAS_ATTRIBUTE_PAINT)) {
-        extract_json_paint(command[SKDEBUGCANVAS_ATTRIBUTE_PAINT], urlDataManager, &paint);
-        paintPtr = &paint;
-    } else {
-        paintPtr = nullptr;
-    }
-    SkDrawImageNineCommand* result = new SkDrawImageNineCommand(image.get(), center, dst, paintPtr);
-    return result;
-}
-
 SkDrawOvalCommand::SkDrawOvalCommand(const SkRect& oval, const SkPaint& paint)
     : INHERITED(kDrawOval_OpType) {
     fOval = oval;
@@ -2605,15 +1657,6 @@ Json::Value SkDrawOvalCommand::toJSON(UrlDataManager& urlDataManager) const {
     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);
-}
-
 SkDrawArcCommand::SkDrawArcCommand(const SkRect& oval, SkScalar startAngle, SkScalar sweepAngle,
                                    bool useCenter, const SkPaint& paint)
         : INHERITED(kDrawArc_OpType) {
@@ -2654,18 +1697,6 @@ Json::Value SkDrawArcCommand::toJSON(UrlDataManager& urlDataManager) const {
     return result;
 }
 
-SkDrawArcCommand* SkDrawArcCommand::fromJSON(Json::Value& command,
-                                             UrlDataManager& urlDataManager) {
-    SkRect coords;
-    extract_json_rect(command[SKDEBUGCANVAS_ATTRIBUTE_COORDS], &coords);
-    SkScalar startAngle = command[SKDEBUGCANVAS_ATTRIBUTE_STARTANGLE].asFloat();
-    SkScalar sweepAngle = command[SKDEBUGCANVAS_ATTRIBUTE_SWEEPANGLE].asFloat();
-    bool useCenter = command[SKDEBUGCANVAS_ATTRIBUTE_USECENTER].asBool();
-    SkPaint paint;
-    extract_json_paint(command[SKDEBUGCANVAS_ATTRIBUTE_PAINT], urlDataManager, &paint);
-    return new SkDrawArcCommand(coords, startAngle, sweepAngle, useCenter, paint);
-}
-
 SkDrawPaintCommand::SkDrawPaintCommand(const SkPaint& paint)
     : INHERITED(kDrawPaint_OpType) {
     fPaint = paint;
@@ -2687,13 +1718,6 @@ Json::Value SkDrawPaintCommand::toJSON(UrlDataManager& urlDataManager) const {
     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);
-}
-
 SkDrawPathCommand::SkDrawPathCommand(const SkPath& path, const SkPaint& paint)
     : INHERITED(kDrawPath_OpType) {
     fPath = path;
@@ -2716,15 +1740,6 @@ Json::Value SkDrawPathCommand::toJSON(UrlDataManager& urlDataManager) const {
     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);
-}
-
 SkDrawRegionCommand::SkDrawRegionCommand(const SkRegion& region, const SkPaint& paint)
     : INHERITED(kDrawRegion_OpType) {
     fRegion = region;
@@ -2747,28 +1762,13 @@ Json::Value SkDrawRegionCommand::toJSON(UrlDataManager& urlDataManager) const {
     return result;
 }
 
-SkDrawRegionCommand* SkDrawRegionCommand::fromJSON(Json::Value& command,
-                                                   UrlDataManager& urlDataManager) {
-    SkRegion region;
-    extract_json_region(command[SKDEBUGCANVAS_ATTRIBUTE_REGION], &region);
-    SkPaint paint;
-    extract_json_paint(command[SKDEBUGCANVAS_ATTRIBUTE_PAINT], urlDataManager, &paint);
-    return new SkDrawRegionCommand(region, paint);
-}
-
 SkBeginDrawPictureCommand::SkBeginDrawPictureCommand(const SkPicture* picture,
                                                      const SkMatrix* matrix,
                                                      const SkPaint* paint)
     : INHERITED(kBeginDrawPicture_OpType)
-    , fPicture(SkRef(picture)) {
-    if (matrix) {
-        fMatrix.set(*matrix);
-    }
-
-    if (paint) {
-        fPaint.set(*paint);
-    }
-}
+    , fPicture(SkRef(picture))
+    , fMatrix(matrix)
+    , fPaint(paint) {}
 
 void SkBeginDrawPictureCommand::execute(SkCanvas* canvas) const {
     if (fPaint.isValid()) {
@@ -2811,16 +1811,13 @@ void SkEndDrawPictureCommand::execute(SkCanvas* canvas) const {
 
 SkDrawPointsCommand::SkDrawPointsCommand(SkCanvas::PointMode mode, size_t count,
                                          const SkPoint pts[], const SkPaint& paint)
-    : INHERITED(kDrawPoints_OpType) {
-    fMode = mode;
-    fCount = count;
-    fPts = new SkPoint[count];
-    memcpy(fPts, pts, count * sizeof(SkPoint));
-    fPaint = paint;
-}
+    : INHERITED(kDrawPoints_OpType)
+    , fMode(mode)
+    , fPts(pts, count)
+    , fPaint(paint) {}
 
 void SkDrawPointsCommand::execute(SkCanvas* canvas) const {
-    canvas->drawPoints(fMode, fCount, fPts, fPaint);
+    canvas->drawPoints(fMode, fPts.count(), fPts.begin(), fPaint);
 }
 
 bool SkDrawPointsCommand::render(SkCanvas* canvas) const {
@@ -2830,7 +1827,7 @@ bool SkDrawPointsCommand::render(SkCanvas* canvas) const {
     SkRect bounds;
 
     bounds.setEmpty();
-    for (unsigned int i = 0; i < fCount; ++i) {
+    for (int i = 0; i < fPts.count(); ++i) {
         SkRectPriv::GrowToInclude(&bounds, fPts[i]);
     }
 
@@ -2840,7 +1837,7 @@ bool SkDrawPointsCommand::render(SkCanvas* canvas) const {
     p.setColor(SK_ColorBLACK);
     p.setStyle(SkPaint::kStroke_Style);
 
-    canvas->drawPoints(fMode, fCount, fPts, p);
+    canvas->drawPoints(fMode, fPts.count(), fPts.begin(), p);
     canvas->restore();
 
     return true;
@@ -2850,7 +1847,7 @@ 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++) {
+    for (int i = 0; i < fPts.count(); i++) {
         points.append(MakeJsonPoint(fPts[i]));
     }
     result[SKDEBUGCANVAS_ATTRIBUTE_POINTS] = points;
@@ -2858,36 +1855,6 @@ Json::Value SkDrawPointsCommand::toJSON(UrlDataManager& urlDataManager) const {
     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;
-    }
-    else if (!strcmp(jsonMode, SKDEBUGCANVAS_POINTMODE_LINES)) {
-        mode = SkCanvas::kLines_PointMode;
-    }
-    else if (!strcmp(jsonMode, SKDEBUGCANVAS_POINTMODE_POLYGON)) {
-        mode = SkCanvas::kPolygon_PointMode;
-    }
-    else {
-        SkASSERT(false);
-        return nullptr;
-    }
-    Json::Value jsonPoints = command[SKDEBUGCANVAS_ATTRIBUTE_POINTS];
-    int count = (int) jsonPoints.size();
-    SkPoint* points = (SkPoint*) sk_malloc_throw(count * sizeof(SkPoint));
-    for (int i = 0; i < count; i++) {
-        points[i] = SkPoint::Make(jsonPoints[i][0].asFloat(), jsonPoints[i][1].asFloat());
-    }
-    SkPaint paint;
-    extract_json_paint(command[SKDEBUGCANVAS_ATTRIBUTE_PAINT], urlDataManager, &paint);
-    SkDrawPointsCommand* result = new SkDrawPointsCommand(mode, count, points, paint);
-    sk_free(points);
-    return result;
-}
-
 SkDrawPosTextCommand::SkDrawPosTextCommand(const void* text, size_t byteLength,
                                            const SkPoint pos[], const SkPaint& paint)
     : INHERITED(kDrawPosText_OpType) {
@@ -2921,20 +1888,6 @@ Json::Value SkDrawPosTextCommand::toJSON(UrlDataManager& urlDataManager) const {
     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();
-    SkPoint* points = (SkPoint*) sk_malloc_throw(count * sizeof(SkPoint));
-    for (int i = 0; i < count; i++) {
-        points[i] = SkPoint::Make(coords[i][0].asFloat(), coords[i][1].asFloat());
-    }
-    return new SkDrawPosTextCommand(text, strlen(text), points, paint);
-}
-
 SkDrawPosTextHCommand::SkDrawPosTextHCommand(const void* text, size_t byteLength,
                                              const SkScalar xpos[], SkScalar constY,
                                              const SkPaint& paint)
@@ -2971,21 +1924,6 @@ Json::Value SkDrawPosTextHCommand::toJSON(UrlDataManager& urlDataManager) const
     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();
-    SkScalar* xpos = (SkScalar*) sk_malloc_throw(count * sizeof(SkScalar));
-    for (int i = 0; i < count; i++) {
-        xpos[i] = jsonXpos[i].asFloat();
-    }
-    SkScalar y = command[SKDEBUGCANVAS_ATTRIBUTE_Y].asFloat();
-    return new SkDrawPosTextHCommand(text, strlen(text), xpos, y, paint);
-}
-
 SkDrawTextBlobCommand::SkDrawTextBlobCommand(sk_sp<SkTextBlob> blob, SkScalar x, SkScalar y,
                                              const SkPaint& paint)
     : INHERITED(kDrawTextBlob_OpType)
@@ -3062,55 +2000,6 @@ Json::Value SkDrawTextBlobCommand::toJSON(UrlDataManager& urlDataManager) const
     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;
-        font.setTextEncoding(SkPaint::kGlyphID_TextEncoding);
-        extract_json_paint(run[SKDEBUGCANVAS_ATTRIBUTE_FONT], urlDataManager, &font);
-        Json::Value glyphs = run[SKDEBUGCANVAS_ATTRIBUTE_GLYPHS];
-        int count = glyphs.size();
-        Json::Value coords = run[SKDEBUGCANVAS_ATTRIBUTE_COORDS];
-        SkScalar x = coords[0].asFloat();
-        SkScalar y = coords[1].asFloat();
-        SkRect bounds;
-        extract_json_rect(command[SKDEBUGCANVAS_ATTRIBUTE_COORDS], &bounds);
-
-        if (run.isMember(SKDEBUGCANVAS_ATTRIBUTE_POSITIONS)) {
-            Json::Value positions = run[SKDEBUGCANVAS_ATTRIBUTE_POSITIONS];
-            if (positions.size() > 0 && positions[0].isNumeric()) {
-                SkTextBlobBuilder::RunBuffer buffer = builder.allocRunPosH(font, count, y, &bounds);
-                for (int j = 0; j < count; j++) {
-                    buffer.glyphs[j] = glyphs[j].asUInt();
-                    buffer.pos[j] = positions[j].asFloat();
-                }
-            }
-            else {
-                SkTextBlobBuilder::RunBuffer buffer = builder.allocRunPos(font, count, &bounds);
-                for (int j = 0; j < count; j++) {
-                    buffer.glyphs[j] = glyphs[j].asUInt();
-                    buffer.pos[j * 2] = positions[j][0].asFloat();
-                    buffer.pos[j * 2 + 1] = positions[j][1].asFloat();
-                }
-            }
-        }
-        else {
-            SkTextBlobBuilder::RunBuffer buffer = builder.allocRun(font, count, x, y, &bounds);
-            for (int j = 0; j < count; j++) {
-                buffer.glyphs[j] = glyphs[j].asUInt();
-            }
-        }
-    }
-    SkScalar x = command[SKDEBUGCANVAS_ATTRIBUTE_X].asFloat();
-    SkScalar y = command[SKDEBUGCANVAS_ATTRIBUTE_Y].asFloat();
-    SkPaint paint;
-    extract_json_paint(command[SKDEBUGCANVAS_ATTRIBUTE_PAINT], urlDataManager, &paint);
-    return new SkDrawTextBlobCommand(builder.make(), x, y, paint);
-}
-
 SkDrawPatchCommand::SkDrawPatchCommand(const SkPoint cubics[12], const SkColor colors[4],
                                        const SkPoint texCoords[4], SkBlendMode bmode,
                                        const SkPaint& paint)
@@ -3162,45 +2051,6 @@ Json::Value SkDrawPatchCommand::toJSON(UrlDataManager& urlDataManager) const {
     return result;
 }
 
-SkDrawPatchCommand* SkDrawPatchCommand::fromJSON(Json::Value& command,
-                                                 UrlDataManager& urlDataManager) {
-    Json::Value jsonCubics = command[SKDEBUGCANVAS_ATTRIBUTE_CUBICS];
-    SkPoint cubics[12];
-    for (int i = 0; i < 12; i++) {
-        cubics[i] = get_json_point(jsonCubics[i]);
-    }
-    SkColor* colorsPtr;
-    SkColor colors[4];
-    if (command.isMember(SKDEBUGCANVAS_ATTRIBUTE_COLORS)) {
-        Json::Value jsonColors = command[SKDEBUGCANVAS_ATTRIBUTE_COLORS];
-        for (int i = 0; i < 4; i++) {
-            colors[i] = get_json_color(jsonColors[i]);
-        }
-        colorsPtr = colors;
-    }
-    else {
-        colorsPtr = nullptr;
-    }
-    SkPoint* texCoordsPtr;
-    SkPoint texCoords[4];
-    if (command.isMember(SKDEBUGCANVAS_ATTRIBUTE_TEXTURECOORDS)) {
-        Json::Value jsonTexCoords = command[SKDEBUGCANVAS_ATTRIBUTE_TEXTURECOORDS];
-        for (int i = 0; i < 4; i++) {
-            texCoords[i] = get_json_point(jsonTexCoords[i]);
-        }
-        texCoordsPtr = texCoords;
-    }
-    else {
-        texCoordsPtr = nullptr;
-    }
-
-    SkBlendMode bmode = SkBlendMode::kSrcOver; // TODO: extract from json
-
-    SkPaint paint;
-    extract_json_paint(command[SKDEBUGCANVAS_ATTRIBUTE_PAINT], urlDataManager, &paint);
-    return new SkDrawPatchCommand(cubics, colorsPtr, texCoordsPtr, bmode, paint);
-}
-
 SkDrawRectCommand::SkDrawRectCommand(const SkRect& rect, const SkPaint& paint)
     : INHERITED(kDrawRect_OpType) {
     fRect = rect;
@@ -3222,15 +2072,6 @@ Json::Value SkDrawRectCommand::toJSON(UrlDataManager& urlDataManager) const {
     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);
-}
-
 SkDrawRRectCommand::SkDrawRRectCommand(const SkRRect& rrect, const SkPaint& paint)
     : INHERITED(kDrawRRect_OpType) {
     fRRect = rrect;
@@ -3253,15 +2094,6 @@ Json::Value SkDrawRRectCommand::toJSON(UrlDataManager& urlDataManager) const {
     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);
-}
-
 SkDrawDRRectCommand::SkDrawDRRectCommand(const SkRRect& outer,
                                          const SkRRect& inner,
                                          const SkPaint& paint)
@@ -3288,17 +2120,6 @@ Json::Value SkDrawDRRectCommand::toJSON(UrlDataManager& urlDataManager) const {
     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;
-    extract_json_paint(command[SKDEBUGCANVAS_ATTRIBUTE_PAINT], urlDataManager, &paint);
-    return new SkDrawDRRectCommand(outer, inner, paint);
-}
-
 SkDrawShadowCommand::SkDrawShadowCommand(const SkPath& path, const SkDrawShadowRec& rec)
         : INHERITED(kDrawShadow_OpType) {
     fPath = path;
@@ -3333,29 +2154,6 @@ Json::Value SkDrawShadowCommand::toJSON(UrlDataManager& urlDataManager) const {
     return result;
 }
 
-SkDrawShadowCommand* SkDrawShadowCommand::fromJSON(Json::Value& command,
-                                               UrlDataManager& urlDataManager) {
-    SkPath path;
-    extract_json_path(command[SKDEBUGCANVAS_ATTRIBUTE_PATH], &path);
-    SkDrawShadowRec rec;
-    rec.fZPlaneParams = get_json_point3(command[SKDEBUGCANVAS_ATTRIBUTE_ZPLANE]);
-    rec.fLightPos = get_json_point3(command[SKDEBUGCANVAS_ATTRIBUTE_LIGHTPOSITION]);
-    rec.fLightRadius = command[SKDEBUGCANVAS_ATTRIBUTE_LIGHTRADIUS].asFloat();
-    rec.fAmbientColor = get_json_color(command[SKDEBUGCANVAS_ATTRIBUTE_AMBIENTCOLOR]);
-    rec.fSpotColor = get_json_color(command[SKDEBUGCANVAS_ATTRIBUTE_SPOTCOLOR]);
-
-    rec.fFlags = SkShadowFlags::kNone_ShadowFlag;
-    if (command.isMember(SKDEBUGCANVAS_SHADOWFLAG_TRANSPARENT_OCC)
-        && command[SKDEBUGCANVAS_SHADOWFLAG_TRANSPARENT_OCC].asBool()) {
-        rec.fFlags |= SkShadowFlags::kTransparentOccluder_ShadowFlag;
-    }
-    if (command.isMember(SKDEBUGCANVAS_SHADOWFLAG_GEOMETRIC_ONLY)
-        && command[SKDEBUGCANVAS_SHADOWFLAG_GEOMETRIC_ONLY].asBool()) {
-        rec.fFlags |= SkShadowFlags::kGeometricOnly_ShadowFlag;
-    }
-    return new SkDrawShadowCommand(path, rec);
-}
-
 SkDrawTextCommand::SkDrawTextCommand(const void* text, size_t byteLength, SkScalar x, SkScalar y,
                                      const SkPaint& paint)
     : INHERITED(kDrawText_OpType) {
@@ -3381,38 +2179,22 @@ Json::Value SkDrawTextCommand::toJSON(UrlDataManager& urlDataManager) const {
     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(),
-                                 paint);
-}
-
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
 SkDrawTextOnPathCommand::SkDrawTextOnPathCommand(const void* text, size_t byteLength,
                                                  const SkPath& path, const SkMatrix* matrix,
                                                  const SkPaint& paint)
-    : INHERITED(kDrawTextOnPath_OpType) {
+    : INHERITED(kDrawTextOnPath_OpType)
+    , fMatrix(matrix) {
     fText = new char[byteLength];
     memcpy(fText, text, byteLength);
     fByteLength = byteLength;
     fPath = path;
-    if (matrix) {
-        fMatrix = *matrix;
-    } else {
-        fMatrix.setIdentity();
-    }
     fPaint = paint;
 }
 
 void SkDrawTextOnPathCommand::execute(SkCanvas* canvas) const {
-    canvas->drawTextOnPath(fText, fByteLength, fPath,
-                           fMatrix.isIdentity() ? nullptr : &fMatrix,
-                           fPaint);
+    canvas->drawTextOnPath(fText, fByteLength, fPath, fMatrix.getMaybeNull(), fPaint);
 }
 
 Json::Value SkDrawTextOnPathCommand::toJSON(UrlDataManager& urlDataManager) const {
@@ -3421,38 +2203,20 @@ Json::Value SkDrawTextOnPathCommand::toJSON(UrlDataManager& urlDataManager) cons
                                                        ((const char*) fText) + fByteLength);
     Json::Value coords(Json::arrayValue);
     result[SKDEBUGCANVAS_ATTRIBUTE_PATH] = MakeJsonPath(fPath);
-    if (!fMatrix.isIdentity()) {
-        result[SKDEBUGCANVAS_ATTRIBUTE_MATRIX] = MakeJsonMatrix(fMatrix);
+    if (fMatrix.isValid()) {
+        result[SKDEBUGCANVAS_ATTRIBUTE_MATRIX] = MakeJsonMatrix(*fMatrix.get());
     }
     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);
-    SkMatrix* matrixPtr;
-    SkMatrix matrix;
-    if (command.isMember(SKDEBUGCANVAS_ATTRIBUTE_MATRIX)) {
-        extract_json_matrix(command[SKDEBUGCANVAS_ATTRIBUTE_MATRIX], &matrix);
-        matrixPtr = &matrix;
-    }
-    else {
-        matrixPtr = nullptr;
-    }
-    return new SkDrawTextOnPathCommand(text, strlen(text), path, matrixPtr, paint);
-}
-
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
 SkDrawTextRSXformCommand::SkDrawTextRSXformCommand(const void* text, size_t byteLength,
                                                    const SkRSXform xform[], const SkRect* cull,
                                                    const SkPaint& paint)
     : INHERITED(kDrawTextRSXform_OpType)
+    , fCull(cull)
 {
     fText = new char[byteLength];
     memcpy(fText, text, byteLength);
@@ -3460,17 +2224,11 @@ SkDrawTextRSXformCommand::SkDrawTextRSXformCommand(const void* text, size_t byte
     int count = paint.countText(text, byteLength);
     fXform = new SkRSXform[count];
     memcpy(fXform, xform, count * sizeof(SkRSXform));
-    if (cull) {
-        fCullStorage = *cull;
-        fCull = &fCullStorage;
-    } else {
-        fCull = nullptr;
-    }
     fPaint = paint;
 }
 
 void SkDrawTextRSXformCommand::execute(SkCanvas* canvas) const {
-    canvas->drawTextRSXform(fText, fByteLength, fXform, fCull, fPaint);
+    canvas->drawTextRSXform(fText, fByteLength, fXform, fCull.getMaybeNull(), fPaint);
 }
 
 Json::Value SkDrawTextRSXformCommand::toJSON(UrlDataManager& urlDataManager) const {
@@ -3481,23 +2239,6 @@ Json::Value SkDrawTextRSXformCommand::toJSON(UrlDataManager& urlDataManager) con
     return result;
 }
 
-SkDrawTextRSXformCommand* SkDrawTextRSXformCommand::fromJSON(Json::Value& command,
-                                                             UrlDataManager& urlDataManager) {
-    const char* text = command[SKDEBUGCANVAS_ATTRIBUTE_TEXT].asCString();
-    size_t byteLength = strlen(text);
-    SkPaint paint;
-    extract_json_paint(command[SKDEBUGCANVAS_ATTRIBUTE_PAINT], urlDataManager, &paint);
-
-    // TODO: handle xform and cull
-    int count = paint.countText(text, byteLength);
-    SkAutoTArray<SkRSXform> xform(count);
-    for (int i = 0; i < count; ++i) {
-        xform[i].fSCos = 1;
-        xform[i].fSSin = xform[i].fTx = xform[i].fTy = 0;
-    }
-    return new SkDrawTextRSXformCommand(text, byteLength, &xform[0], nullptr, paint);
-}
-
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
 SkDrawVerticesCommand::SkDrawVerticesCommand(sk_sp<SkVertices> vertices, SkBlendMode bmode,
@@ -3541,10 +2282,6 @@ void SkRestoreCommand::execute(SkCanvas* canvas) const {
     canvas->restore();
 }
 
-SkRestoreCommand* SkRestoreCommand::fromJSON(Json::Value& command, UrlDataManager& urlDataManager) {
-    return new SkRestoreCommand();
-}
-
 SkSaveCommand::SkSaveCommand()
     : INHERITED(kSave_OpType) {
 }
@@ -3553,58 +2290,29 @@ void SkSaveCommand::execute(SkCanvas* canvas) const {
     canvas->save();
 }
 
-SkSaveCommand* SkSaveCommand::fromJSON(Json::Value& command, UrlDataManager& urlDataManager) {
-    return new SkSaveCommand();
-}
-
 SkSaveLayerCommand::SkSaveLayerCommand(const SkCanvas::SaveLayerRec& rec)
-    : INHERITED(kSaveLayer_OpType) {
-    if (rec.fBounds) {
-        fBounds = *rec.fBounds;
-    } else {
-        fBounds.setEmpty();
-    }
-
-    if (rec.fPaint) {
-        fPaint = *rec.fPaint;
-        fPaintPtr = &fPaint;
-    } else {
-        fPaintPtr = nullptr;
-    }
-    fSaveLayerFlags = rec.fSaveLayerFlags;
-
-    if (rec.fBackdrop) {
-        fBackdrop = rec.fBackdrop;
-        fBackdrop->ref();
-    } else {
-        fBackdrop = nullptr;
-    }
-}
-
-SkSaveLayerCommand::~SkSaveLayerCommand() {
-    if (fBackdrop != nullptr) {
-        fBackdrop->unref();
-    }
-}
+    : INHERITED(kSaveLayer_OpType)
+    , fBounds(rec.fBounds)
+    , fPaint(rec.fPaint)
+    , fBackdrop(SkSafeRef(rec.fBackdrop))
+    , fSaveLayerFlags(rec.fSaveLayerFlags) {}
 
 void SkSaveLayerCommand::execute(SkCanvas* canvas) const {
-    canvas->saveLayer(SkCanvas::SaveLayerRec(fBounds.isEmpty() ? nullptr : &fBounds,
-                                             fPaintPtr,
+    canvas->saveLayer(SkCanvas::SaveLayerRec(fBounds.getMaybeNull(), fPaint.getMaybeNull(),
                                              fSaveLayerFlags));
 }
 
 Json::Value SkSaveLayerCommand::toJSON(UrlDataManager& urlDataManager) const {
     Json::Value result = INHERITED::toJSON(urlDataManager);
-    if (!fBounds.isEmpty()) {
-        result[SKDEBUGCANVAS_ATTRIBUTE_BOUNDS] = MakeJsonRect(fBounds);
+    if (fBounds.isValid()) {
+        result[SKDEBUGCANVAS_ATTRIBUTE_BOUNDS] = MakeJsonRect(*fBounds.get());
     }
-    if (fPaintPtr != nullptr) {
-        result[SKDEBUGCANVAS_ATTRIBUTE_PAINT] = MakeJsonPaint(*fPaintPtr,
-                                                                urlDataManager);
+    if (fPaint.isValid()) {
+        result[SKDEBUGCANVAS_ATTRIBUTE_PAINT] = MakeJsonPaint(*fPaint.get(), urlDataManager);
     }
     if (fBackdrop != nullptr) {
         Json::Value jsonBackdrop;
-        flatten(fBackdrop, &jsonBackdrop, urlDataManager);
+        flatten(fBackdrop.get(), &jsonBackdrop, urlDataManager);
         result[SKDEBUGCANVAS_ATTRIBUTE_BACKDROP] = jsonBackdrop;
     }
     if (fSaveLayerFlags != 0) {
@@ -3614,30 +2322,6 @@ Json::Value SkSaveLayerCommand::toJSON(UrlDataManager& urlDataManager) const {
     return result;
 }
 
-SkSaveLayerCommand* SkSaveLayerCommand::fromJSON(Json::Value& command,
-                                                 UrlDataManager& urlDataManager) {
-    SkCanvas::SaveLayerRec rec;
-    SkRect bounds;
-    if (command.isMember(SKDEBUGCANVAS_ATTRIBUTE_BOUNDS)) {
-        extract_json_rect(command[SKDEBUGCANVAS_ATTRIBUTE_BOUNDS], &bounds);
-        rec.fBounds = &bounds;
-    }
-    SkPaint paint;
-    if (command.isMember(SKDEBUGCANVAS_ATTRIBUTE_PAINT)) {
-        extract_json_paint(command[SKDEBUGCANVAS_ATTRIBUTE_PAINT], urlDataManager, &paint);
-        rec.fPaint = &paint;
-    }
-    if (command.isMember(SKDEBUGCANVAS_ATTRIBUTE_BACKDROP)) {
-        Json::Value backdrop = command[SKDEBUGCANVAS_ATTRIBUTE_BACKDROP];
-        rec.fBackdrop = (SkImageFilter*) load_flattenable(backdrop, urlDataManager);
-    }
-    SkSaveLayerCommand* result = new SkSaveLayerCommand(rec);
-    if (rec.fBackdrop != nullptr) {
-        rec.fBackdrop->unref();
-    }
-    return result;
-}
-
 SkSetMatrixCommand::SkSetMatrixCommand(const SkMatrix& matrix)
     : INHERITED(kSetMatrix_OpType) {
     fMatrix = matrix;
@@ -3652,10 +2336,3 @@ Json::Value SkSetMatrixCommand::toJSON(UrlDataManager& urlDataManager) const {
     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);
-}
diff --git a/tools/debugger/SkDrawCommand.h b/tools/debugger/SkDrawCommand.h
index 5a14c4fbff..7bac9e4858 100644
--- a/tools/debugger/SkDrawCommand.h
+++ b/tools/debugger/SkDrawCommand.h
@@ -93,12 +93,6 @@ public:
 
     virtual Json::Value toJSON(UrlDataManager& urlDataManager) const;
 
-    /* Converts a JSON representation of a command into a newly-allocated SkDrawCommand object. It
-     * is the caller's responsibility to delete this object. This method may return null if an error
-     * occurs.
-     */
-    static SkDrawCommand* fromJSON(Json::Value& command, UrlDataManager& urlDataManager);
-
     static const char* GetCommandString(OpType type);
 
     // Helper methods for converting things to JSON
@@ -132,7 +126,6 @@ class SkRestoreCommand : public SkDrawCommand {
 public:
     SkRestoreCommand();
     void execute(SkCanvas* canvas) const override;
-    static SkRestoreCommand* fromJSON(Json::Value& command, UrlDataManager& urlDataManager);
 
 private:
     typedef SkDrawCommand INHERITED;
@@ -143,7 +136,6 @@ public:
     SkClearCommand(SkColor color);
     void execute(SkCanvas* canvas) const override;
     Json::Value toJSON(UrlDataManager& urlDataManager) const override;
-    static SkClearCommand* fromJSON(Json::Value& command, UrlDataManager& urlDataManager);
 
 private:
     SkColor fColor;
@@ -157,7 +149,6 @@ public:
     void execute(SkCanvas* canvas) const override;
     bool render(SkCanvas* canvas) const override;
     Json::Value toJSON(UrlDataManager& urlDataManager) const override;
-    static SkClipPathCommand* fromJSON(Json::Value& command, UrlDataManager& urlDataManager);
 
 private:
     SkPath   fPath;
@@ -172,7 +163,6 @@ public:
     SkClipRegionCommand(const SkRegion& region, SkClipOp op);
     void execute(SkCanvas* canvas) const override;
     Json::Value toJSON(UrlDataManager& urlDataManager) const override;
-    static SkClipRegionCommand* fromJSON(Json::Value& command, UrlDataManager& urlDataManager);
 
 private:
     SkRegion fRegion;
@@ -186,11 +176,6 @@ public:
     SkClipRectCommand(const SkRect& rect, SkClipOp op, bool doAA);
     void execute(SkCanvas* canvas) const override;
     Json::Value toJSON(UrlDataManager& urlDataManager) const override;
-    static SkClipRectCommand* fromJSON(Json::Value& command, UrlDataManager& urlDataManager);
-
-    const SkRect& rect() const { return fRect; }
-    SkClipOp op() const { return fOp; }
-    bool doAA() const { return fDoAA; }
 
 private:
     SkRect   fRect;
@@ -206,11 +191,6 @@ public:
     void execute(SkCanvas* canvas) const override;
     bool render(SkCanvas* canvas) const override;
     Json::Value toJSON(UrlDataManager& urlDataManager) const override;
-    static SkClipRRectCommand* fromJSON(Json::Value& command, UrlDataManager& urlDataManager);
-
-    const SkRRect& rrect() const { return fRRect; }
-    SkClipOp op() const { return fOp; }
-    bool doAA() const { return fDoAA; }
 
 private:
     SkRRect  fRRect;
@@ -225,7 +205,6 @@ public:
     SkConcatCommand(const SkMatrix& matrix);
     void execute(SkCanvas* canvas) const override;
     Json::Value toJSON(UrlDataManager& urlDataManager) const override;
-    static SkConcatCommand* fromJSON(Json::Value& command, UrlDataManager& urlDataManager);
 
 private:
     SkMatrix fMatrix;
@@ -238,7 +217,6 @@ public:
     SkDrawAnnotationCommand(const SkRect&, const char key[], sk_sp<SkData> value);
     void execute(SkCanvas* canvas) const override;
     Json::Value toJSON(UrlDataManager& urlDataManager) const override;
-    static SkDrawAnnotationCommand* fromJSON(Json::Value& command, UrlDataManager& urlDataManager);
 
 private:
     SkRect          fRect;
@@ -255,14 +233,12 @@ public:
     void execute(SkCanvas* canvas) const override;
     bool render(SkCanvas* canvas) const override;
     Json::Value toJSON(UrlDataManager& urlDataManager) const override;
-    static SkDrawBitmapCommand* fromJSON(Json::Value& command, UrlDataManager& urlDataManager);
 
 private:
-    SkBitmap fBitmap;
-    SkScalar fLeft;
-    SkScalar fTop;
-    SkPaint  fPaint;
-    SkPaint* fPaintPtr;
+    SkBitmap         fBitmap;
+    SkScalar         fLeft;
+    SkScalar         fTop;
+    SkTLazy<SkPaint> fPaint;
 
     typedef SkDrawCommand INHERITED;
 };
@@ -274,8 +250,6 @@ public:
     void execute(SkCanvas* canvas) const override;
     bool render(SkCanvas* canvas) const override;
     Json::Value toJSON(UrlDataManager& urlDataManager) const override;
-    static SkDrawBitmapLatticeCommand* fromJSON(Json::Value& command,
-                                                UrlDataManager& urlDataManager);
 
 private:
     SkBitmap          fBitmap;
@@ -293,14 +267,12 @@ public:
     void execute(SkCanvas* canvas) const override;
     bool render(SkCanvas* canvas) const override;
     Json::Value toJSON(UrlDataManager& urlDataManager) const override;
-    static SkDrawBitmapNineCommand* fromJSON(Json::Value& command, UrlDataManager& urlDataManager);
 
 private:
-    SkBitmap fBitmap;
-    SkIRect  fCenter;
-    SkRect   fDst;
-    SkPaint  fPaint;
-    SkPaint* fPaintPtr;
+    SkBitmap         fBitmap;
+    SkIRect          fCenter;
+    SkRect           fDst;
+    SkTLazy<SkPaint> fPaint;
 
     typedef SkDrawCommand INHERITED;
 };
@@ -313,34 +285,12 @@ public:
     void execute(SkCanvas* canvas) const override;
     bool render(SkCanvas* canvas) const override;
     Json::Value toJSON(UrlDataManager& urlDataManager) const override;
-    static SkDrawBitmapRectCommand* fromJSON(Json::Value& command, UrlDataManager& urlDataManager);
-
-    const SkBitmap& bitmap() const { return fBitmap; }
-
-    // The non-const 'paint' method allows modification of this object's
-    // SkPaint. For this reason the ctor and setPaint method make a local copy.
-    // The 'fPaintPtr' member acts a signal that the local SkPaint is valid
-    // (since only an SkPaint* is passed into the ctor).
-    const SkPaint* paint() const { return fPaintPtr; }
-    SkPaint* paint() { return fPaintPtr; }
-
-    void setPaint(const SkPaint& paint) { fPaint = paint; fPaintPtr = &fPaint; }
-
-    const SkRect* srcRect() const { return fSrc.isEmpty() ? nullptr : &fSrc; }
-    void setSrcRect(const SkRect& src) { fSrc = src; }
-
-    const SkRect& dstRect() const { return fDst; }
-    void setDstRect(const SkRect& dst) { fDst = dst; }
-
-    SkCanvas::SrcRectConstraint constraint() const { return fConstraint; }
-    void setConstraint(SkCanvas::SrcRectConstraint constraint) { fConstraint = constraint; }
 
 private:
     SkBitmap                      fBitmap;
-    SkRect                        fSrc;
+    SkTLazy<SkRect>               fSrc;
     SkRect                        fDst;
-    SkPaint                       fPaint;
-    SkPaint*                      fPaintPtr;
+    SkTLazy<SkPaint>              fPaint;
     SkCanvas::SrcRectConstraint   fConstraint;
 
     typedef SkDrawCommand INHERITED;
@@ -352,7 +302,6 @@ public:
     void execute(SkCanvas* canvas) const override;
     bool render(SkCanvas* canvas) const override;
     Json::Value toJSON(UrlDataManager& urlDataManager) const override;
-    static SkDrawImageCommand* fromJSON(Json::Value& command, UrlDataManager& urlDataManager);
 
 private:
     sk_sp<const SkImage> fImage;
@@ -370,8 +319,6 @@ public:
     void execute(SkCanvas* canvas) const override;
     bool render(SkCanvas* canvas) const override;
     Json::Value toJSON(UrlDataManager& urlDataManager) const override;
-    static SkDrawImageLatticeCommand* fromJSON(Json::Value& command,
-                                               UrlDataManager& urlDataManager);
 
 private:
     sk_sp<const SkImage>        fImage;
@@ -389,14 +336,12 @@ public:
     void execute(SkCanvas* canvas) const override;
     bool render(SkCanvas* canvas) const override;
     Json::Value toJSON(UrlDataManager& urlDataManager) const override;
-    static SkDrawImageNineCommand* fromJSON(Json::Value& command, UrlDataManager& urlDataManager);
 
 private:
     sk_sp<const SkImage> fImage;
     SkIRect              fCenter;
     SkRect               fDst;
-    SkPaint              fPaint;
-    SkPaint*             fPaintPtr;
+    SkTLazy<SkPaint>     fPaint;
 
     typedef SkDrawCommand INHERITED;
 };
@@ -408,7 +353,6 @@ public:
     void execute(SkCanvas* canvas) const override;
     bool render(SkCanvas* canvas) const override;
     Json::Value toJSON(UrlDataManager& urlDataManager) const override;
-    static SkDrawImageRectCommand* fromJSON(Json::Value& command, UrlDataManager& urlDataManager);
 
 private:
     sk_sp<const SkImage>        fImage;
@@ -426,7 +370,6 @@ public:
     void execute(SkCanvas* canvas) const override;
     bool render(SkCanvas* canvas) const override;
     Json::Value toJSON(UrlDataManager& urlDataManager) const override;
-    static SkDrawOvalCommand* fromJSON(Json::Value& command, UrlDataManager& urlDataManager);
 
 private:
     SkRect  fOval;
@@ -442,7 +385,6 @@ public:
     void execute(SkCanvas* canvas) const override;
     bool render(SkCanvas* canvas) const override;
     Json::Value toJSON(UrlDataManager& urlDataManager) const override;
-    static SkDrawArcCommand* fromJSON(Json::Value& command, UrlDataManager& urlDataManager);
 
 private:
     SkRect   fOval;
@@ -460,7 +402,6 @@ public:
     void execute(SkCanvas* canvas) const override;
     bool render(SkCanvas* canvas) const override;
     Json::Value toJSON(UrlDataManager& urlDataManager) const override;
-    static SkDrawPaintCommand* fromJSON(Json::Value& command, UrlDataManager& urlDataManager);
 
 private:
     SkPaint fPaint;
@@ -474,7 +415,6 @@ public:
     void execute(SkCanvas* canvas) const override;
     bool render(SkCanvas* canvas) const override;
     Json::Value toJSON(UrlDataManager& urlDataManager) const override;
-    static SkDrawPathCommand* fromJSON(Json::Value& command, UrlDataManager& urlDataManager);
 
 private:
     SkPath   fPath;
@@ -516,16 +456,13 @@ class SkDrawPointsCommand : public SkDrawCommand {
 public:
     SkDrawPointsCommand(SkCanvas::PointMode mode, size_t count, const SkPoint pts[],
                         const SkPaint& paint);
-    ~SkDrawPointsCommand() override { delete [] fPts; }
     void execute(SkCanvas* canvas) const override;
     bool render(SkCanvas* canvas) const override;
     Json::Value toJSON(UrlDataManager& urlDataManager) const override;
-    static SkDrawPointsCommand* fromJSON(Json::Value& command, UrlDataManager& urlDataManager);
 
 private:
     SkCanvas::PointMode fMode;
-    size_t              fCount;
-    SkPoint*            fPts;
+    SkTDArray<SkPoint>  fPts;
     SkPaint             fPaint;
 
     typedef SkDrawCommand INHERITED;
@@ -537,7 +474,6 @@ public:
     void execute(SkCanvas* canvas) const override;
     bool render(SkCanvas* canvas) const override;
     Json::Value toJSON(UrlDataManager& urlDataManager) const override;
-    static SkDrawRegionCommand* fromJSON(Json::Value& command, UrlDataManager& urlDataManager);
 
 private:
     SkRegion fRegion;
@@ -553,7 +489,6 @@ public:
     ~SkDrawTextCommand() override { delete [] fText; }
     void execute(SkCanvas* canvas) const override;
     Json::Value toJSON(UrlDataManager& urlDataManager) const override;
-    static SkDrawTextCommand* fromJSON(Json::Value& command, UrlDataManager& urlDataManager);
 
 private:
     char*    fText;
@@ -572,7 +507,6 @@ public:
     ~SkDrawPosTextCommand() override { delete [] fPos; delete [] fText; }
     void execute(SkCanvas* canvas) const override;
     Json::Value toJSON(UrlDataManager& urlDataManager) const override;
-    static SkDrawPosTextCommand* fromJSON(Json::Value& command, UrlDataManager& urlDataManager);
 
 private:
     char*    fText;
@@ -590,14 +524,13 @@ public:
     ~SkDrawTextOnPathCommand() override { delete [] fText; }
     void execute(SkCanvas* canvas) const override;
     Json::Value toJSON(UrlDataManager& urlDataManager) const override;
-    static SkDrawTextOnPathCommand* fromJSON(Json::Value& command, UrlDataManager& urlDataManager);
 
 private:
-    char*    fText;
-    size_t   fByteLength;
-    SkPath   fPath;
-    SkMatrix fMatrix;
-    SkPaint  fPaint;
+    char*             fText;
+    size_t            fByteLength;
+    SkPath            fPath;
+    SkTLazy<SkMatrix> fMatrix;
+    SkPaint           fPaint;
 
     typedef SkDrawCommand INHERITED;
 };
@@ -609,15 +542,13 @@ public:
     ~SkDrawTextRSXformCommand() override { delete[] fText; delete[] fXform; }
     void execute(SkCanvas* canvas) const override;
     Json::Value toJSON(UrlDataManager& urlDataManager) const override;
-    static SkDrawTextRSXformCommand* fromJSON(Json::Value& command, UrlDataManager& urlDataManager);
 
 private:
-    char*       fText;
-    size_t      fByteLength;
-    SkRSXform*  fXform;
-    SkRect*     fCull;
-    SkRect      fCullStorage;
-    SkPaint     fPaint;
+    char*           fText;
+    size_t          fByteLength;
+    SkRSXform*      fXform;
+    SkTLazy<SkRect> fCull;
+    SkPaint         fPaint;
 
     typedef SkDrawCommand INHERITED;
 };
@@ -629,7 +560,6 @@ public:
     ~SkDrawPosTextHCommand() override { delete [] fXpos; delete [] fText; }
     void execute(SkCanvas* canvas) const override;
     Json::Value toJSON(UrlDataManager& urlDataManager) const override;
-    static SkDrawPosTextHCommand* fromJSON(Json::Value& command, UrlDataManager& urlDataManager);
 
 private:
     SkScalar* fXpos;
@@ -648,7 +578,6 @@ public:
     void execute(SkCanvas* canvas) const override;
     bool render(SkCanvas* canvas) const override;
     Json::Value toJSON(UrlDataManager& urlDataManager) const override;
-    static SkDrawTextBlobCommand* fromJSON(Json::Value& command, UrlDataManager& urlDataManager);
 
 private:
     sk_sp<SkTextBlob> fBlob;
@@ -666,7 +595,6 @@ public:
                        const SkPaint& paint);
     void execute(SkCanvas* canvas) const override;
     Json::Value toJSON(UrlDataManager& urlDataManager) const override;
-    static SkDrawPatchCommand* fromJSON(Json::Value& command, UrlDataManager& urlDataManager);
 
 private:
     SkPoint fCubics[12];
@@ -686,10 +614,7 @@ public:
     SkDrawRectCommand(const SkRect& rect, const SkPaint& paint);
     void execute(SkCanvas* canvas) const override;
     Json::Value toJSON(UrlDataManager& urlDataManager) const override;
-    static SkDrawRectCommand* fromJSON(Json::Value& command, UrlDataManager& urlDataManager);
 
-    const SkRect& rect() const   { return fRect; }
-    const SkPaint& paint() const { return fPaint; }
 private:
     SkRect  fRect;
     SkPaint fPaint;
@@ -703,7 +628,6 @@ public:
     void execute(SkCanvas* canvas) const override;
     bool render(SkCanvas* canvas) const override;
     Json::Value toJSON(UrlDataManager& urlDataManager) const override;
-    static SkDrawRRectCommand* fromJSON(Json::Value& command, UrlDataManager& urlDataManager);
 
 private:
     SkRRect fRRect;
@@ -719,7 +643,6 @@ public:
     void execute(SkCanvas* canvas) const override;
     bool render(SkCanvas* canvas) const override;
     Json::Value toJSON(UrlDataManager& urlDataManager) const override;
-    static SkDrawDRRectCommand* fromJSON(Json::Value& command, UrlDataManager& urlDataManager);
 
 private:
     SkRRect fOuter;
@@ -766,7 +689,6 @@ class SkSaveCommand : public SkDrawCommand {
 public:
     SkSaveCommand();
     void execute(SkCanvas* canvas) const override;
-    static SkSaveCommand* fromJSON(Json::Value& command, UrlDataManager& urlDataManager);
 
 private:
     typedef SkDrawCommand INHERITED;
@@ -775,19 +697,14 @@ private:
 class SkSaveLayerCommand : public SkDrawCommand {
 public:
     SkSaveLayerCommand(const SkCanvas::SaveLayerRec&);
-    ~SkSaveLayerCommand() override;
     void execute(SkCanvas* canvas) const override;
     Json::Value toJSON(UrlDataManager& urlDataManager) const override;
-    static SkSaveLayerCommand* fromJSON(Json::Value& command, UrlDataManager& urlDataManager);
-
-    const SkPaint* paint() const { return fPaintPtr; }
 
 private:
-    SkRect               fBounds;
-    SkPaint              fPaint;
-    SkPaint*             fPaintPtr;
-    const SkImageFilter* fBackdrop;
-    uint32_t       fSaveLayerFlags;
+    SkTLazy<SkRect>            fBounds;
+    SkTLazy<SkPaint>           fPaint;
+    sk_sp<const SkImageFilter> fBackdrop;
+    uint32_t                   fSaveLayerFlags;
 
     typedef SkDrawCommand INHERITED;
 };
@@ -797,7 +714,6 @@ public:
     SkSetMatrixCommand(const SkMatrix& matrix);
     void execute(SkCanvas* canvas) const override;
     Json::Value toJSON(UrlDataManager& urlDataManager) const override;
-    static SkSetMatrixCommand* fromJSON(Json::Value& command, UrlDataManager& urlDataManager);
 
 private:
     SkMatrix fMatrix;
@@ -811,7 +727,6 @@ public:
     void execute(SkCanvas* canvas) const override;
     bool render(SkCanvas* canvas) const override;
     Json::Value toJSON(UrlDataManager& urlDataManager) const override;
-    static SkDrawShadowCommand* fromJSON(Json::Value& command, UrlDataManager& urlDataManager);
 
 private:
     SkPath           fPath;