JSON API cleanups

tools/json/SkJSONRenderer.cpp

 /*
  * 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 "SkValidatingReadBuffer.h"
 
 namespace SkJSONRenderer {
 
 class Renderer {
 public:
-    void getPaint(Json::Value& command, SkPaint* paint);
+    void getPaint(Json::Value& paint, SkPaint* result);
 
-    void getRect(Json::Value& command, const char* name, SkRect* rect);
+    void getRect(Json::Value& rect, SkRect* result);
 
-    void getRRect(Json::Value& command, const char* name, SkRRect* rrect);
+    void getRRect(Json::Value& rrect, SkRRect* result);
 
-    void getPath(Json::Value& command, SkPath* path);
+    void getPath(Json::Value& path, SkPath* result);
 
-    SkRegion::Op getRegionOp(Json::Value& command);
+    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 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_MATRIX)) {
+    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);
@@ skipping 12 matching lines @@
     }
     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_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)) {
@@ skipping 329 matching lines @@
     }
 }
 
 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);
     }
 }
 
-void Renderer::getPaint(Json::Value& command, SkPaint* result) {
-    Json::Value jsonPaint = command[SKJSONCANVAS_ATTRIBUTE_PAINT];
-    apply_paint_color(jsonPaint, result);
-    apply_paint_shader(jsonPaint, result);
-    apply_paint_patheffect(jsonPaint, result);
-    apply_paint_maskfilter(jsonPaint, result);
-    apply_paint_xfermode(jsonPaint, result);
-    apply_paint_imagefilter(jsonPaint, result);
-    apply_paint_style(jsonPaint, result);
-    apply_paint_strokewidth(jsonPaint, result);
-    apply_paint_strokemiter(jsonPaint, result);
-    apply_paint_cap(jsonPaint, result);
-    apply_paint_antialias(jsonPaint, result);
-    apply_paint_blur(jsonPaint, result);
-    apply_paint_dashing(jsonPaint, result);
-    apply_paint_textalign(jsonPaint, result);
-    apply_paint_textsize(jsonPaint, result);
-    apply_paint_textscalex(jsonPaint, result);
-    apply_paint_textskewx(jsonPaint, result);
+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_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);
 }
 
-void Renderer::getRect(Json::Value& command, const char* name, SkRect* result) {
-    Json::Value rect = command[name];
+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& command, const char* name, SkRRect* result) {
-    Json::Value rrect = command[name];
+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);
+                                          radii);
 }
 
-void Renderer::getPath(Json::Value& command, SkPath* result) {
-    Json::Value path = command[SKJSONCANVAS_ATTRIBUTE_PATH];
+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);
     }
@@ skipping 33 matching lines @@
                                 conic[1][0].asFloat(), conic[1][1].asFloat(),
                                 conic[2].asFloat());
             }
             else {
                 SkASSERT(false);
             }
         }
     }
 }
 
-SkRegion::Op Renderer::getRegionOp(Json::Value& command) {
-    const char* op = command[SKJSONCANVAS_ATTRIBUTE_REGIONOP].asCString();
+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) {
-    Json::Value jsonMatrix = command[SKJSONCANVAS_ATTRIBUTE_MATRIX];
     SkMatrix matrix;
-    SkScalar values[] = { 
-        jsonMatrix[0][0].asFloat(), jsonMatrix[0][1].asFloat(), jsonMatrix[0][2].asFloat(),
-        jsonMatrix[1][0].asFloat(), jsonMatrix[1][1].asFloat(), jsonMatrix[1][2].asFloat(),
-        jsonMatrix[2][0].asFloat(), jsonMatrix[2][1].asFloat(), jsonMatrix[2][2].asFloat() 
-    };
-    matrix.set9(values);
+    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);
+        this->getRect(command[SKJSONCANVAS_ATTRIBUTE_BOUNDS], &bounds);
         rec.fBounds = &bounds;
     }
     SkPaint paint;
     if (command.isMember(SKJSONCANVAS_ATTRIBUTE_PAINT)) {
-        this->getPaint(command, &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, &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);
+    this->getRect(command[SKJSONCANVAS_ATTRIBUTE_COORDS], &rect);
     SkPaint paint;
-    this->getPaint(command, &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);
+    this->getRRect(command[SKJSONCANVAS_ATTRIBUTE_COORDS], &rrect);
     SkPaint paint;
-    this->getPaint(command, &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);
+    this->getRect(command[SKJSONCANVAS_ATTRIBUTE_COORDS], &rect);
     SkPaint paint;
-    this->getPaint(command, &paint);
+    this->getPaint(command[SKJSONCANVAS_ATTRIBUTE_PAINT], &paint);
     target->drawOval(rect, paint);
 }
 
 void Renderer::processPath(Json::Value& command, SkCanvas* target) {
-    Json::Value jsonPath = command[SKJSONCANVAS_ATTRIBUTE_PATH];
     SkPath path;
-    this->getPath(command, &path);
+    this->getPath(command[SKJSONCANVAS_ATTRIBUTE_PATH], &path);
     SkPaint paint;
-    this->getPaint(command, &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, &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, &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::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, &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), 
+    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), 
+    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, &path);
-    target->clipPath(path, this->getRegionOp(command), 
+    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, &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);
+    this->getRect(command[SKJSONCANVAS_ATTRIBUTE_DST], &dst);
     SkPaint* paintPtr;
     SkPaint paint;
     if (command.isMember(SKJSONCANVAS_ATTRIBUTE_PAINT)) {
-        this->getPaint(command, &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);
+        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, &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);
+    this->getRect(command[SKJSONCANVAS_ATTRIBUTE_DST], &dst);
     SkPaint* paintPtr;
     SkPaint paint;
     if (command.isMember(SKJSONCANVAS_ATTRIBUTE_PAINT)) {
-        this->getPaint(command, &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);
+        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