added JSON support for various lesser-used features

tools/debugger/SkDrawCommand.cpp

 
 /*
  * Copyright 2012 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 
 #include "SkDrawCommand.h"
@@ skipping 24 matching lines @@
 #define SKDEBUGCANVAS_ATTRIBUTE_INNER             "inner"
 #define SKDEBUGCANVAS_ATTRIBUTE_MODE              "mode"
 #define SKDEBUGCANVAS_ATTRIBUTE_POINTS            "points"
 #define SKDEBUGCANVAS_ATTRIBUTE_PATH              "path"
 #define SKDEBUGCANVAS_ATTRIBUTE_TEXT              "text"
 #define SKDEBUGCANVAS_ATTRIBUTE_COLOR             "color"
 #define SKDEBUGCANVAS_ATTRIBUTE_ALPHA             "alpha"
 #define SKDEBUGCANVAS_ATTRIBUTE_STYLE             "style"
 #define SKDEBUGCANVAS_ATTRIBUTE_STROKEWIDTH       "strokeWidth"
 #define SKDEBUGCANVAS_ATTRIBUTE_STROKEMITER       "strokeMiter"
+#define SKDEBUGCANVAS_ATTRIBUTE_STROKEJOIN        "strokeJoin"
 #define SKDEBUGCANVAS_ATTRIBUTE_CAP               "cap"
 #define SKDEBUGCANVAS_ATTRIBUTE_ANTIALIAS         "antiAlias"
+#define SKDEBUGCANVAS_ATTRIBUTE_DITHER            "dither"
 #define SKDEBUGCANVAS_ATTRIBUTE_REGION            "region"
 #define SKDEBUGCANVAS_ATTRIBUTE_REGIONOP          "op"
 #define SKDEBUGCANVAS_ATTRIBUTE_EDGESTYLE         "edgeStyle"
 #define SKDEBUGCANVAS_ATTRIBUTE_DEVICEREGION      "deviceRegion"
 #define SKDEBUGCANVAS_ATTRIBUTE_BLUR              "blur"
 #define SKDEBUGCANVAS_ATTRIBUTE_SIGMA             "sigma"
 #define SKDEBUGCANVAS_ATTRIBUTE_QUALITY           "quality"
 #define SKDEBUGCANVAS_ATTRIBUTE_TEXTALIGN         "textAlign"
 #define SKDEBUGCANVAS_ATTRIBUTE_TEXTSIZE          "textSize"
 #define SKDEBUGCANVAS_ATTRIBUTE_TEXTSCALEX        "textScaleX"
 #define SKDEBUGCANVAS_ATTRIBUTE_TEXTSKEWX         "textSkewX"
 #define SKDEBUGCANVAS_ATTRIBUTE_DASHING           "dashing"
 #define SKDEBUGCANVAS_ATTRIBUTE_INTERVALS         "intervals"
 #define SKDEBUGCANVAS_ATTRIBUTE_PHASE             "phase"
 #define SKDEBUGCANVAS_ATTRIBUTE_FILLTYPE          "fillType"
 #define SKDEBUGCANVAS_ATTRIBUTE_VERBS             "verbs"
 #define SKDEBUGCANVAS_ATTRIBUTE_NAME              "name"
 #define SKDEBUGCANVAS_ATTRIBUTE_BYTES             "bytes"
 #define SKDEBUGCANVAS_ATTRIBUTE_SHADER            "shader"
 #define SKDEBUGCANVAS_ATTRIBUTE_PATHEFFECT        "pathEffect"
 #define SKDEBUGCANVAS_ATTRIBUTE_MASKFILTER        "maskFilter"
 #define SKDEBUGCANVAS_ATTRIBUTE_XFERMODE          "xfermode"
+#define SKDEBUGCANVAS_ATTRIBUTE_LOOPER            "looper"
 #define SKDEBUGCANVAS_ATTRIBUTE_BACKDROP          "backdrop"
 #define SKDEBUGCANVAS_ATTRIBUTE_COLORFILTER       "colorfilter"
 #define SKDEBUGCANVAS_ATTRIBUTE_IMAGEFILTER       "imagefilter"
 #define SKDEBUGCANVAS_ATTRIBUTE_IMAGE             "image"
 #define SKDEBUGCANVAS_ATTRIBUTE_BITMAP            "bitmap"
 #define SKDEBUGCANVAS_ATTRIBUTE_SRC               "src"
 #define SKDEBUGCANVAS_ATTRIBUTE_DST               "dst"
 #define SKDEBUGCANVAS_ATTRIBUTE_CENTER            "center"
 #define SKDEBUGCANVAS_ATTRIBUTE_STRICT            "strict"
 #define SKDEBUGCANVAS_ATTRIBUTE_DESCRIPTION       "description"
 #define SKDEBUGCANVAS_ATTRIBUTE_X                 "x"
 #define SKDEBUGCANVAS_ATTRIBUTE_Y                 "y"
 #define SKDEBUGCANVAS_ATTRIBUTE_RUNS              "runs"
 #define SKDEBUGCANVAS_ATTRIBUTE_POSITIONS         "positions"
 #define SKDEBUGCANVAS_ATTRIBUTE_GLYPHS            "glyphs"
 #define SKDEBUGCANVAS_ATTRIBUTE_FONT              "font"
 #define SKDEBUGCANVAS_ATTRIBUTE_TYPEFACE          "typeface"
+#define SKDEBUGCANVAS_ATTRIBUTE_CUBICS            "cubics"
+#define SKDEBUGCANVAS_ATTRIBUTE_COLORS            "colors"
+#define SKDEBUGCANVAS_ATTRIBUTE_TEXTURECOORDS     "textureCoords"
+#define SKDEBUGCANVAS_ATTRIBUTE_FILTERQUALITY     "filterQuality"
 
 #define SKDEBUGCANVAS_VERB_MOVE                   "move"
 #define SKDEBUGCANVAS_VERB_LINE                   "line"
 #define SKDEBUGCANVAS_VERB_QUAD                   "quad"
 #define SKDEBUGCANVAS_VERB_CUBIC                  "cubic"
 #define SKDEBUGCANVAS_VERB_CONIC                  "conic"
 #define SKDEBUGCANVAS_VERB_CLOSE                  "close"
 
 #define SKDEBUGCANVAS_STYLE_FILL                  "fill"
 #define SKDEBUGCANVAS_STYLE_STROKE                "stroke"
@@ skipping 24 matching lines @@
 
 #define SKDEBUGCANVAS_FILLTYPE_WINDING            "winding"
 #define SKDEBUGCANVAS_FILLTYPE_EVENODD            "evenOdd"
 #define SKDEBUGCANVAS_FILLTYPE_INVERSEWINDING     "inverseWinding"
 #define SKDEBUGCANVAS_FILLTYPE_INVERSEEVENODD     "inverseEvenOdd"
 
 #define SKDEBUGCANVAS_CAP_BUTT                    "butt"
 #define SKDEBUGCANVAS_CAP_ROUND                   "round"
 #define SKDEBUGCANVAS_CAP_SQUARE                  "square"
 
+#define SKDEBUGCANVAS_MITER_JOIN                  "miter"
+#define SKDEBUGCANVAS_ROUND_JOIN                  "round"
+#define SKDEBUGCANVAS_BEVEL_JOIN                  "bevel"
+
 #define SKDEBUGCANVAS_COLORTYPE_ARGB4444          "ARGB4444"
 #define SKDEBUGCANVAS_COLORTYPE_RGBA8888          "RGBA8888"
 #define SKDEBUGCANVAS_COLORTYPE_BGRA8888          "BGRA8888"
 #define SKDEBUGCANVAS_COLORTYPE_565               "565"
 #define SKDEBUGCANVAS_COLORTYPE_GRAY8             "Gray8"
 #define SKDEBUGCANVAS_COLORTYPE_INDEX8            "Index8"
 #define SKDEBUGCANVAS_COLORTYPE_ALPHA8            "Alpha8"
 
 #define SKDEBUGCANVAS_ALPHATYPE_OPAQUE            "opaque"
 #define SKDEBUGCANVAS_ALPHATYPE_PREMUL            "premul"
 #define SKDEBUGCANVAS_ALPHATYPE_UNPREMUL          "unpremul"
 
+#define SKDEBUGCANVAS_FILTERQUALITY_NONE          "none"
+#define SKDEBUGCANVAS_FILTERQUALITY_LOW           "low"
+#define SKDEBUGCANVAS_FILTERQUALITY_MEDIUM        "medium"
+#define SKDEBUGCANVAS_FILTERQUALITY_HIGH          "high"
+
 typedef SkDrawCommand* (*FROM_JSON)(Json::Value);
 
 // TODO(chudy): Refactor into non subclass model.
 
 SkDrawCommand::SkDrawCommand(OpType type)
     : fOpType(type)
     , fVisible(true) {
 }
 
 SkDrawCommand::~SkDrawCommand() {
@@ skipping 75 matching lines @@
         INSTALL_FACTORY(DrawPath);
         INSTALL_FACTORY(DrawPoints);
         INSTALL_FACTORY(DrawText);
         INSTALL_FACTORY(DrawPosText);
         INSTALL_FACTORY(DrawTextOnPath);
         INSTALL_FACTORY(DrawTextBlob);
 
         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);
 }
 
-SkClearCommand::SkClearCommand(SkColor color) : INHERITED(kDrawClear_OpType) {
-    fColor = color;
-    fInfo.push(SkObjectParser::CustomTextToString("No Parameters"));
-}
-
-void SkClearCommand::execute(SkCanvas* canvas) const {
-    canvas->clear(fColor);
-}
-
-Json::Value SkClearCommand::toJSON() const {
-    Json::Value result = INHERITED::toJSON();
-    Json::Value colorValue(Json::arrayValue);
-    colorValue.append(Json::Value(SkColorGetA(fColor)));
-    colorValue.append(Json::Value(SkColorGetR(fColor)));
-    colorValue.append(Json::Value(SkColorGetG(fColor)));
-    colorValue.append(Json::Value(SkColorGetB(fColor)));
-    result[SKDEBUGCANVAS_ATTRIBUTE_COLOR] = colorValue;;
-    return result;
-}
-
- SkClearCommand* SkClearCommand::fromJSON(Json::Value& command) {
-    Json::Value color = command[SKDEBUGCANVAS_ATTRIBUTE_COLOR];
-    return new SkClearCommand(SkColorSetARGB(color[0].asInt(), color[1].asInt(), color[2].asInt(),
-                                             color[3].asInt()));
-}
-
 namespace {
 
 void xlate_and_scale_to_bounds(SkCanvas* canvas, const SkRect& bounds) {
     const SkISize& size = canvas->getDeviceSize();
 
     static const SkScalar kInsetFrac = 0.9f; // Leave a border around object
 
     canvas->translate(size.fWidth/2.0f, size.fHeight/2.0f);
     if (bounds.width() > bounds.height()) {
         canvas->scale(SkDoubleToScalar((kInsetFrac*size.fWidth)/bounds.width()),
@@ skipping 101 matching lines @@
     SkPaint p;
     p.setColor(SK_ColorBLACK);
     p.setStyle(SkPaint::kStroke_Style);
 
     canvas->drawDRRect(outer, inner, p);
     canvas->restore();
 }
 
 };
 
+static Json::Value make_json_color(const SkColor color) {
+    Json::Value result(Json::arrayValue);
+    result.append(Json::Value(SkColorGetA(color)));
+    result.append(Json::Value(SkColorGetR(color)));
+    result.append(Json::Value(SkColorGetG(color)));
+    result.append(Json::Value(SkColorGetB(color)));
+    return result;
+}
+
+
 static Json::Value make_json_point(const SkPoint& point) {
     Json::Value result(Json::arrayValue);
     result.append(Json::Value(point.x()));
     result.append(Json::Value(point.y()));
     return result;
 }
 
 static Json::Value make_json_point(SkScalar x, SkScalar y) {
     Json::Value result(Json::arrayValue);
     result.append(Json::Value(x));
@@ skipping 41 matching lines @@
     row2.append(Json::Value(matrix[4]));
     row2.append(Json::Value(matrix[5]));
     result.append(row2);
     Json::Value row3(Json::arrayValue);
     row3.append(Json::Value(matrix[6]));
     row3.append(Json::Value(matrix[7]));
     row3.append(Json::Value(matrix[8]));
     result.append(row3);
     return result;
 }
+
 static Json::Value make_json_path(const SkPath& path) {
     Json::Value result(Json::objectValue);
     switch (path.getFillType()) {
         case SkPath::kWinding_FillType:
             result[SKDEBUGCANVAS_ATTRIBUTE_FILLTYPE] = SKDEBUGCANVAS_FILLTYPE_WINDING;
             break;
         case SkPath::kEvenOdd_FillType:
             result[SKDEBUGCANVAS_ATTRIBUTE_FILLTYPE] = SKDEBUGCANVAS_FILLTYPE_EVENODD;
             break;
         case SkPath::kInverseWinding_FillType:
@@ skipping 359 matching lines @@
             }
             default: SkASSERT(false);
         }
     }
 }
 
 static void apply_paint_cap(const SkPaint& paint, Json::Value* target) {
     SkPaint::Cap cap = paint.getStrokeCap();
     if (cap != SkPaint::kDefault_Cap) {
         switch (cap) {
-            case SkPaint::kButt_Cap: {
+            case SkPaint::kButt_Cap:
                 (*target)[SKDEBUGCANVAS_ATTRIBUTE_CAP] = Json::Value(SKDEBUGCANVAS_CAP_BUTT);
                 break;
-            }
-            case SkPaint::kRound_Cap: {
+            case SkPaint::kRound_Cap:
                 (*target)[SKDEBUGCANVAS_ATTRIBUTE_CAP] = Json::Value(SKDEBUGCANVAS_CAP_ROUND);
                 break;
-            }
-            case SkPaint::kSquare_Cap: {
+            case SkPaint::kSquare_Cap:
                 (*target)[SKDEBUGCANVAS_ATTRIBUTE_CAP] = Json::Value(SKDEBUGCANVAS_CAP_SQUARE);
                 break;
-            }
             default: SkASSERT(false);
         }
     }
 }
+
+static void apply_paint_join(const SkPaint& paint, Json::Value* target) {
+    SkPaint::Join join = paint.getStrokeJoin();
+    if (join != SkPaint::kDefault_Join) {
+        switch (join) {
+            case SkPaint::kMiter_Join:
+                (*target)[SKDEBUGCANVAS_ATTRIBUTE_STROKEJOIN] = Json::Value(
+                                                                          SKDEBUGCANVAS_MITER_JOIN);
+                break;
+            case SkPaint::kRound_Join:
+                (*target)[SKDEBUGCANVAS_ATTRIBUTE_STROKEJOIN] = Json::Value(
+                                                                          SKDEBUGCANVAS_ROUND_JOIN);
+                break;
+            case SkPaint::kBevel_Join:
+                (*target)[SKDEBUGCANVAS_ATTRIBUTE_STROKEJOIN] = Json::Value(
+                                                                        SKDEBUGCANVAS_BEVEL_JOIN);
+                break;
+            default: SkASSERT(false);
+        }
+    }
+}
+
+static void apply_paint_filterquality(const SkPaint& paint, Json::Value* target) {
+    SkFilterQuality quality = paint.getFilterQuality();
+    switch (quality) {
+        case kNone_SkFilterQuality:
+            break;
+        case kLow_SkFilterQuality:
+            (*target)[SKDEBUGCANVAS_ATTRIBUTE_FILTERQUALITY] = Json::Value(
+                                                                   SKDEBUGCANVAS_FILTERQUALITY_LOW);
+            break;
+        case kMedium_SkFilterQuality:
+            (*target)[SKDEBUGCANVAS_ATTRIBUTE_FILTERQUALITY] = Json::Value(
+                                                                SKDEBUGCANVAS_FILTERQUALITY_MEDIUM);
+            break;
+        case kHigh_SkFilterQuality:
+            (*target)[SKDEBUGCANVAS_ATTRIBUTE_FILTERQUALITY] = Json::Value(
+                                                                  SKDEBUGCANVAS_FILTERQUALITY_HIGH);
+            break;
+    }
+}
+
 static void apply_paint_maskfilter(const SkPaint& paint, Json::Value* target, bool sendBinaries) {
     SkMaskFilter* maskFilter = paint.getMaskFilter();
     if (maskFilter != nullptr) {
         SkMaskFilter::BlurRec blurRec;
         if (maskFilter->asABlur(&blurRec)) {
             Json::Value blur(Json::objectValue);
             blur[SKDEBUGCANVAS_ATTRIBUTE_SIGMA] = Json::Value(blurRec.fSigma);
             switch (blurRec.fStyle) {
                 case SkBlurStyle::kNormal_SkBlurStyle:
-                    blur[SKDEBUGCANVAS_ATTRIBUTE_STYLE] = Json::Value(SKDEBUGCANVAS_BLURSTYLE_NORMAL);
+                    blur[SKDEBUGCANVAS_ATTRIBUTE_STYLE] = Json::Value(
+                                                                    SKDEBUGCANVAS_BLURSTYLE_NORMAL);
                     break;
                 case SkBlurStyle::kSolid_SkBlurStyle:
-                    blur[SKDEBUGCANVAS_ATTRIBUTE_STYLE] = Json::Value(SKDEBUGCANVAS_BLURSTYLE_SOLID);
+                    blur[SKDEBUGCANVAS_ATTRIBUTE_STYLE] = Json::Value(
+                                                                     SKDEBUGCANVAS_BLURSTYLE_SOLID);
                     break;
                 case SkBlurStyle::kOuter_SkBlurStyle:
-                    blur[SKDEBUGCANVAS_ATTRIBUTE_STYLE] = Json::Value(SKDEBUGCANVAS_BLURSTYLE_OUTER);
+                    blur[SKDEBUGCANVAS_ATTRIBUTE_STYLE] = Json::Value(
+                                                                     SKDEBUGCANVAS_BLURSTYLE_OUTER);
                     break;
                 case SkBlurStyle::kInner_SkBlurStyle:
-                    blur[SKDEBUGCANVAS_ATTRIBUTE_STYLE] = Json::Value(SKDEBUGCANVAS_BLURSTYLE_INNER);
+                    blur[SKDEBUGCANVAS_ATTRIBUTE_STYLE] = Json::Value(
+                                                                     SKDEBUGCANVAS_BLURSTYLE_INNER);
                     break;
                 default:
                     SkASSERT(false);
             }
             switch (blurRec.fQuality) {
                 case SkBlurQuality::kLow_SkBlurQuality:
-                    blur[SKDEBUGCANVAS_ATTRIBUTE_QUALITY] = Json::Value(SKDEBUGCANVAS_BLURQUALITY_LOW);
+                    blur[SKDEBUGCANVAS_ATTRIBUTE_QUALITY] = Json::Value(
+                                                                     SKDEBUGCANVAS_BLURQUALITY_LOW);
                     break;
                 case SkBlurQuality::kHigh_SkBlurQuality:
-                    blur[SKDEBUGCANVAS_ATTRIBUTE_QUALITY] = Json::Value(SKDEBUGCANVAS_BLURQUALITY_HIGH);
+                    blur[SKDEBUGCANVAS_ATTRIBUTE_QUALITY] = Json::Value(
+                                                                    SKDEBUGCANVAS_BLURQUALITY_HIGH);
                     break;
                 default:
                     SkASSERT(false);
             }
             (*target)[SKDEBUGCANVAS_ATTRIBUTE_BLUR] = blur;
         } else {
             Json::Value jsonMaskFilter;
             flatten(maskFilter, &jsonMaskFilter, sendBinaries);
             (*target)[SKDEBUGCANVAS_ATTRIBUTE_MASKFILTER] = jsonMaskFilter;
         }
@@ skipping 90 matching lines @@
 
 static void apply_paint_colorfilter(const SkPaint& paint, Json::Value* target, bool sendBinaries) {
     SkFlattenable* colorFilter = paint.getColorFilter();
     if (colorFilter != nullptr) {
         Json::Value jsonColorFilter;
         flatten(colorFilter, &jsonColorFilter, sendBinaries);
         (*target)[SKDEBUGCANVAS_ATTRIBUTE_COLORFILTER] = jsonColorFilter;
     }
 }
 
+static void apply_paint_looper(const SkPaint& paint, Json::Value* target, bool sendBinaries) {
+    SkFlattenable* looper = paint.getLooper();
+    if (looper != nullptr) {
+        Json::Value jsonLooper;
+        flatten(looper, &jsonLooper, sendBinaries);
+        (*target)[SKDEBUGCANVAS_ATTRIBUTE_LOOPER] = jsonLooper;
+    }
+}
+
 Json::Value make_json_paint(const SkPaint& paint, bool sendBinaries) {
     Json::Value result(Json::objectValue);
     store_scalar(&result, SKDEBUGCANVAS_ATTRIBUTE_STROKEWIDTH, paint.getStrokeWidth(), 0.0f);
     store_scalar(&result, SKDEBUGCANVAS_ATTRIBUTE_STROKEMITER, paint.getStrokeMiter(), 
                  SkPaintDefaults_MiterLimit);
     store_bool(&result, SKDEBUGCANVAS_ATTRIBUTE_ANTIALIAS, paint.isAntiAlias(), false);
+    store_bool(&result, SKDEBUGCANVAS_ATTRIBUTE_DITHER, paint.isDither(), false);
     store_scalar(&result, SKDEBUGCANVAS_ATTRIBUTE_TEXTSIZE, paint.getTextSize(), 
                  SkPaintDefaults_TextSize);
     store_scalar(&result, SKDEBUGCANVAS_ATTRIBUTE_TEXTSCALEX, paint.getTextScaleX(), SK_Scalar1);
     store_scalar(&result, SKDEBUGCANVAS_ATTRIBUTE_TEXTSCALEX, paint.getTextSkewX(), 0.0f);
     apply_paint_color(paint, &result);
     apply_paint_style(paint, &result);
     apply_paint_cap(paint, &result);
+    apply_paint_join(paint, &result);
+    apply_paint_filterquality(paint, &result);
     apply_paint_textalign(paint, &result);
     apply_paint_patheffect(paint, &result, sendBinaries);
     apply_paint_maskfilter(paint, &result, sendBinaries);
     apply_paint_shader(paint, &result, sendBinaries);
     apply_paint_xfermode(paint, &result, sendBinaries);
+    apply_paint_looper(paint, &result, sendBinaries);
     apply_paint_imagefilter(paint, &result, sendBinaries);
     apply_paint_colorfilter(paint, &result, sendBinaries);
     apply_paint_typeface(paint, &result, sendBinaries);
     return result;
 }
 
+static SkPoint get_json_point(Json::Value point) {
+    return SkPoint::Make(point[0].asFloat(), point[1].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)) {
-        Json::Value color = jsonPaint[SKDEBUGCANVAS_ATTRIBUTE_COLOR];
-        target->setColor(SkColorSetARGB(color[0].asInt(), color[1].asInt(), color[2].asInt(),
-                         color[3].asInt()));
+        target->setColor(get_json_color(jsonPaint[SKDEBUGCANVAS_ATTRIBUTE_COLOR]));
     }
 }
 
 static void extract_json_paint_shader(Json::Value& jsonPaint, SkPaint* target) {
     if (jsonPaint.isMember(SKDEBUGCANVAS_ATTRIBUTE_SHADER)) {
         Json::Value jsonShader = jsonPaint[SKDEBUGCANVAS_ATTRIBUTE_SHADER];
         SkShader* shader = (SkShader*) load_flattenable(jsonShader);
         if (shader != nullptr) {
             target->setShader(shader);
             shader->unref();
@@ skipping 38 matching lines @@
     if (jsonPaint.isMember(SKDEBUGCANVAS_ATTRIBUTE_XFERMODE)) {
         Json::Value jsonXfermode = jsonPaint[SKDEBUGCANVAS_ATTRIBUTE_XFERMODE];
         SkXfermode* xfermode = (SkXfermode*) load_flattenable(jsonXfermode);
         if (xfermode != nullptr) {
             target->setXfermode(xfermode);
             xfermode->unref();
         }
     }
 }
 
+static void extract_json_paint_looper(Json::Value& jsonPaint, SkPaint* target) {
+    if (jsonPaint.isMember(SKDEBUGCANVAS_ATTRIBUTE_LOOPER)) {
+        Json::Value jsonLooper = jsonPaint[SKDEBUGCANVAS_ATTRIBUTE_LOOPER];
+        SkDrawLooper* looper = (SkDrawLooper*) load_flattenable(jsonLooper);
+        if (looper != nullptr) {
+            target->setLooper(looper);
+            looper->unref();
+        }
+    }
+}
+
 static void extract_json_paint_imagefilter(Json::Value& jsonPaint, SkPaint* target) {
     if (jsonPaint.isMember(SKDEBUGCANVAS_ATTRIBUTE_IMAGEFILTER)) {
         Json::Value jsonImageFilter = jsonPaint[SKDEBUGCANVAS_ATTRIBUTE_IMAGEFILTER];
         SkImageFilter* imageFilter = (SkImageFilter*) load_flattenable(jsonImageFilter);
         if (imageFilter != nullptr) {
             target->setImageFilter(imageFilter);
             imageFilter->unref();
         }
     }
 }
@@ skipping 20 matching lines @@
     }    
 }
 
 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_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)) {
@@ skipping 95 matching lines @@
     }
 }
 
 static void extract_json_paint(Json::Value& paint, SkPaint* result) {
     extract_json_paint_color(paint, result);
     extract_json_paint_shader(paint, result);
     extract_json_paint_patheffect(paint, result);
     extract_json_paint_maskfilter(paint, result);
     extract_json_paint_colorfilter(paint, result);
     extract_json_paint_xfermode(paint, result);
+    extract_json_paint_looper(paint, result);
     extract_json_paint_imagefilter(paint, result);
     extract_json_paint_style(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_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);
     extract_json_paint_typeface(paint, result);
 }
 
 static void extract_json_rect(Json::Value& rect, SkRect* result) {
@@ skipping 96 matching lines @@
     else if (!strcmp(op, SKDEBUGCANVAS_REGIONOP_REVERSE_DIFFERENCE)) {
         return SkRegion::kReverseDifference_Op;
     }
     else if (!strcmp(op, SKDEBUGCANVAS_REGIONOP_REPLACE)) {
         return SkRegion::kReplace_Op;
     }
     SkASSERT(false);
     return SkRegion::kIntersect_Op;
 }
 
+SkClearCommand::SkClearCommand(SkColor color) : INHERITED(kDrawClear_OpType) {
+    fColor = color;
+    fInfo.push(SkObjectParser::CustomTextToString("No Parameters"));
+}
+
+void SkClearCommand::execute(SkCanvas* canvas) const {
+    canvas->clear(fColor);
+}
+
+Json::Value SkClearCommand::toJSON() const {
+    Json::Value result = INHERITED::toJSON();
+    result[SKDEBUGCANVAS_ATTRIBUTE_COLOR] = make_json_color(fColor);
+    return result;
+}
+
+ SkClearCommand* SkClearCommand::fromJSON(Json::Value& command) {
+    Json::Value color = command[SKDEBUGCANVAS_ATTRIBUTE_COLOR];
+    return new SkClearCommand(get_json_color(color));
+}
 
 SkClipPathCommand::SkClipPathCommand(const SkPath& path, SkRegion::Op op, bool doAA)
     : INHERITED(kClipPath_OpType) {
     fPath = path;
     fOp = op;
     fDoAA = doAA;
 
     fInfo.push(SkObjectParser::PathToString(path));
     fInfo.push(SkObjectParser::RegionOpToString(op));
     fInfo.push(SkObjectParser::BoolToString(doAA));
@@ skipping 168 matching lines @@
 }
 
 Json::Value SkDrawBitmapCommand::toJSON() const {
     Json::Value result = INHERITED::toJSON();
     Json::Value encoded;
     if (flatten(fBitmap, &encoded, SKDEBUGCANVAS_SEND_BINARIES)) {
         Json::Value command(Json::objectValue);
         result[SKDEBUGCANVAS_ATTRIBUTE_BITMAP] = encoded;
         result[SKDEBUGCANVAS_ATTRIBUTE_COORDS] = make_json_point(fLeft, fTop);
         if (fPaintPtr != nullptr) {
-            result[SKDEBUGCANVAS_ATTRIBUTE_PAINT] = make_json_paint(*fPaintPtr, SKDEBUGCANVAS_SEND_BINARIES);
+            result[SKDEBUGCANVAS_ATTRIBUTE_PAINT] = make_json_paint(*fPaintPtr, 
+                                                                    SKDEBUGCANVAS_SEND_BINARIES);
         }
     }
     return result;
 }
 
 SkDrawBitmapCommand* SkDrawBitmapCommand::fromJSON(Json::Value& command) {
     SkBitmap* bitmap = load_bitmap(command[SKDEBUGCANVAS_ATTRIBUTE_BITMAP]);
     if (bitmap == nullptr) {
         return nullptr;
     }
@@ skipping 269 matching lines @@
         fInfo.push(SkObjectParser::RectToString(*src, "Src: "));
     }
     fInfo.push(SkObjectParser::RectToString(dst, "Dst: "));
     if (paint) {
         fInfo.push(SkObjectParser::PaintToString(*paint));
     }
     fInfo.push(SkObjectParser::IntToString(fConstraint, "Constraint: "));
 }
 
 void SkDrawImageRectCommand::execute(SkCanvas* canvas) const {
-    canvas->legacy_drawImageRect(fImage, fSrc.getMaybeNull(), fDst, fPaint.getMaybeNull(), fConstraint);
+    canvas->legacy_drawImageRect(fImage, fSrc.getMaybeNull(), fDst, fPaint.getMaybeNull(), 
+                                 fConstraint);
 }
 
 bool SkDrawImageRectCommand::render(SkCanvas* canvas) const {
     SkAutoCanvasRestore acr(canvas, true);
     canvas->clear(0xFFFFFFFF);
 
     xlate_and_scale_to_bounds(canvas, fDst);
 
     this->execute(canvas);
     return true;
@@ skipping 535 matching lines @@
     SkPaint paint;
     extract_json_paint(command[SKDEBUGCANVAS_ATTRIBUTE_PAINT], &paint);
     return new SkDrawTextBlobCommand(builder.build(), x, y, paint);
 }
 
 SkDrawPatchCommand::SkDrawPatchCommand(const SkPoint cubics[12], const SkColor colors[4],
                                        const SkPoint texCoords[4], SkXfermode* xfermode,
                                        const SkPaint& paint)
     : INHERITED(kDrawPatch_OpType) {
     memcpy(fCubics, cubics, sizeof(fCubics));
-    memcpy(fColors, colors, sizeof(fColors));
-    memcpy(fTexCoords, texCoords, sizeof(fTexCoords));
-    fXfermode.reset(xfermode);
+    if (colors != nullptr) {
+        memcpy(fColors, colors, sizeof(fColors));
+        fColorsPtr = fColors;
+    } else {
+        fColorsPtr = nullptr;
+    }
+    if (texCoords != nullptr) {
+        memcpy(fTexCoords, texCoords, sizeof(fTexCoords));
+        fTexCoordsPtr = fTexCoords;
+    } else {
+        fTexCoordsPtr = nullptr;
+    }
+    if (xfermode != nullptr) {
+        fXfermode.reset(SkRef(xfermode));
+    }
     fPaint = paint;
 
     fInfo.push(SkObjectParser::PaintToString(paint));
 }
 
 void SkDrawPatchCommand::execute(SkCanvas* canvas) const {
-    canvas->drawPatch(fCubics, fColors, fTexCoords, fXfermode, fPaint);
+    canvas->drawPatch(fCubics, fColorsPtr, fTexCoordsPtr, fXfermode, fPaint);
+}
+
+Json::Value SkDrawPatchCommand::toJSON() const {
+    Json::Value result = INHERITED::toJSON();
+    Json::Value cubics = Json::Value(Json::arrayValue);
+    for (int i = 0; i < 12; i++) {
+        cubics.append(make_json_point(fCubics[i]));
+    }
+    result[SKDEBUGCANVAS_ATTRIBUTE_CUBICS] = cubics;
+    if (fColorsPtr != nullptr) {
+        Json::Value colors = Json::Value(Json::arrayValue);
+        for (int i = 0; i < 4; i++) {
+            colors.append(make_json_color(fColorsPtr[i]));
+        }
+        result[SKDEBUGCANVAS_ATTRIBUTE_COLORS] = colors;
+    }
+    if (fTexCoordsPtr != nullptr) {
+        Json::Value texCoords = Json::Value(Json::arrayValue);
+        for (int i = 0; i < 4; i++) {
+            texCoords.append(make_json_point(fTexCoords[i]));
+        }
+        result[SKDEBUGCANVAS_ATTRIBUTE_TEXTURECOORDS] = texCoords;
+    }
+    if (fXfermode.get() != nullptr) {
+        Json::Value jsonXfermode;
+        flatten(fXfermode, &jsonXfermode, SKDEBUGCANVAS_SEND_BINARIES);
+        result[SKDEBUGCANVAS_ATTRIBUTE_XFERMODE] = jsonXfermode;
+    }
+    return result;
+}
+
+SkDrawPatchCommand* SkDrawPatchCommand::fromJSON(Json::Value& command) {
+    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;
+    }
+    SkAutoTUnref<SkXfermode> xfermode;
+    if (command.isMember(SKDEBUGCANVAS_ATTRIBUTE_XFERMODE)) {
+        Json::Value jsonXfermode = command[SKDEBUGCANVAS_ATTRIBUTE_XFERMODE];
+        xfermode.reset((SkXfermode*) load_flattenable(jsonXfermode));
+    }
+    SkPaint paint;
+    extract_json_paint(command[SKDEBUGCANVAS_ATTRIBUTE_PAINT], &paint);
+    return new SkDrawPatchCommand(cubics, colorsPtr, texCoordsPtr, xfermode, paint);
 }
 
 SkDrawRectCommand::SkDrawRectCommand(const SkRect& rect, const SkPaint& paint)
     : INHERITED(kDrawRect_OpType) {
     fRect = rect;
     fPaint = paint;
 
     fInfo.push(SkObjectParser::RectToString(rect));
     fInfo.push(SkObjectParser::PaintToString(paint));
 }
@@ skipping 364 matching lines @@
     if (rec.fBackdrop != nullptr) {
         rec.fBackdrop->unref();
     }
     return result;
 }
 
 SkSetMatrixCommand::SkSetMatrixCommand(const SkMatrix& matrix)
     : INHERITED(kSetMatrix_OpType) {
     fUserMatrix.reset();
     fMatrix = matrix;
-
     fInfo.push(SkObjectParser::MatrixToString(matrix));
 }
 
 void SkSetMatrixCommand::setUserMatrix(const SkMatrix& userMatrix) {
     fUserMatrix = userMatrix;
 }
 
 void SkSetMatrixCommand::execute(SkCanvas* canvas) const {
     SkMatrix temp = SkMatrix::Concat(fUserMatrix, fMatrix);
     canvas->setMatrix(temp);
 }
 
 Json::Value SkSetMatrixCommand::toJSON() const {
     Json::Value result = INHERITED::toJSON();
     result[SKDEBUGCANVAS_ATTRIBUTE_MATRIX] = make_json_matrix(fMatrix);
     return result;
 }
 
 SkSetMatrixCommand* SkSetMatrixCommand::fromJSON(Json::Value& command) {
     SkMatrix matrix;
     extract_json_matrix(command[SKDEBUGCANVAS_ATTRIBUTE_MATRIX], &matrix);
     return new SkSetMatrixCommand(matrix);
 }