Remove unused tools and unused includes of SkImageDecoder

tools/json/SkJSONRenderer.cpp

Index: tools/json/SkJSONRenderer.cpp
diff --git a/tools/json/SkJSONRenderer.cpp b/tools/json/SkJSONRenderer.cpp
deleted file mode 100644
index 6332b2ae2912aed409ff63dd861fe9c7d788d153..0000000000000000000000000000000000000000
--- a/tools/json/SkJSONRenderer.cpp
+++ /dev/null
@@ -1,972 +0,0 @@
-/*
- * Copyright 2016 Google Inc.
- *
- * Use of this source code is governed by a BSD-style license that can be
- * found in the LICENSE file.
- */
-
-#include "SkJSONRenderer.h"
-
-#include "SkBlurMaskFilter.h"
-#include "SkDashPathEffect.h"
-#include "SkJSONCanvas.h"
-#include "SkJSONCPP.h"
-#include "SkPath.h"
-#include "SkTextBlob.h"
-#include "SkTypeface.h"
-#include "SkValidatingReadBuffer.h"
-
-namespace SkJSONRenderer {
-
-class Renderer {
-public:
-    void getPaint(Json::Value& paint, SkPaint* result);
-
-    void getRect(Json::Value& rect, SkRect* result);
-
-    void getRRect(Json::Value& rrect, SkRRect* result);
-
-    void getPath(Json::Value& path, SkPath* result);
-
-    void getMatrix(Json::Value& matrix, SkMatrix* result);
-
-    SkRegion::Op getRegionOp(Json::Value& op);
-
-    void processCommand(Json::Value& command, SkCanvas* target);
-
-    void processTranslate(Json::Value& command, SkCanvas* target);
-
-    void processScale(Json::Value& command, SkCanvas* target);
-
-    void processMatrix(Json::Value& command, SkCanvas* target);
-
-    void processSave(Json::Value& command, SkCanvas* target);
-
-    void processRestore(Json::Value& command, SkCanvas* target);
-
-    void processSaveLayer(Json::Value& command, SkCanvas* target);
-
-    void processPaint(Json::Value& command, SkCanvas* target);
-
-    void processRect(Json::Value& command, SkCanvas* target);
-
-    void processRRect(Json::Value& command, SkCanvas* target);
-
-    void processOval(Json::Value& command, SkCanvas* target);
-
-    void processPath(Json::Value& command, SkCanvas* target);
-
-    void processText(Json::Value& command, SkCanvas* target);
-
-    void processPosText(Json::Value& command, SkCanvas* target);
-
-    void processTextOnPath(Json::Value& command, SkCanvas* target);
-
-    void processTextBlob(Json::Value& command, SkCanvas* target);
-
-    void processPoints(Json::Value& command, SkCanvas* target);
-
-    void processImage(Json::Value& command, SkCanvas* target);
-
-    void processImageRect(Json::Value& command, SkCanvas* target);
-
-    void processBitmap(Json::Value& command, SkCanvas* target);
-
-    void processBitmapRect(Json::Value& command, SkCanvas* target);
-
-    void processClipRect(Json::Value& command, SkCanvas* target);
-    
-    void processClipRRect(Json::Value& command, SkCanvas* target);
-
-    void processClipPath(Json::Value& command, SkCanvas* target);
-};
-
-void Renderer::processCommand(Json::Value& command, SkCanvas* target) {
-    const char* name = command[SKJSONCANVAS_COMMAND].asCString();
-    // TODO speed this up with a hash
-    if (!strcmp(name, SKJSONCANVAS_COMMAND_TRANSLATE)) {
-        this->processTranslate(command, target);
-    }
-    else if (!strcmp(name, SKJSONCANVAS_COMMAND_SCALE)) {
-        this->processScale(command, target);
-    }
-    else if (!strcmp(name, SKJSONCANVAS_COMMAND_MATRIX)) {
-        this->processMatrix(command, target);
-    }
-    else if (!strcmp(name, SKJSONCANVAS_COMMAND_SAVE)) {
-        this->processSave(command, target);
-    }
-    else if (!strcmp(name, SKJSONCANVAS_COMMAND_RESTORE)) {
-        this->processRestore(command, target);
-    }
-    else if (!strcmp(name, SKJSONCANVAS_COMMAND_SAVELAYER)) {
-        this->processSaveLayer(command, target);
-    }
-    else if (!strcmp(name, SKJSONCANVAS_COMMAND_PAINT)) {
-        this->processPaint(command, target);
-    }
-    else if (!strcmp(name, SKJSONCANVAS_COMMAND_RECT)) {
-        this->processRect(command, target);
-    }
-    else if (!strcmp(name, SKJSONCANVAS_COMMAND_RRECT)) {
-        this->processRRect(command, target);
-    }
-    else if (!strcmp(name, SKJSONCANVAS_COMMAND_OVAL)) {
-        this->processOval(command, target);
-    }
-    else if (!strcmp(name, SKJSONCANVAS_COMMAND_PATH)) {
-        this->processPath(command, target);
-    }
-    else if (!strcmp(name, SKJSONCANVAS_COMMAND_TEXT)) {
-        this->processText(command, target);
-    }
-    else if (!strcmp(name, SKJSONCANVAS_COMMAND_POSTEXT)) {
-        this->processPosText(command, target);
-    }
-    else if (!strcmp(name, SKJSONCANVAS_COMMAND_TEXTONPATH)) {
-        this->processTextOnPath(command, target);
-    }
-    else if (!strcmp(name, SKJSONCANVAS_COMMAND_TEXTBLOB)) {
-        this->processTextBlob(command, target);
-    }
-    else if (!strcmp(name, SKJSONCANVAS_COMMAND_POINTS)) {
-        this->processPoints(command, target);
-    }
-    else if (!strcmp(name, SKJSONCANVAS_COMMAND_IMAGE)) {
-        this->processImage(command, target);
-    }
-    else if (!strcmp(name, SKJSONCANVAS_COMMAND_IMAGERECT)) {
-        this->processImageRect(command, target);
-    }
-    else if (!strcmp(name, SKJSONCANVAS_COMMAND_BITMAP)) {
-        this->processBitmap(command, target);
-    }
-    else if (!strcmp(name, SKJSONCANVAS_COMMAND_BITMAPRECT)) {
-        this->processBitmapRect(command, target);
-    }
-    else if (!strcmp(name, SKJSONCANVAS_COMMAND_CLIPRECT)) {
-        this->processClipRect(command, target);
-    }
-    else if (!strcmp(name, SKJSONCANVAS_COMMAND_CLIPRRECT)) {
-        this->processClipRRect(command, target);
-    }
-    else if (!strcmp(name, SKJSONCANVAS_COMMAND_CLIPPATH)) {
-        this->processClipPath(command, target);
-    }
-    else {
-        SkDebugf("unsupported JSON command: %s\n", name);
-    }
-}
-
-static void apply_paint_color(Json::Value& jsonPaint, SkPaint* target) {
-    if (jsonPaint.isMember(SKJSONCANVAS_ATTRIBUTE_COLOR)) {
-        Json::Value color = jsonPaint[SKJSONCANVAS_ATTRIBUTE_COLOR];
-        target->setColor(SkColorSetARGB(color[0].asInt(), color[1].asInt(), color[2].asInt(),
-                         color[3].asInt()));
-    }
-}
-
-// note that the caller is responsible for freeing the pointer
-static Json::ArrayIndex decode_data(Json::Value bytes, void** target) {
-    Json::ArrayIndex size = bytes.size();
-    *target = sk_malloc_throw(size);
-    for (Json::ArrayIndex i = 0; i < size; i++) {
-        ((uint8_t*) *target)[i] = bytes[i].asInt();
-    }
-    return size;
-}
-
-static SkFlattenable* load_flattenable(Json::Value jsonFlattenable) {
-    if (!jsonFlattenable.isMember(SKJSONCANVAS_ATTRIBUTE_NAME)) {
-        return nullptr;
-    }
-    const char* name = jsonFlattenable[SKJSONCANVAS_ATTRIBUTE_NAME].asCString();
-    SkFlattenable::Factory factory = SkFlattenable::NameToFactory(name);
-    if (factory == nullptr) {
-        SkDebugf("no factory for loading '%s'\n", name);
-        return nullptr;
-    }
-    void* data;
-    int size = decode_data(jsonFlattenable[SKJSONCANVAS_ATTRIBUTE_BYTES], &data);
-    SkValidatingReadBuffer buffer(data, size);
-    SkFlattenable* result = factory(buffer);
-    free(data);
-    if (!buffer.isValid()) {
-        SkDebugf("invalid buffer loading flattenable\n");
-        return nullptr;
-    }
-    return result;
-}
-
-static SkColorType colortype_from_name(const char* name) {
-    if (!strcmp(name, SKJSONCANVAS_COLORTYPE_ARGB4444)) {
-        return kARGB_4444_SkColorType;
-    }
-    else if (!strcmp(name, SKJSONCANVAS_COLORTYPE_RGBA8888)) {
-        return kRGBA_8888_SkColorType;
-    }
-    else if (!strcmp(name, SKJSONCANVAS_COLORTYPE_BGRA8888)) {
-        return kBGRA_8888_SkColorType;
-    }
-    else if (!strcmp(name, SKJSONCANVAS_COLORTYPE_565)) {
-        return kRGB_565_SkColorType;
-    }
-    else if (!strcmp(name, SKJSONCANVAS_COLORTYPE_GRAY8)) {
-        return kGray_8_SkColorType;
-    }
-    else if (!strcmp(name, SKJSONCANVAS_COLORTYPE_INDEX8)) {
-        return kIndex_8_SkColorType;
-    }
-    else if (!strcmp(name, SKJSONCANVAS_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 (bitmap->copyTo(dst, colorType)) {
-        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) {
-    if (!jsonBitmap.isMember(SKJSONCANVAS_ATTRIBUTE_BYTES)) {
-        SkDebugf("invalid bitmap\n");
-        return nullptr;
-    }
-    void* data;
-    int size = decode_data(jsonBitmap[SKJSONCANVAS_ATTRIBUTE_BYTES], &data);
-    SkMemoryStream stream(data, size);
-    SkImageDecoder* decoder = SkImageDecoder::Factory(&stream);
-    SkBitmap* bitmap = new SkBitmap();
-    SkImageDecoder::Result result = decoder->decode(&stream, bitmap, 
-                                                    SkImageDecoder::kDecodePixels_Mode);
-    free(decoder);
-    if (result != SkImageDecoder::kFailure) {
-        free(data);
-        if (jsonBitmap.isMember(SKJSONCANVAS_ATTRIBUTE_COLOR)) {
-            const char* ctName = jsonBitmap[SKJSONCANVAS_ATTRIBUTE_COLOR].asCString();
-            SkColorType ct = colortype_from_name(ctName);
-            if (ct != kIndex_8_SkColorType) {
-                bitmap = convert_colortype(bitmap, ct);
-            }
-        }
-        return bitmap;
-    }
-    SkDebugf("image decode failed\n");
-    free(data);
-    return nullptr;
-}
-
-static SkImage* load_image(const Json::Value& jsonImage) {
-    SkBitmap* bitmap = load_bitmap(jsonImage);
-    if (bitmap == nullptr) {
-        return nullptr;
-    }
-    SkImage* result = SkImage::NewFromBitmap(*bitmap);
-    delete bitmap;
-    return result;
-}
-
-static void apply_paint_shader(Json::Value& jsonPaint, SkPaint* target) {
-    if (jsonPaint.isMember(SKJSONCANVAS_ATTRIBUTE_SHADER)) {
-        Json::Value jsonShader = jsonPaint[SKJSONCANVAS_ATTRIBUTE_SHADER];
-        SkShader* shader = (SkShader*) load_flattenable(jsonShader);
-        if (shader != nullptr) {
-            target->setShader(shader);
-            shader->unref();
-        }
-    }
-}
-
-static void apply_paint_patheffect(Json::Value& jsonPaint, SkPaint* target) {
-    if (jsonPaint.isMember(SKJSONCANVAS_ATTRIBUTE_PATHEFFECT)) {
-        Json::Value jsonPathEffect = jsonPaint[SKJSONCANVAS_ATTRIBUTE_PATHEFFECT];
-        SkPathEffect* pathEffect = (SkPathEffect*) load_flattenable(jsonPathEffect);
-        if (pathEffect != nullptr) {
-            target->setPathEffect(pathEffect);
-            pathEffect->unref();
-        }
-    }
-}
-
-static void apply_paint_maskfilter(Json::Value& jsonPaint, SkPaint* target) {
-    if (jsonPaint.isMember(SKJSONCANVAS_ATTRIBUTE_MASKFILTER)) {
-        Json::Value jsonMaskFilter = jsonPaint[SKJSONCANVAS_ATTRIBUTE_MASKFILTER];
-        SkMaskFilter* maskFilter = (SkMaskFilter*) load_flattenable(jsonMaskFilter);
-        if (maskFilter != nullptr) {
-            target->setMaskFilter(maskFilter);
-            maskFilter->unref();
-        }
-    }
-}
-
-static void apply_paint_colorfilter(Json::Value& jsonPaint, SkPaint* target) {
-    if (jsonPaint.isMember(SKJSONCANVAS_ATTRIBUTE_COLORFILTER)) {
-        Json::Value jsonColorFilter = jsonPaint[SKJSONCANVAS_ATTRIBUTE_COLORFILTER];
-        SkColorFilter* colorFilter = (SkColorFilter*) load_flattenable(jsonColorFilter);
-        if (colorFilter != nullptr) {
-            target->setColorFilter(colorFilter);
-            colorFilter->unref();
-        }
-    }
-}
-
-static void apply_paint_xfermode(Json::Value& jsonPaint, SkPaint* target) {
-    if (jsonPaint.isMember(SKJSONCANVAS_ATTRIBUTE_XFERMODE)) {
-        Json::Value jsonXfermode = jsonPaint[SKJSONCANVAS_ATTRIBUTE_XFERMODE];
-        SkXfermode* xfermode = (SkXfermode*) load_flattenable(jsonXfermode);
-        if (xfermode != nullptr) {
-            target->setXfermode(xfermode);
-            xfermode->unref();
-        }
-    }
-}
-
-static void apply_paint_imagefilter(Json::Value& jsonPaint, SkPaint* target) {
-    if (jsonPaint.isMember(SKJSONCANVAS_ATTRIBUTE_IMAGEFILTER)) {
-        Json::Value jsonImageFilter = jsonPaint[SKJSONCANVAS_ATTRIBUTE_IMAGEFILTER];
-        SkImageFilter* imageFilter = (SkImageFilter*) load_flattenable(jsonImageFilter);
-        if (imageFilter != nullptr) {
-            target->setImageFilter(imageFilter);
-            imageFilter->unref();
-        }
-    }
-}
-
-static void apply_paint_style(Json::Value& jsonPaint, SkPaint* target) {
-    if (jsonPaint.isMember(SKJSONCANVAS_ATTRIBUTE_STYLE)) {
-        const char* style = jsonPaint[SKJSONCANVAS_ATTRIBUTE_STYLE].asCString();
-        if (!strcmp(style, SKJSONCANVAS_STYLE_FILL)) {
-            target->setStyle(SkPaint::kFill_Style);
-        }
-        else if (!strcmp(style, SKJSONCANVAS_STYLE_STROKE)) {
-            target->setStyle(SkPaint::kStroke_Style);
-        }
-        else if (!strcmp(style, SKJSONCANVAS_STYLE_STROKEANDFILL)) {
-            target->setStyle(SkPaint::kStrokeAndFill_Style);
-        }
-    }
-}
-
-static void apply_paint_strokewidth(Json::Value& jsonPaint, SkPaint* target) {
-    if (jsonPaint.isMember(SKJSONCANVAS_ATTRIBUTE_STROKEWIDTH)) {
-        float strokeWidth = jsonPaint[SKJSONCANVAS_ATTRIBUTE_STROKEWIDTH].asFloat();
-        target->setStrokeWidth(strokeWidth);
-    }    
-}
-
-static void apply_paint_strokemiter(Json::Value& jsonPaint, SkPaint* target) {
-    if (jsonPaint.isMember(SKJSONCANVAS_ATTRIBUTE_STROKEMITER)) {
-        float strokeMiter = jsonPaint[SKJSONCANVAS_ATTRIBUTE_STROKEMITER].asFloat();
-        target->setStrokeMiter(strokeMiter);
-    }    
-}
-
-static void apply_paint_cap(Json::Value& jsonPaint, SkPaint* target) {
-    if (jsonPaint.isMember(SKJSONCANVAS_ATTRIBUTE_CAP)) {
-        const char* cap = jsonPaint[SKJSONCANVAS_ATTRIBUTE_CAP].asCString();
-        if (!strcmp(cap, SKJSONCANVAS_CAP_BUTT)) {
-            target->setStrokeCap(SkPaint::kButt_Cap);
-        }
-        else if (!strcmp(cap, SKJSONCANVAS_CAP_ROUND)) {
-            target->setStrokeCap(SkPaint::kRound_Cap);
-        }
-        else if (!strcmp(cap, SKJSONCANVAS_CAP_SQUARE)) {
-            target->setStrokeCap(SkPaint::kSquare_Cap);
-        }
-    }
-}
-
-static void apply_paint_antialias(Json::Value& jsonPaint, SkPaint* target) {
-    if (jsonPaint.isMember(SKJSONCANVAS_ATTRIBUTE_ANTIALIAS)) {
-        target->setAntiAlias(jsonPaint[SKJSONCANVAS_ATTRIBUTE_ANTIALIAS].asBool());
-    }
-}
-
-static void apply_paint_blur(Json::Value& jsonPaint, SkPaint* target) {
-    if (jsonPaint.isMember(SKJSONCANVAS_ATTRIBUTE_BLUR)) {
-        Json::Value blur = jsonPaint[SKJSONCANVAS_ATTRIBUTE_BLUR];
-        SkScalar sigma = blur[SKJSONCANVAS_ATTRIBUTE_SIGMA].asFloat();
-        SkBlurStyle style;
-        const char* jsonStyle = blur[SKJSONCANVAS_ATTRIBUTE_STYLE].asCString();
-        if (!strcmp(jsonStyle, SKJSONCANVAS_BLURSTYLE_NORMAL)) {
-            style = SkBlurStyle::kNormal_SkBlurStyle;
-        }
-        else if (!strcmp(jsonStyle, SKJSONCANVAS_BLURSTYLE_SOLID)) {
-            style = SkBlurStyle::kSolid_SkBlurStyle;
-        }
-        else if (!strcmp(jsonStyle, SKJSONCANVAS_BLURSTYLE_OUTER)) {
-            style = SkBlurStyle::kOuter_SkBlurStyle;
-        }
-        else if (!strcmp(jsonStyle, SKJSONCANVAS_BLURSTYLE_INNER)) {
-            style = SkBlurStyle::kInner_SkBlurStyle;
-        }
-        else {
-            SkASSERT(false);
-            style = SkBlurStyle::kNormal_SkBlurStyle;
-        }
-        SkBlurMaskFilter::BlurFlags flags;
-        const char* jsonQuality = blur[SKJSONCANVAS_ATTRIBUTE_QUALITY].asCString();
-        if (!strcmp(jsonQuality, SKJSONCANVAS_BLURQUALITY_LOW)) {
-            flags = SkBlurMaskFilter::BlurFlags::kNone_BlurFlag;
-        }
-        else if (!strcmp(jsonQuality, SKJSONCANVAS_BLURQUALITY_HIGH)) {
-            flags = SkBlurMaskFilter::BlurFlags::kHighQuality_BlurFlag;
-        }
-        else {
-            SkASSERT(false);
-            flags = SkBlurMaskFilter::BlurFlags::kNone_BlurFlag;
-        }
-        target->setMaskFilter(SkBlurMaskFilter::Create(style, sigma, flags));
-    }
-}
-
-static void apply_paint_dashing(Json::Value& jsonPaint, SkPaint* target) {
-    if (jsonPaint.isMember(SKJSONCANVAS_ATTRIBUTE_DASHING)) {
-        Json::Value dash = jsonPaint[SKJSONCANVAS_ATTRIBUTE_DASHING];
-        Json::Value jsonIntervals = dash[SKJSONCANVAS_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[SKJSONCANVAS_ATTRIBUTE_PHASE].asFloat();
-        target->setPathEffect(SkDashPathEffect::Create(intervals, count, phase));
-        free(intervals);
-    }
-}
-
-static void apply_paint_textalign(Json::Value& jsonPaint, SkPaint* target) {
-    if (jsonPaint.isMember(SKJSONCANVAS_ATTRIBUTE_TEXTALIGN)) {
-        SkPaint::Align textAlign;
-        const char* jsonAlign = jsonPaint[SKJSONCANVAS_ATTRIBUTE_TEXTALIGN].asCString();
-        if (!strcmp(jsonAlign, SKJSONCANVAS_ALIGN_LEFT)) {
-            textAlign = SkPaint::kLeft_Align;
-        }
-        else if (!strcmp(jsonAlign, SKJSONCANVAS_ALIGN_CENTER)) {
-            textAlign = SkPaint::kCenter_Align;
-        }
-        else if (!strcmp(jsonAlign, SKJSONCANVAS_ALIGN_RIGHT)) {
-            textAlign = SkPaint::kRight_Align;
-        }
-        else {
-            SkASSERT(false);
-            textAlign = SkPaint::kLeft_Align;
-        }
-        target->setTextAlign(textAlign);
-    }
-}
-
-static void apply_paint_textsize(Json::Value& jsonPaint, SkPaint* target) {
-    if (jsonPaint.isMember(SKJSONCANVAS_ATTRIBUTE_TEXTSIZE)) {
-        float textSize = jsonPaint[SKJSONCANVAS_ATTRIBUTE_TEXTSIZE].asFloat();
-        target->setTextSize(textSize);
-    }
-}
-
-static void apply_paint_textscalex(Json::Value& jsonPaint, SkPaint* target) {
-    if (jsonPaint.isMember(SKJSONCANVAS_ATTRIBUTE_TEXTSCALEX)) {
-        float textScaleX = jsonPaint[SKJSONCANVAS_ATTRIBUTE_TEXTSCALEX].asFloat();
-        target->setTextScaleX(textScaleX);
-    }
-}
-
-static void apply_paint_textskewx(Json::Value& jsonPaint, SkPaint* target) {
-    if (jsonPaint.isMember(SKJSONCANVAS_ATTRIBUTE_TEXTSKEWX)) {
-        float textSkewX = jsonPaint[SKJSONCANVAS_ATTRIBUTE_TEXTSKEWX].asFloat();
-        target->setTextSkewX(textSkewX);
-    }
-}
-
-static void apply_paint_typeface(Json::Value& jsonPaint, SkPaint* target) {
-    if (jsonPaint.isMember(SKJSONCANVAS_ATTRIBUTE_TYPEFACE)) {
-        Json::Value jsonTypeface = jsonPaint[SKJSONCANVAS_ATTRIBUTE_TYPEFACE];
-        Json::Value bytes = jsonTypeface[SKJSONCANVAS_ATTRIBUTE_BYTES];
-        void* data;
-        Json::ArrayIndex length = decode_data(bytes, &data);
-        SkMemoryStream buffer(data, length);
-        SkTypeface* typeface = SkTypeface::Deserialize(&buffer);
-        free(data);
-        target->setTypeface(typeface);
-    }
-}
-
-void Renderer::getPaint(Json::Value& paint, SkPaint* result) {
-    apply_paint_color(paint, result);
-    apply_paint_shader(paint, result);
-    apply_paint_patheffect(paint, result);
-    apply_paint_maskfilter(paint, result);
-    apply_paint_colorfilter(paint, result);
-    apply_paint_xfermode(paint, result);
-    apply_paint_imagefilter(paint, result);
-    apply_paint_style(paint, result);
-    apply_paint_strokewidth(paint, result);
-    apply_paint_strokemiter(paint, result);
-    apply_paint_cap(paint, result);
-    apply_paint_antialias(paint, result);
-    apply_paint_blur(paint, result);
-    apply_paint_dashing(paint, result);
-    apply_paint_textalign(paint, result);
-    apply_paint_textsize(paint, result);
-    apply_paint_textscalex(paint, result);
-    apply_paint_textskewx(paint, result);
-    apply_paint_typeface(paint, result);
-}
-
-void Renderer::getRect(Json::Value& rect, SkRect* result) {
-    result->set(rect[0].asFloat(), rect[1].asFloat(), rect[2].asFloat(), rect[3].asFloat());
-}
-
-void Renderer::getRRect(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);
-}
-
-void Renderer::getMatrix(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);
-}
-
-void Renderer::getPath(Json::Value& path, SkPath* result) {
-    const char* fillType = path[SKJSONCANVAS_ATTRIBUTE_FILLTYPE].asCString();
-    if (!strcmp(fillType, SKJSONCANVAS_FILLTYPE_WINDING)) {
-        result->setFillType(SkPath::kWinding_FillType);
-    }
-    else if (!strcmp(fillType, SKJSONCANVAS_FILLTYPE_EVENODD)) {
-        result->setFillType(SkPath::kEvenOdd_FillType);
-    }
-    else if (!strcmp(fillType, SKJSONCANVAS_FILLTYPE_INVERSEWINDING)) {
-        result->setFillType(SkPath::kInverseWinding_FillType);
-    }
-    else if (!strcmp(fillType, SKJSONCANVAS_FILLTYPE_INVERSEEVENODD)) {
-        result->setFillType(SkPath::kInverseEvenOdd_FillType);
-    }
-    Json::Value verbs = path[SKJSONCANVAS_ATTRIBUTE_VERBS];
-    for (Json::ArrayIndex i = 0; i < verbs.size(); i++) {
-        Json::Value verb = verbs[i];
-        if (verb.isString()) {
-            SkASSERT(!strcmp(verb.asCString(), SKJSONCANVAS_VERB_CLOSE));
-            result->close();
-        }
-        else {
-            if (verb.isMember(SKJSONCANVAS_VERB_MOVE)) {
-                Json::Value move = verb[SKJSONCANVAS_VERB_MOVE];
-                result->moveTo(move[0].asFloat(), move[1].asFloat());
-            }
-            else if (verb.isMember(SKJSONCANVAS_VERB_LINE)) {
-                Json::Value line = verb[SKJSONCANVAS_VERB_LINE];
-                result->lineTo(line[0].asFloat(), line[1].asFloat());
-            }
-            else if (verb.isMember(SKJSONCANVAS_VERB_QUAD)) {
-                Json::Value quad = verb[SKJSONCANVAS_VERB_QUAD];
-                result->quadTo(quad[0][0].asFloat(), quad[0][1].asFloat(),
-                               quad[1][0].asFloat(), quad[1][1].asFloat());
-            }
-            else if (verb.isMember(SKJSONCANVAS_VERB_CUBIC)) {
-                Json::Value cubic = verb[SKJSONCANVAS_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(SKJSONCANVAS_VERB_CONIC)) {
-                Json::Value conic = verb[SKJSONCANVAS_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);
-            }
-        }
-    }
-}
-
-SkRegion::Op Renderer::getRegionOp(Json::Value& jsonOp) {
-    const char* op = jsonOp.asCString();
-    if (!strcmp(op, SKJSONCANVAS_REGIONOP_DIFFERENCE)) {
-        return SkRegion::kDifference_Op;
-    }
-    else if (!strcmp(op, SKJSONCANVAS_REGIONOP_INTERSECT)) {
-        return SkRegion::kIntersect_Op;
-    }
-    else if (!strcmp(op, SKJSONCANVAS_REGIONOP_UNION)) {
-        return SkRegion::kUnion_Op;
-    }
-    else if (!strcmp(op, SKJSONCANVAS_REGIONOP_XOR)) {
-        return SkRegion::kXOR_Op;
-    }
-    else if (!strcmp(op, SKJSONCANVAS_REGIONOP_REVERSE_DIFFERENCE)) {
-        return SkRegion::kReverseDifference_Op;
-    }
-    else if (!strcmp(op, SKJSONCANVAS_REGIONOP_REPLACE)) {
-        return SkRegion::kReplace_Op;
-    }
-    SkASSERT(false);
-    return SkRegion::kIntersect_Op;
-}
-
-void Renderer::processTranslate(Json::Value& command, SkCanvas* target) {
-    target->translate(command[SKJSONCANVAS_ATTRIBUTE_X].asFloat(),
-                      command[SKJSONCANVAS_ATTRIBUTE_Y].asFloat());
-}
-
-void Renderer::processScale(Json::Value& command, SkCanvas* target) {
-    target->scale(command[SKJSONCANVAS_ATTRIBUTE_X].asFloat(),
-                  command[SKJSONCANVAS_ATTRIBUTE_Y].asFloat());
-}
-
-void Renderer::processMatrix(Json::Value& command, SkCanvas* target) {
-    SkMatrix matrix;
-    this->getMatrix(command[SKJSONCANVAS_ATTRIBUTE_MATRIX], &matrix);
-    target->setMatrix(matrix);
-}
-
-void Renderer::processSave(Json::Value& command, SkCanvas* target) {
-    target->save();
-}
-
-void Renderer::processRestore(Json::Value& command, SkCanvas* target) {
-    target->restore();
-}
-
-void Renderer::processSaveLayer(Json::Value& command, SkCanvas* target) {
-    SkCanvas::SaveLayerRec rec;
-    SkRect bounds;
-    if (command.isMember(SKJSONCANVAS_ATTRIBUTE_BOUNDS)) {
-        this->getRect(command[SKJSONCANVAS_ATTRIBUTE_BOUNDS], &bounds);
-        rec.fBounds = &bounds;
-    }
-    SkPaint paint;
-    if (command.isMember(SKJSONCANVAS_ATTRIBUTE_PAINT)) {
-        this->getPaint(command[SKJSONCANVAS_ATTRIBUTE_PAINT], &paint);
-        rec.fPaint = &paint;
-    }
-    if (command.isMember(SKJSONCANVAS_ATTRIBUTE_BACKDROP)) {
-        rec.fBackdrop = (SkImageFilter*) load_flattenable(command[SKJSONCANVAS_ATTRIBUTE_BACKDROP]);
-    }
-    target->saveLayer(rec);
-    if (rec.fBackdrop != nullptr) {
-        rec.fBackdrop->unref();
-    }
-}
-
-void Renderer::processPaint(Json::Value& command, SkCanvas* target) {
-    SkPaint paint;
-    this->getPaint(command[SKJSONCANVAS_ATTRIBUTE_PAINT], &paint);
-    target->drawPaint(paint);
-}
-
-void Renderer::processRect(Json::Value& command, SkCanvas* target) {
-    SkRect rect;
-    this->getRect(command[SKJSONCANVAS_ATTRIBUTE_COORDS], &rect);
-    SkPaint paint;
-    this->getPaint(command[SKJSONCANVAS_ATTRIBUTE_PAINT], &paint);
-    target->drawRect(rect, paint);
-}
-
-void Renderer::processRRect(Json::Value& command, SkCanvas* target) {
-    SkRRect rrect;
-    this->getRRect(command[SKJSONCANVAS_ATTRIBUTE_COORDS], &rrect);
-    SkPaint paint;
-    this->getPaint(command[SKJSONCANVAS_ATTRIBUTE_PAINT], &paint);
-    target->drawRRect(rrect, paint);
-}
-
-void Renderer::processOval(Json::Value& command, SkCanvas* target) {
-    SkRect rect;
-    this->getRect(command[SKJSONCANVAS_ATTRIBUTE_COORDS], &rect);
-    SkPaint paint;
-    this->getPaint(command[SKJSONCANVAS_ATTRIBUTE_PAINT], &paint);
-    target->drawOval(rect, paint);
-}
-
-void Renderer::processPath(Json::Value& command, SkCanvas* target) {
-    SkPath path;
-    this->getPath(command[SKJSONCANVAS_ATTRIBUTE_PATH], &path);
-    SkPaint paint;
-    this->getPaint(command[SKJSONCANVAS_ATTRIBUTE_PAINT], &paint);
-    target->drawPath(path, paint);
-}
-
-void Renderer::processText(Json::Value& command, SkCanvas* target) {
-    const char* text = command[SKJSONCANVAS_ATTRIBUTE_TEXT].asCString();
-    SkPaint paint;
-    this->getPaint(command[SKJSONCANVAS_ATTRIBUTE_PAINT], &paint);
-    Json::Value coords = command[SKJSONCANVAS_ATTRIBUTE_COORDS];
-    target->drawText(text, strlen(text), coords[0].asFloat(), coords[1].asFloat(), paint);
-}
-
-void Renderer::processPosText(Json::Value& command, SkCanvas* target) {
-    const char* text = command[SKJSONCANVAS_ATTRIBUTE_TEXT].asCString();
-    SkPaint paint;
-    this->getPaint(command[SKJSONCANVAS_ATTRIBUTE_PAINT], &paint);
-    Json::Value coords = command[SKJSONCANVAS_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());
-    }
-    target->drawPosText(text, strlen(text), points, paint);
-    free(points);
-}
-
-void Renderer::processTextOnPath(Json::Value& command, SkCanvas* target) {
-    const char* text = command[SKJSONCANVAS_ATTRIBUTE_TEXT].asCString();
-    SkPath path;
-    this->getPath(command[SKJSONCANVAS_ATTRIBUTE_PATH], &path);
-    SkMatrix* matrixPtr;
-    SkMatrix matrix;
-    if (command.isMember(SKJSONCANVAS_ATTRIBUTE_MATRIX)) {
-        this->getMatrix(command[SKJSONCANVAS_ATTRIBUTE_MATRIX], &matrix);
-        matrixPtr = &matrix;
-    }
-    else {
-        matrixPtr = nullptr;
-    }
-    SkPaint paint;
-    this->getPaint(command[SKJSONCANVAS_ATTRIBUTE_PAINT], &paint);
-    target->drawTextOnPath(text, strlen(text), path, matrixPtr, paint);
-}
-
-void Renderer::processTextBlob(Json::Value& command, SkCanvas* target) {
-    SkTextBlobBuilder builder;
-    Json::Value runs = command[SKJSONCANVAS_ATTRIBUTE_RUNS];
-    for (Json::ArrayIndex i = 0 ; i < runs.size(); i++) {
-        Json::Value run = runs[i];
-        SkPaint font;
-        font.setTextEncoding(SkPaint::kGlyphID_TextEncoding);
-        this->getPaint(run[SKJSONCANVAS_ATTRIBUTE_FONT], &font);
-        Json::Value glyphs = run[SKJSONCANVAS_ATTRIBUTE_GLYPHS];
-        int count = glyphs.size();
-        Json::Value coords = run[SKJSONCANVAS_ATTRIBUTE_COORDS];
-        SkScalar x = coords[0].asFloat();
-        SkScalar y = coords[1].asFloat();
-        if (run.isMember(SKJSONCANVAS_ATTRIBUTE_POSITIONS)) {
-            Json::Value positions = run[SKJSONCANVAS_ATTRIBUTE_POSITIONS];
-            if (positions.size() > 0 && positions[0].isNumeric()) {
-                SkTextBlobBuilder::RunBuffer buffer = builder.allocRunPosH(font, count, y);
-                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);
-                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);
-            for (int j = 0; j < count; j++) {
-                buffer.glyphs[j] = glyphs[j].asUInt();
-            }
-        }
-    }
-    SkScalar x = command[SKJSONCANVAS_ATTRIBUTE_X].asFloat();
-    SkScalar y = command[SKJSONCANVAS_ATTRIBUTE_Y].asFloat();
-    SkPaint paint;
-    this->getPaint(command[SKJSONCANVAS_ATTRIBUTE_PAINT], &paint);
-    target->drawTextBlob(builder.build(), x, y, paint);
-}
-
-void Renderer::processPoints(Json::Value& command, SkCanvas* target) {
-    SkCanvas::PointMode mode;
-    const char* jsonMode = command[SKJSONCANVAS_ATTRIBUTE_MODE].asCString();
-    if (!strcmp(jsonMode, SKJSONCANVAS_POINTMODE_POINTS)) {
-        mode = SkCanvas::kPoints_PointMode;
-    }
-    else if (!strcmp(jsonMode, SKJSONCANVAS_POINTMODE_LINES)) {
-        mode = SkCanvas::kLines_PointMode;
-    }
-    else if (!strcmp(jsonMode, SKJSONCANVAS_POINTMODE_POLYGON)) {
-        mode = SkCanvas::kPolygon_PointMode;
-    }
-    else {
-        SkASSERT(false);
-        return;
-    }
-    Json::Value jsonPoints = command[SKJSONCANVAS_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;
-    this->getPaint(command[SKJSONCANVAS_ATTRIBUTE_PAINT], &paint);
-    target->drawPoints(mode, count, points, paint);
-    free(points);
-}
-
-void Renderer::processClipRect(Json::Value& command, SkCanvas* target) {
-    SkRect rect;
-    this->getRect(command[SKJSONCANVAS_ATTRIBUTE_COORDS], &rect);
-    target->clipRect(rect, this->getRegionOp(command[SKJSONCANVAS_ATTRIBUTE_REGIONOP]), 
-                     command[SKJSONCANVAS_ATTRIBUTE_ANTIALIAS].asBool());
-}
-
-void Renderer::processClipRRect(Json::Value& command, SkCanvas* target) {
-    SkRRect rrect;
-    this->getRRect(command[SKJSONCANVAS_ATTRIBUTE_COORDS], &rrect);
-    target->clipRRect(rrect, this->getRegionOp(command[SKJSONCANVAS_ATTRIBUTE_REGIONOP]), 
-                      command[SKJSONCANVAS_ATTRIBUTE_ANTIALIAS].asBool());
-}
-
-void Renderer::processClipPath(Json::Value& command, SkCanvas* target) {
-    SkPath path;
-    this->getPath(command[SKJSONCANVAS_ATTRIBUTE_PATH], &path);
-    target->clipPath(path, this->getRegionOp(command[SKJSONCANVAS_ATTRIBUTE_REGIONOP]), 
-                     command[SKJSONCANVAS_ATTRIBUTE_ANTIALIAS].asBool());
-}
-
-void Renderer::processImage(Json::Value& command, SkCanvas* target) {
-    SkImage* image = load_image(command[SKJSONCANVAS_ATTRIBUTE_IMAGE]);
-    if (image == nullptr) {
-        return;
-    }
-    Json::Value point = command[SKJSONCANVAS_ATTRIBUTE_COORDS];
-    SkPaint* paintPtr;
-    SkPaint paint;
-    if (command.isMember(SKJSONCANVAS_ATTRIBUTE_PAINT)) {
-        this->getPaint(command[SKJSONCANVAS_ATTRIBUTE_PAINT], &paint);
-        paintPtr = &paint;
-    }
-    else {
-        paintPtr = nullptr;
-    }
-    target->drawImage(image, point[0].asFloat(), point[1].asFloat(), paintPtr);
-    image->unref();
-}
-
-void Renderer::processImageRect(Json::Value& command, SkCanvas* target) {
-    SkImage* image = load_image(command[SKJSONCANVAS_ATTRIBUTE_IMAGE]);
-    if (image == nullptr) {
-        return;
-    }
-    SkRect dst;
-    this->getRect(command[SKJSONCANVAS_ATTRIBUTE_DST], &dst);
-    SkPaint* paintPtr;
-    SkPaint paint;
-    if (command.isMember(SKJSONCANVAS_ATTRIBUTE_PAINT)) {
-        this->getPaint(command[SKJSONCANVAS_ATTRIBUTE_PAINT], &paint);
-        paintPtr = &paint;
-    }
-    else {
-        paintPtr = nullptr;
-    }
-    SkCanvas::SrcRectConstraint constraint;
-    if (command.isMember(SKJSONCANVAS_ATTRIBUTE_STRICT) && 
-        command[SKJSONCANVAS_ATTRIBUTE_STRICT].asBool()) {
-        constraint = SkCanvas::kStrict_SrcRectConstraint;
-    }
-    else {
-        constraint = SkCanvas::kFast_SrcRectConstraint;
-    }
-    if (command.isMember(SKJSONCANVAS_ATTRIBUTE_SRC)) {
-        SkRect src;
-        this->getRect(command[SKJSONCANVAS_ATTRIBUTE_SRC], &src);
-        target->drawImageRect(image, src, dst, paintPtr, constraint);
-    }
-    else {
-        target->drawImageRect(image, dst, paintPtr, constraint);
-    }
-    image->unref();
-}
-
-void Renderer::processBitmap(Json::Value& command, SkCanvas* target) {
-    SkImage* image = load_image(command[SKJSONCANVAS_ATTRIBUTE_BITMAP]);
-    if (image == nullptr) {
-        return;
-    }
-    Json::Value point = command[SKJSONCANVAS_ATTRIBUTE_COORDS];
-    SkPaint* paintPtr;
-    SkPaint paint;
-    if (command.isMember(SKJSONCANVAS_ATTRIBUTE_PAINT)) {
-        this->getPaint(command[SKJSONCANVAS_ATTRIBUTE_PAINT], &paint);
-        paintPtr = &paint;
-    }
-    else {
-        paintPtr = nullptr;
-    }
-    target->drawImage(image, point[0].asFloat(), point[1].asFloat(), paintPtr);
-    image->unref();
-}
-
-void Renderer::processBitmapRect(Json::Value& command, SkCanvas* target) {
-    SkBitmap* bitmap = load_bitmap(command[SKJSONCANVAS_ATTRIBUTE_BITMAP]);
-    if (bitmap == nullptr) {
-        return;
-    }
-    SkRect dst;
-    this->getRect(command[SKJSONCANVAS_ATTRIBUTE_DST], &dst);
-    SkPaint* paintPtr;
-    SkPaint paint;
-    if (command.isMember(SKJSONCANVAS_ATTRIBUTE_PAINT)) {
-        this->getPaint(command[SKJSONCANVAS_ATTRIBUTE_PAINT], &paint);
-        paintPtr = &paint;
-    }
-    else {
-        paintPtr = nullptr;
-    }
-    SkCanvas::SrcRectConstraint constraint;
-    if (command.isMember(SKJSONCANVAS_ATTRIBUTE_STRICT) && 
-        command[SKJSONCANVAS_ATTRIBUTE_STRICT].asBool()) {
-        constraint = SkCanvas::kStrict_SrcRectConstraint;
-    }
-    else {
-        constraint = SkCanvas::kFast_SrcRectConstraint;
-    }
-    if (command.isMember(SKJSONCANVAS_ATTRIBUTE_SRC)) {
-        SkRect src;
-        this->getRect(command[SKJSONCANVAS_ATTRIBUTE_SRC], &src);
-        target->drawBitmapRect(*bitmap, src, dst, paintPtr, constraint);
-    }
-    else {
-        target->drawBitmapRect(*bitmap, dst, paintPtr, constraint);
-    }
-    free(bitmap);
-}
-
-void render(const char* json, SkCanvas* target) {
-    Renderer renderer;
-    Json::Reader reader;
-    Json::Value root;
-    if (reader.parse(std::string(json), root)) {
-        SkASSERT(root[SKJSONCANVAS_VERSION].asInt() == 1);
-        Json::Value commands = root[SKJSONCANVAS_COMMANDS];
-        for (Json::ArrayIndex i = 0; i < commands.size(); i++) {
-            renderer.processCommand(commands[i], target);
-        }
-    }
-    else {
-        SkDebugf(json);
-        SkFAIL("json parse failure");
-    }
-}
-
-} // namespace