JSON API cleanups

tools/json/SkJSONCanvas.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 "SkJSONCanvas.h"
 #include "SkImageFilter.h"
 #include "SkMaskFilter.h"
@@ skipping 492 matching lines @@
         case SkCanvas::kLines_PointMode:
             return Json::Value(SKJSONCANVAS_POINTMODE_LINES);
         case SkCanvas::kPolygon_PointMode: 
             return Json::Value(SKJSONCANVAS_POINTMODE_POLYGON);
         default:
             SkASSERT(false);
             return Json::Value("<invalid point mode>");
     };
 }
 
-void SkJSONCanvas::updateMatrix() {
-    const SkMatrix& matrix = this->getTotalMatrix();
-    if (matrix != fLastMatrix) {
-        Json::Value command(Json::objectValue);
-        command[SKJSONCANVAS_COMMAND] = Json::Value(SKJSONCANVAS_COMMAND_MATRIX);
-        command[SKJSONCANVAS_ATTRIBUTE_MATRIX] = MakeMatrix(matrix);
-        fCommands.append(command);
-        fLastMatrix = matrix;
+void SkJSONCanvas::didConcat(const SkMatrix& matrix) {
+    Json::Value command(Json::objectValue);
+    switch (matrix.getType()) {
+        case SkMatrix::kTranslate_Mask:
+            command[SKJSONCANVAS_COMMAND] = Json::Value(SKJSONCANVAS_COMMAND_TRANSLATE);
+            command[SKJSONCANVAS_ATTRIBUTE_X] = Json::Value(matrix.get(SkMatrix::kMTransX));
+            command[SKJSONCANVAS_ATTRIBUTE_Y] = Json::Value(matrix.get(SkMatrix::kMTransY));
+            break;
+        case SkMatrix::kScale_Mask:
+            command[SKJSONCANVAS_COMMAND] = Json::Value(SKJSONCANVAS_COMMAND_SCALE);
+            command[SKJSONCANVAS_ATTRIBUTE_X] = Json::Value(matrix.get(SkMatrix::kMScaleX));
+            command[SKJSONCANVAS_ATTRIBUTE_Y] = Json::Value(matrix.get(SkMatrix::kMScaleY));
+            break;
+        default:
+            this->didSetMatrix(this->getTotalMatrix());
+            return;
     }
+    fCommands.append(command);
+}
+
+void SkJSONCanvas::didSetMatrix(const SkMatrix& matrix) {
+    Json::Value command(Json::objectValue);
+    command[SKJSONCANVAS_COMMAND] = Json::Value(SKJSONCANVAS_COMMAND_MATRIX);
+    command[SKJSONCANVAS_ATTRIBUTE_MATRIX] = this->makeMatrix(matrix);
+    fCommands.append(command);
 }
 
 void SkJSONCanvas::onDrawPaint(const SkPaint& paint) {
     Json::Value command(Json::objectValue);
     command[SKJSONCANVAS_COMMAND] = Json::Value(SKJSONCANVAS_COMMAND_PAINT);
     command[SKJSONCANVAS_ATTRIBUTE_PAINT] = this->makePaint(paint);
     fCommands.append(command);
 }
 
 void SkJSONCanvas::onDrawRect(const SkRect& rect, const SkPaint& paint) {
-    this->updateMatrix();
     Json::Value command(Json::objectValue);
     command[SKJSONCANVAS_COMMAND] = Json::Value(SKJSONCANVAS_COMMAND_RECT);
     command[SKJSONCANVAS_ATTRIBUTE_COORDS] = this->makeRect(rect);
     command[SKJSONCANVAS_ATTRIBUTE_PAINT] = this->makePaint(paint);
     fCommands.append(command);
 }
 
 void SkJSONCanvas::onDrawOval(const SkRect& rect, const SkPaint& paint) {
-    this->updateMatrix();
     Json::Value command(Json::objectValue);
     command[SKJSONCANVAS_COMMAND] = Json::Value(SKJSONCANVAS_COMMAND_OVAL);
     command[SKJSONCANVAS_ATTRIBUTE_COORDS] = this->makeRect(rect);
     command[SKJSONCANVAS_ATTRIBUTE_PAINT] = this->makePaint(paint);
     fCommands.append(command);
 }
 
 void SkJSONCanvas::onDrawRRect(const SkRRect& rrect, const SkPaint& paint) {
-    this->updateMatrix();
     Json::Value command(Json::objectValue);
     command[SKJSONCANVAS_COMMAND] = Json::Value(SKJSONCANVAS_COMMAND_RRECT);
     command[SKJSONCANVAS_ATTRIBUTE_COORDS] = this->makeRRect(rrect);
     command[SKJSONCANVAS_ATTRIBUTE_PAINT] = this->makePaint(paint);
     fCommands.append(command);
 }
 
 void SkJSONCanvas::onDrawDRRect(const SkRRect& outer, const SkRRect& inner, const SkPaint& paint) {
-    this->updateMatrix();
     Json::Value command(Json::objectValue);
     command[SKJSONCANVAS_COMMAND] = Json::Value(SKJSONCANVAS_COMMAND_RRECT);
     command[SKJSONCANVAS_ATTRIBUTE_INNER] = this->makeRRect(inner);
     command[SKJSONCANVAS_ATTRIBUTE_OUTER] = this->makeRRect(outer);
     command[SKJSONCANVAS_ATTRIBUTE_PAINT] = this->makePaint(paint);
     fCommands.append(command);
 }
 
 void SkJSONCanvas::onDrawPoints(SkCanvas::PointMode mode, size_t count, const SkPoint pts[], 
                                 const SkPaint& paint) {
-    this->updateMatrix();
     Json::Value command(Json::objectValue);
     command[SKJSONCANVAS_COMMAND] = Json::Value(SKJSONCANVAS_COMMAND_POINTS);
     command[SKJSONCANVAS_ATTRIBUTE_MODE] = this->makePointMode(mode);
     Json::Value points(Json::arrayValue);
     for (size_t i = 0; i < count; i++) {
         points.append(this->makePoint(pts[i]));
     }
     command[SKJSONCANVAS_ATTRIBUTE_POINTS] = points;
     command[SKJSONCANVAS_ATTRIBUTE_PAINT] = this->makePaint(paint);
     fCommands.append(command);
 }
 
 void SkJSONCanvas::onDrawVertices(SkCanvas::VertexMode, int vertexCount, const SkPoint vertices[],
                                   const SkPoint texs[], const SkColor colors[], SkXfermode*,
                                   const uint16_t indices[], int indexCount, const SkPaint&) {
     SkDebugf("unsupported: drawVertices\n");
+    Json::Value command(Json::objectValue);
+    command[SKJSONCANVAS_COMMAND] = Json::Value(SKJSONCANVAS_COMMAND_VERTICES);
+    fCommands.append(command);
 }
 
 void SkJSONCanvas::onDrawAtlas(const SkImage*, const SkRSXform[], const SkRect[], const SkColor[],
                                int count, SkXfermode::Mode, const SkRect* cull, const SkPaint*) {
     SkDebugf("unsupported: drawAtlas\n");
+    Json::Value command(Json::objectValue);
+    command[SKJSONCANVAS_COMMAND] = Json::Value(SKJSONCANVAS_COMMAND_ATLAS);
+    fCommands.append(command);
 }
 
 void SkJSONCanvas::onDrawPath(const SkPath& path, const SkPaint& paint) {
-    this->updateMatrix();
     Json::Value command(Json::objectValue);
     command[SKJSONCANVAS_COMMAND] = Json::Value(SKJSONCANVAS_COMMAND_PATH);
     command[SKJSONCANVAS_ATTRIBUTE_PATH] = this->makePath(path);
     command[SKJSONCANVAS_ATTRIBUTE_PAINT] = this->makePaint(paint);
     fCommands.append(command);
 }
 
 void SkJSONCanvas::onDrawImage(const SkImage* image, SkScalar dx, SkScalar dy, 
                                const SkPaint* paint) {
     Json::Value encoded;
     if (flatten(*image, &encoded, fSendBinaries)) {
-        this->updateMatrix();
         Json::Value command(Json::objectValue);
         command[SKJSONCANVAS_COMMAND] = Json::Value(SKJSONCANVAS_COMMAND_IMAGE);
         command[SKJSONCANVAS_ATTRIBUTE_IMAGE] = encoded;
         command[SKJSONCANVAS_ATTRIBUTE_COORDS] = this->makePoint(dx, dy);
         if (paint != nullptr) {
             command[SKJSONCANVAS_ATTRIBUTE_PAINT] = this->makePaint(*paint);
         }
         fCommands.append(command);
     }
 }
 
 void SkJSONCanvas::onDrawImageRect(const SkImage* image, const SkRect* src, const SkRect& dst, 
                                    const SkPaint* paint, SkCanvas::SrcRectConstraint constraint) {
     Json::Value encoded;
     if (flatten(*image, &encoded, fSendBinaries)) {
-        this->updateMatrix();
         Json::Value command(Json::objectValue);
         command[SKJSONCANVAS_COMMAND] = Json::Value(SKJSONCANVAS_COMMAND_IMAGERECT);
         command[SKJSONCANVAS_ATTRIBUTE_IMAGE] = encoded;
         if (src != nullptr) {
             command[SKJSONCANVAS_ATTRIBUTE_SRC] = this->makeRect(*src);
         }
         command[SKJSONCANVAS_ATTRIBUTE_DST] = this->makeRect(dst);
         if (paint != nullptr) {
             command[SKJSONCANVAS_ATTRIBUTE_PAINT] = this->makePaint(*paint);
         }
         if (constraint == SkCanvas::kStrict_SrcRectConstraint) {
             command[SKJSONCANVAS_ATTRIBUTE_STRICT] = Json::Value(true);
         }
         fCommands.append(command);
     }
 }
 
 void SkJSONCanvas::onDrawImageNine(const SkImage*, const SkIRect& center, const SkRect& dst,
                                    const SkPaint*) {
     SkDebugf("unsupported: drawImageNine\n");
+    Json::Value command(Json::objectValue);
+    command[SKJSONCANVAS_COMMAND] = Json::Value(SKJSONCANVAS_COMMAND_IMAGENINE);
+    fCommands.append(command);
 }
 
 void SkJSONCanvas::onDrawBitmap(const SkBitmap& bitmap, SkScalar dx, SkScalar dy, 
                                 const SkPaint* paint) {
     Json::Value encoded;
     if (flatten(bitmap, &encoded, fSendBinaries)) {
-        this->updateMatrix();
         Json::Value command(Json::objectValue);
         command[SKJSONCANVAS_COMMAND] = Json::Value(SKJSONCANVAS_COMMAND_BITMAP);
         command[SKJSONCANVAS_ATTRIBUTE_BITMAP] = encoded;
         command[SKJSONCANVAS_ATTRIBUTE_COORDS] = this->makePoint(dx, dy);
         if (paint != nullptr) {
             command[SKJSONCANVAS_ATTRIBUTE_PAINT] = this->makePaint(*paint);
         }
         fCommands.append(command);
     }
 }
 
 void SkJSONCanvas::onDrawBitmapRect(const SkBitmap& bitmap, const SkRect* src, const SkRect& dst, 
                                    const SkPaint* paint, SkCanvas::SrcRectConstraint constraint) {
     Json::Value encoded;
     if (flatten(bitmap, &encoded, fSendBinaries)) {
-        this->updateMatrix();
         Json::Value command(Json::objectValue);
         command[SKJSONCANVAS_COMMAND] = Json::Value(SKJSONCANVAS_COMMAND_BITMAPRECT);
         command[SKJSONCANVAS_ATTRIBUTE_BITMAP] = encoded;
         if (src != nullptr) {
             command[SKJSONCANVAS_ATTRIBUTE_SRC] = this->makeRect(*src);
         }
         command[SKJSONCANVAS_ATTRIBUTE_DST] = this->makeRect(dst);
         if (paint != nullptr) {
             command[SKJSONCANVAS_ATTRIBUTE_PAINT] = this->makePaint(*paint);
         }
         if (constraint == SkCanvas::kStrict_SrcRectConstraint) {
             command[SKJSONCANVAS_ATTRIBUTE_STRICT] = Json::Value(true);
         }
         fCommands.append(command);
     }
 }
 
 void SkJSONCanvas::onDrawBitmapNine(const SkBitmap&, const SkIRect& center, const SkRect& dst,
                                     const SkPaint*) {
     SkDebugf("unsupported: drawBitmapNine\n");
+    Json::Value command(Json::objectValue);
+    command[SKJSONCANVAS_COMMAND] = Json::Value(SKJSONCANVAS_COMMAND_BITMAPNINE);
+    fCommands.append(command);
 }
 
 void SkJSONCanvas::onDrawText(const void* text, size_t byteLength, SkScalar x,
                               SkScalar y, const SkPaint& paint) {
-    this->updateMatrix();
     Json::Value command(Json::objectValue);
     command[SKJSONCANVAS_COMMAND] = Json::Value(SKJSONCANVAS_COMMAND_TEXT);
     command[SKJSONCANVAS_ATTRIBUTE_TEXT] = Json::Value((const char*) text, 
                                                        ((const char*) text) + byteLength);
     command[SKJSONCANVAS_ATTRIBUTE_COORDS] = this->makePoint(x, y);
     command[SKJSONCANVAS_ATTRIBUTE_PAINT] = this->makePaint(paint);
     fCommands.append(command);
 }
 
 void SkJSONCanvas::onDrawPosText(const void* text, size_t byteLength,
                                  const SkPoint pos[], const SkPaint& paint) {
-    this->updateMatrix();
     Json::Value command(Json::objectValue);
     command[SKJSONCANVAS_COMMAND] = Json::Value(SKJSONCANVAS_COMMAND_POSTEXT);
     command[SKJSONCANVAS_ATTRIBUTE_TEXT] = Json::Value((const char*) text, 
                                                        ((const char*) text) + byteLength);
     Json::Value coords(Json::arrayValue);
     for (size_t i = 0; i < byteLength; i++) {
         coords.append(this->makePoint(pos[i]));
     }
     command[SKJSONCANVAS_ATTRIBUTE_COORDS] = coords;
     command[SKJSONCANVAS_ATTRIBUTE_PAINT] = this->makePaint(paint);
     fCommands.append(command);
 }
 
 void SkJSONCanvas::onDrawPosTextH(const void* text, size_t byteLength,
                                   const SkScalar xpos[], SkScalar constY,
                                   const SkPaint& paint) {
     SkDebugf("unsupported: drawPosTextH\n");
+    Json::Value command(Json::objectValue);
+    command[SKJSONCANVAS_COMMAND] = Json::Value(SKJSONCANVAS_COMMAND_POSTEXTH);
+    fCommands.append(command);
 }
 
 void SkJSONCanvas::onDrawTextOnPath(const void* text, size_t byteLength,
                                     const SkPath& path, const SkMatrix* matrix,
                                     const SkPaint& paint) {
-    SkDebugf("unsupported: drawTextOnPath\n");
+    Json::Value command(Json::objectValue);
+    command[SKJSONCANVAS_COMMAND] = Json::Value(SKJSONCANVAS_COMMAND_TEXTONPATH);
+    command[SKJSONCANVAS_ATTRIBUTE_TEXT] = Json::Value((const char*) text, 
+                                                       ((const char*) text) + byteLength);
+    command[SKJSONCANVAS_ATTRIBUTE_PATH] = this->makePath(path);
+    if (matrix != nullptr) {
+        command[SKJSONCANVAS_ATTRIBUTE_MATRIX] = this->makeMatrix(*matrix);
+    }
+    command[SKJSONCANVAS_ATTRIBUTE_PAINT] = this->makePaint(paint);
+    fCommands.append(command);
 }
 
 void SkJSONCanvas::onDrawTextBlob(const SkTextBlob* blob, SkScalar x, SkScalar y,
                                   const SkPaint& paint) {
     SkDebugf("unsupported: drawTextBlob\n");
+    Json::Value command(Json::objectValue);
+    command[SKJSONCANVAS_COMMAND] = Json::Value(SKJSONCANVAS_COMMAND_TEXTBLOB);
+    fCommands.append(command);
 }
 
 void SkJSONCanvas::onDrawPatch(const SkPoint cubics[12], const SkColor colors[4],
                                const SkPoint texCoords[4], SkXfermode* xmode, 
                                const SkPaint& paint) {
     SkDebugf("unsupported: drawPatch\n");
+    Json::Value command(Json::objectValue);
+    command[SKJSONCANVAS_COMMAND] = Json::Value(SKJSONCANVAS_COMMAND_PATCH);
+    fCommands.append(command);
 }
 
 void SkJSONCanvas::onDrawDrawable(SkDrawable*, const SkMatrix*) {
     SkDebugf("unsupported: drawDrawable\n");
+    Json::Value command(Json::objectValue);
+    command[SKJSONCANVAS_COMMAND] = Json::Value(SKJSONCANVAS_COMMAND_DRAWABLE);
+    fCommands.append(command);
 }
 
 void SkJSONCanvas::onClipRect(const SkRect& rect, SkRegion::Op op, ClipEdgeStyle edgeStyle) {
-    this->updateMatrix();
     Json::Value command(Json::objectValue);
     command[SKJSONCANVAS_COMMAND] = Json::Value(SKJSONCANVAS_COMMAND_CLIPRECT);
     command[SKJSONCANVAS_ATTRIBUTE_COORDS] = this->makeRect(rect);
     command[SKJSONCANVAS_ATTRIBUTE_REGIONOP] = this->makeRegionOp(op);
     command[SKJSONCANVAS_ATTRIBUTE_ANTIALIAS] = (edgeStyle == SkCanvas::kSoft_ClipEdgeStyle);
     fCommands.append(command);
 }
 
 void SkJSONCanvas::onClipRRect(const SkRRect& rrect, SkRegion::Op op, ClipEdgeStyle edgeStyle) {
-    this->updateMatrix();
     Json::Value command(Json::objectValue);
     command[SKJSONCANVAS_COMMAND] = Json::Value(SKJSONCANVAS_COMMAND_CLIPRRECT);
     command[SKJSONCANVAS_ATTRIBUTE_COORDS] = this->makeRRect(rrect);
     command[SKJSONCANVAS_ATTRIBUTE_REGIONOP] = this->makeRegionOp(op);
     command[SKJSONCANVAS_ATTRIBUTE_ANTIALIAS] = (edgeStyle == SkCanvas::kSoft_ClipEdgeStyle);
     fCommands.append(command);
 }
 
 void SkJSONCanvas::onClipPath(const SkPath& path, SkRegion::Op op, ClipEdgeStyle edgeStyle) {
-    this->updateMatrix();
     Json::Value command(Json::objectValue);
     command[SKJSONCANVAS_COMMAND] = Json::Value(SKJSONCANVAS_COMMAND_CLIPPATH);
     command[SKJSONCANVAS_ATTRIBUTE_PATH] = this->makePath(path);
     command[SKJSONCANVAS_ATTRIBUTE_REGIONOP] = this->makeRegionOp(op);
     command[SKJSONCANVAS_ATTRIBUTE_ANTIALIAS] = (edgeStyle == SkCanvas::kSoft_ClipEdgeStyle);
     fCommands.append(command);
 }
 
 void SkJSONCanvas::onClipRegion(const SkRegion& deviceRgn, SkRegion::Op op) {
-    this->updateMatrix();
     Json::Value command(Json::objectValue);
     command[SKJSONCANVAS_COMMAND] = Json::Value(SKJSONCANVAS_COMMAND_CLIPREGION);
     command[SKJSONCANVAS_ATTRIBUTE_REGION] = this->makeRegion(deviceRgn);
     command[SKJSONCANVAS_ATTRIBUTE_REGIONOP] = this->makeRegionOp(op);
     fCommands.append(command);
 }
 
 void SkJSONCanvas::willSave() {
-    this->updateMatrix();
     Json::Value command(Json::objectValue);
     command[SKJSONCANVAS_COMMAND] = Json::Value(SKJSONCANVAS_COMMAND_SAVE);
     fCommands.append(command);
 }
 
 void SkJSONCanvas::willRestore() {
     Json::Value command(Json::objectValue);
     command[SKJSONCANVAS_COMMAND] = Json::Value(SKJSONCANVAS_COMMAND_RESTORE);
     fCommands.append(command);
 }
 
 SkCanvas::SaveLayerStrategy SkJSONCanvas::getSaveLayerStrategy(const SaveLayerRec& rec) {
-    this->updateMatrix();
     Json::Value command(Json::objectValue);
     command[SKJSONCANVAS_COMMAND] = Json::Value(SKJSONCANVAS_COMMAND_SAVELAYER);
     if (rec.fBounds != nullptr) {
         command[SKJSONCANVAS_ATTRIBUTE_BOUNDS] = this->makeRect(*rec.fBounds);
     }
     if (rec.fPaint != nullptr) {
         command[SKJSONCANVAS_ATTRIBUTE_PAINT] = this->makePaint(*rec.fPaint);
     }
     if (rec.fBackdrop != nullptr) {
         Json::Value backdrop;
         flatten(rec.fBackdrop, &backdrop, fSendBinaries);
         command[SKJSONCANVAS_ATTRIBUTE_BACKDROP] = backdrop;
     }
     if (rec.fSaveLayerFlags != 0) {
         SkDebugf("unsupported: saveLayer flags\n");
     }
     fCommands.append(command);
     return this->INHERITED::getSaveLayerStrategy(rec);
 }