Style bikeshed - remove extraneous whitespace

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 455 matching lines @@
             break;
         case SkPath::kEvenOdd_FillType:
             result[SKDEBUGCANVAS_ATTRIBUTE_FILLTYPE] = SKDEBUGCANVAS_FILLTYPE_EVENODD;
             break;
         case SkPath::kInverseWinding_FillType:
             result[SKDEBUGCANVAS_ATTRIBUTE_FILLTYPE] = SKDEBUGCANVAS_FILLTYPE_INVERSEWINDING;
             break;
         case SkPath::kInverseEvenOdd_FillType:
             result[SKDEBUGCANVAS_ATTRIBUTE_FILLTYPE] = SKDEBUGCANVAS_FILLTYPE_INVERSEEVENODD;
             break;
-    }    
+    }
     Json::Value verbs(Json::arrayValue);
     SkPath::Iter iter(path, false);
     SkPoint pts[4];
     SkPath::Verb verb;
     while ((verb = iter.next(pts)) != SkPath::kDone_Verb) {
         switch (verb) {
             case SkPath::kLine_Verb: {
                 Json::Value line(Json::objectValue);
                 line[SKDEBUGCANVAS_VERB_LINE] = make_json_point(pts[1]);
                 verbs.append(line);
@@ skipping 68 matching lines @@
             return Json::Value("<invalid region op>");
     };
 }
 
 static Json::Value make_json_pointmode(SkCanvas::PointMode mode) {
     switch (mode) {
         case SkCanvas::kPoints_PointMode:
             return Json::Value(SKDEBUGCANVAS_POINTMODE_POINTS);
         case SkCanvas::kLines_PointMode:
             return Json::Value(SKDEBUGCANVAS_POINTMODE_LINES);
-        case SkCanvas::kPolygon_PointMode: 
+        case SkCanvas::kPolygon_PointMode:
             return Json::Value(SKDEBUGCANVAS_POINTMODE_POLYGON);
         default:
             SkASSERT(false);
             return Json::Value("<invalid point mode>");
     };
 }
 
-static void store_scalar(Json::Value* target, const char* key, SkScalar value, 
+static void store_scalar(Json::Value* target, const char* key, SkScalar value,
                          SkScalar defaultValue) {
     if (value != defaultValue) {
         (*target)[key] = Json::Value(value);
     }
 }
 
 static void store_bool(Json::Value* target, const char* key, bool value, bool defaultValue) {
     if (value != defaultValue) {
         (*target)[key] = Json::Value(value);
     }
 }
 
-static void encode_data(const void* bytes, size_t count, const char* contentType, 
+static void encode_data(const void* bytes, size_t count, const char* contentType,
                         UrlDataManager& urlDataManager, Json::Value* target) {
     SkAutoTUnref<SkData> data(SkData::NewWithCopy(bytes, count));
     SkString url = urlDataManager.addData(data, contentType);
     *target = Json::Value(url.c_str());
 }
 
-static void flatten(const SkFlattenable* flattenable, Json::Value* target, 
+static void flatten(const SkFlattenable* flattenable, Json::Value* target,
                     UrlDataManager& urlDataManager) {
     SkWriteBuffer buffer;
     flattenable->flatten(buffer);
     void* data = sk_malloc_throw(buffer.bytesWritten());
     buffer.writeToMemory(data);
     Json::Value jsonData;
     encode_data(data, buffer.bytesWritten(), "application/octet-stream", urlDataManager, &jsonData);
     Json::Value jsonFlattenable;
     jsonFlattenable[SKDEBUGCANVAS_ATTRIBUTE_NAME] = Json::Value(flattenable->getTypeName());
     jsonFlattenable[SKDEBUGCANVAS_ATTRIBUTE_DATA] = jsonData;
     (*target) = jsonFlattenable;
     sk_free(data);
 }
 
 static void write_png_callback(png_structp png_ptr, png_bytep data, png_size_t length) {
     SkWStream* out = (SkWStream*) png_get_io_ptr(png_ptr);
     out->write(data, length);
 }
 
-void SkDrawCommand::WritePNG(const png_bytep rgba, png_uint_32 width, png_uint_32 height, 
+void SkDrawCommand::WritePNG(const png_bytep rgba, png_uint_32 width, png_uint_32 height,
                              SkWStream& out) {
     png_structp png = png_create_write_struct(PNG_LIBPNG_VER_STRING, NULL, NULL, NULL);
     SkASSERT(png != nullptr);
     png_infop info_ptr = png_create_info_struct(png);
     SkASSERT(info_ptr != nullptr);
     if (setjmp(png_jmpbuf(png))) {
         SkFAIL("png encode error");
     }
     png_set_IHDR(png, info_ptr, width, height, 8, PNG_COLOR_TYPE_RGB, PNG_INTERLACE_NONE,
                  PNG_COMPRESSION_TYPE_DEFAULT, PNG_FILTER_TYPE_DEFAULT);
@@ skipping 12 matching lines @@
     }
     png_set_filter(png, 0, PNG_NO_FILTERS);
     png_set_rows(png, info_ptr, &rows[0]);
     png_set_write_fn(png, &out, write_png_callback, NULL);
     png_write_png(png, info_ptr, PNG_TRANSFORM_IDENTITY, NULL);
     png_destroy_write_struct(&png, NULL);
     sk_free(rows);
     sk_free(pixels);
 }
 
-static bool SK_WARN_UNUSED_RESULT flatten(const SkImage& image, Json::Value* target, 
+static bool SK_WARN_UNUSED_RESULT flatten(const SkImage& image, Json::Value* target,
                                           UrlDataManager& urlDataManager) {
     size_t rowBytes = 4 * image.width();
     SkAutoFree buffer(sk_malloc_throw(rowBytes * image.height()));
-    SkImageInfo dstInfo = SkImageInfo::Make(image.width(), image.height(), 
+    SkImageInfo dstInfo = SkImageInfo::Make(image.width(), image.height(),
                                             kN32_SkColorType, kPremul_SkAlphaType);
     if (!image.readPixels(dstInfo, buffer.get(), rowBytes, 0, 0)) {
         SkDebugf("readPixels failed\n");
         return false;
     }
     SkDynamicMemoryWStream out;
     SkDrawCommand::WritePNG((png_bytep) buffer.get(), image.width(), image.height(), out);
     SkData* encoded = out.copyToData();
     Json::Value jsonData;
     encode_data(encoded->data(), encoded->size(), "image/png", urlDataManager, &jsonData);
@@ skipping 31 matching lines @@
         case kPremul_SkAlphaType:
             return SKDEBUGCANVAS_ALPHATYPE_PREMUL;
         case kUnpremul_SkAlphaType:
             return SKDEBUGCANVAS_ALPHATYPE_UNPREMUL;
         default:
             SkASSERT(false);
             return SKDEBUGCANVAS_ALPHATYPE_OPAQUE;
     }
 }
 
-static Json::ArrayIndex decode_data(Json::Value data, UrlDataManager& urlDataManager, 
+static Json::ArrayIndex decode_data(Json::Value data, UrlDataManager& urlDataManager,
                                     const void** target) {
     UrlDataManager::UrlData* urlData = urlDataManager.getDataFromUrl(SkString(data.asCString()));
     if (urlData == nullptr) {
         SkASSERT(false);
         *target = nullptr;
         return 0;
     }
     *target = urlData->fData->data();
     // cast should be safe for any reasonably-sized object...
     return (Json::ArrayIndex) urlData->fData->size();
 }
 
-static SkFlattenable* load_flattenable(Json::Value jsonFlattenable, 
+static SkFlattenable* load_flattenable(Json::Value jsonFlattenable,
                                        UrlDataManager& urlDataManager) {
     if (!jsonFlattenable.isMember(SKDEBUGCANVAS_ATTRIBUTE_NAME)) {
         return nullptr;
     }
     const char* name = jsonFlattenable[SKDEBUGCANVAS_ATTRIBUTE_NAME].asCString();
     SkFlattenable::Factory factory = SkFlattenable::NameToFactory(name);
     if (factory == nullptr) {
         SkDebugf("no factory for loading '%s'\n", name);
         return nullptr;
     }
@@ skipping 82 matching lines @@
 static sk_sp<SkImage> load_image(const Json::Value& jsonImage, UrlDataManager& urlDataManager) {
     SkBitmap* bitmap = load_bitmap(jsonImage, urlDataManager);
     if (bitmap == nullptr) {
         return nullptr;
     }
     auto result = SkImage::MakeFromBitmap(*bitmap);
     delete bitmap;
     return result;
 }
 
-static bool SK_WARN_UNUSED_RESULT flatten(const SkBitmap& bitmap, Json::Value* target, 
+static bool SK_WARN_UNUSED_RESULT flatten(const SkBitmap& bitmap, Json::Value* target,
                                           UrlDataManager& urlDataManager) {
     bitmap.lockPixels();
     sk_sp<SkImage> image(SkImage::MakeFromBitmap(bitmap));
     bitmap.unlockPixels();
     (*target)[SKDEBUGCANVAS_ATTRIBUTE_COLOR] = Json::Value(color_type_name(bitmap.colorType()));
     (*target)[SKDEBUGCANVAS_ATTRIBUTE_ALPHA] = Json::Value(alpha_type_name(bitmap.alphaType()));
     bool success = flatten(*image, target, urlDataManager);
     return success;
 }
 
@@ skipping 80 matching lines @@
             (*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, 
+static void apply_paint_maskfilter(const SkPaint& paint, Json::Value* target,
                                    UrlDataManager& urlDataManager) {
     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(
@@ skipping 28 matching lines @@
             }
             (*target)[SKDEBUGCANVAS_ATTRIBUTE_BLUR] = blur;
         } else {
             Json::Value jsonMaskFilter;
             flatten(maskFilter, &jsonMaskFilter, urlDataManager);
             (*target)[SKDEBUGCANVAS_ATTRIBUTE_MASKFILTER] = jsonMaskFilter;
         }
     }
 }
 
-static void apply_paint_patheffect(const SkPaint& paint, Json::Value* target, 
+static void apply_paint_patheffect(const SkPaint& paint, Json::Value* target,
                                    UrlDataManager& urlDataManager) {
     SkPathEffect* pathEffect = paint.getPathEffect();
     if (pathEffect != nullptr) {
         SkPathEffect::DashInfo dashInfo;
         SkPathEffect::DashType dashType = pathEffect->asADash(&dashInfo);
         if (dashType == SkPathEffect::kDash_DashType) {
             dashInfo.fIntervals = (SkScalar*) sk_malloc_throw(dashInfo.fCount * sizeof(SkScalar));
             pathEffect->asADash(&dashInfo);
             Json::Value dashing(Json::objectValue);
             Json::Value intervals(Json::arrayValue);
             for (int32_t i = 0; i < dashInfo.fCount; i++) {
                 intervals.append(Json::Value(dashInfo.fIntervals[i]));
             }
             sk_free(dashInfo.fIntervals);
             dashing[SKDEBUGCANVAS_ATTRIBUTE_INTERVALS] = intervals;
             dashing[SKDEBUGCANVAS_ATTRIBUTE_PHASE] = dashInfo.fPhase;
             (*target)[SKDEBUGCANVAS_ATTRIBUTE_DASHING] = dashing;
         } else {
             Json::Value jsonPathEffect;
             flatten(pathEffect, &jsonPathEffect, urlDataManager);
             (*target)[SKDEBUGCANVAS_ATTRIBUTE_PATHEFFECT] = jsonPathEffect;
         }
     }
 }
-    
+
 static void apply_paint_textalign(const SkPaint& paint, Json::Value* target) {
     SkPaint::Align textAlign = paint.getTextAlign();
     if (textAlign != SkPaint::kLeft_Align) {
         switch (textAlign) {
             case SkPaint::kCenter_Align: {
                 (*target)[SKDEBUGCANVAS_ATTRIBUTE_TEXTALIGN] = SKDEBUGCANVAS_ALIGN_CENTER;
                 break;
             }
             case SkPaint::kRight_Align: {
                 (*target)[SKDEBUGCANVAS_ATTRIBUTE_TEXTALIGN] = SKDEBUGCANVAS_ALIGN_RIGHT;
                 break;
             }
             default: SkASSERT(false);
         }
     }
 }
 
-static void apply_paint_typeface(const SkPaint& paint, Json::Value* target, 
+static void apply_paint_typeface(const SkPaint& paint, Json::Value* target,
                                  UrlDataManager& urlDataManager) {
     SkTypeface* typeface = paint.getTypeface();
     if (typeface != nullptr) {
         Json::Value jsonTypeface;
         SkDynamicMemoryWStream buffer;
         typeface->serialize(&buffer);
         void* data = sk_malloc_throw(buffer.bytesWritten());
         buffer.copyTo(data);
         Json::Value jsonData;
-        encode_data(data, buffer.bytesWritten(), "application/octet-stream", urlDataManager, 
+        encode_data(data, buffer.bytesWritten(), "application/octet-stream", urlDataManager,
                     &jsonData);
         jsonTypeface[SKDEBUGCANVAS_ATTRIBUTE_DATA] = jsonData;
         sk_free(data);
         (*target)[SKDEBUGCANVAS_ATTRIBUTE_TYPEFACE] = jsonTypeface;
     }
 }
 
-static void apply_paint_shader(const SkPaint& paint, Json::Value* target, 
+static void apply_paint_shader(const SkPaint& paint, Json::Value* target,
                                UrlDataManager& urlDataManager) {
     SkFlattenable* shader = paint.getShader();
     if (shader != nullptr) {
         Json::Value jsonShader;
         flatten(shader, &jsonShader, urlDataManager);
         (*target)[SKDEBUGCANVAS_ATTRIBUTE_SHADER] = jsonShader;
     }
 }
 
-static void apply_paint_xfermode(const SkPaint& paint, Json::Value* target, 
+static void apply_paint_xfermode(const SkPaint& paint, Json::Value* target,
                                  UrlDataManager& urlDataManager) {
     SkFlattenable* xfermode = paint.getXfermode();
     if (xfermode != nullptr) {
         Json::Value jsonXfermode;
         flatten(xfermode, &jsonXfermode, urlDataManager);
         (*target)[SKDEBUGCANVAS_ATTRIBUTE_XFERMODE] = jsonXfermode;
     }
 }
 
 static void apply_paint_imagefilter(const SkPaint& paint, Json::Value* target,
                                     UrlDataManager& urlDataManager) {
     SkFlattenable* imageFilter = paint.getImageFilter();
     if (imageFilter != nullptr) {
         Json::Value jsonImageFilter;
         flatten(imageFilter, &jsonImageFilter, urlDataManager);
         (*target)[SKDEBUGCANVAS_ATTRIBUTE_IMAGEFILTER] = jsonImageFilter;
     }
 }
 
-static void apply_paint_colorfilter(const SkPaint& paint, Json::Value* target, 
+static void apply_paint_colorfilter(const SkPaint& paint, Json::Value* target,
                                     UrlDataManager& urlDataManager) {
     SkFlattenable* colorFilter = paint.getColorFilter();
     if (colorFilter != nullptr) {
         Json::Value jsonColorFilter;
         flatten(colorFilter, &jsonColorFilter, urlDataManager);
         (*target)[SKDEBUGCANVAS_ATTRIBUTE_COLORFILTER] = jsonColorFilter;
     }
 }
 
-static void apply_paint_looper(const SkPaint& paint, Json::Value* target, 
+static void apply_paint_looper(const SkPaint& paint, Json::Value* target,
                                UrlDataManager& urlDataManager) {
     SkFlattenable* looper = paint.getLooper();
     if (looper != nullptr) {
         Json::Value jsonLooper;
         flatten(looper, &jsonLooper, urlDataManager);
         (*target)[SKDEBUGCANVAS_ATTRIBUTE_LOOPER] = jsonLooper;
     }
 }
 
 Json::Value make_json_paint(const SkPaint& paint, UrlDataManager& urlDataManager) {
     Json::Value result(Json::objectValue);
     store_scalar(&result, SKDEBUGCANVAS_ATTRIBUTE_STROKEWIDTH, paint.getStrokeWidth(), 0.0f);
-    store_scalar(&result, SKDEBUGCANVAS_ATTRIBUTE_STROKEMITER, paint.getStrokeMiter(), 
+    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(), 
+    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, urlDataManager);
@@ skipping 14 matching lines @@
 static SkColor get_json_color(Json::Value color) {
     return SkColorSetARGB(color[0].asInt(), color[1].asInt(), color[2].asInt(), color[3].asInt());
 }
 
 static void extract_json_paint_color(Json::Value& jsonPaint, SkPaint* target) {
     if (jsonPaint.isMember(SKDEBUGCANVAS_ATTRIBUTE_COLOR)) {
         target->setColor(get_json_color(jsonPaint[SKDEBUGCANVAS_ATTRIBUTE_COLOR]));
     }
 }
 
-static void extract_json_paint_shader(Json::Value& jsonPaint, UrlDataManager& urlDataManager, 
+static void extract_json_paint_shader(Json::Value& jsonPaint, UrlDataManager& urlDataManager,
                                       SkPaint* target) {
     if (jsonPaint.isMember(SKDEBUGCANVAS_ATTRIBUTE_SHADER)) {
         Json::Value jsonShader = jsonPaint[SKDEBUGCANVAS_ATTRIBUTE_SHADER];
         SkShader* shader = (SkShader*) load_flattenable(jsonShader, urlDataManager);
         if (shader != nullptr) {
             target->setShader(sk_ref_sp(shader));
         }
     }
 }
 
-static void extract_json_paint_patheffect(Json::Value& jsonPaint, UrlDataManager& urlDataManager, 
+static void extract_json_paint_patheffect(Json::Value& jsonPaint, UrlDataManager& urlDataManager,
                                           SkPaint* target) {
     if (jsonPaint.isMember(SKDEBUGCANVAS_ATTRIBUTE_PATHEFFECT)) {
         Json::Value jsonPathEffect = jsonPaint[SKDEBUGCANVAS_ATTRIBUTE_PATHEFFECT];
         sk_sp<SkPathEffect> pathEffect((SkPathEffect*)load_flattenable(jsonPathEffect,
                                                                        urlDataManager));
         if (pathEffect != nullptr) {
             target->setPathEffect(pathEffect);
         }
     }
 }
 
-static void extract_json_paint_maskfilter(Json::Value& jsonPaint, UrlDataManager& urlDataManager, 
+static void extract_json_paint_maskfilter(Json::Value& jsonPaint, UrlDataManager& urlDataManager,
                                           SkPaint* target) {
     if (jsonPaint.isMember(SKDEBUGCANVAS_ATTRIBUTE_MASKFILTER)) {
         Json::Value jsonMaskFilter = jsonPaint[SKDEBUGCANVAS_ATTRIBUTE_MASKFILTER];
         SkMaskFilter* maskFilter = (SkMaskFilter*) load_flattenable(jsonMaskFilter, urlDataManager);
         if (maskFilter != nullptr) {
             target->setMaskFilter(maskFilter);
             maskFilter->unref();
         }
     }
 }
 
-static void extract_json_paint_colorfilter(Json::Value& jsonPaint, UrlDataManager& urlDataManager, 
+static void extract_json_paint_colorfilter(Json::Value& jsonPaint, UrlDataManager& urlDataManager,
                                            SkPaint* target) {
     if (jsonPaint.isMember(SKDEBUGCANVAS_ATTRIBUTE_COLORFILTER)) {
         Json::Value jsonColorFilter = jsonPaint[SKDEBUGCANVAS_ATTRIBUTE_COLORFILTER];
         sk_sp<SkColorFilter> colorFilter((SkColorFilter*)load_flattenable(jsonColorFilter,
                                                                           urlDataManager));
         if (colorFilter != nullptr) {
             target->setColorFilter(colorFilter);
         }
     }
 }
 
-static void extract_json_paint_xfermode(Json::Value& jsonPaint, UrlDataManager& urlDataManager, 
+static void extract_json_paint_xfermode(Json::Value& jsonPaint, UrlDataManager& urlDataManager,
                                         SkPaint* target) {
     if (jsonPaint.isMember(SKDEBUGCANVAS_ATTRIBUTE_XFERMODE)) {
         Json::Value jsonXfermode = jsonPaint[SKDEBUGCANVAS_ATTRIBUTE_XFERMODE];
         SkXfermode* xfermode = (SkXfermode*) load_flattenable(jsonXfermode, urlDataManager);
         if (xfermode != nullptr) {
             target->setXfermode(xfermode);
             xfermode->unref();
         }
     }
 }
 
-static void extract_json_paint_looper(Json::Value& jsonPaint, UrlDataManager& urlDataManager, 
+static void extract_json_paint_looper(Json::Value& jsonPaint, UrlDataManager& urlDataManager,
                                       SkPaint* target) {
     if (jsonPaint.isMember(SKDEBUGCANVAS_ATTRIBUTE_LOOPER)) {
         Json::Value jsonLooper = jsonPaint[SKDEBUGCANVAS_ATTRIBUTE_LOOPER];
         sk_sp<SkDrawLooper> looper((SkDrawLooper*) load_flattenable(jsonLooper, urlDataManager));
         if (looper != nullptr) {
             target->setLooper(std::move(looper));
         }
     }
 }
 
-static void extract_json_paint_imagefilter(Json::Value& jsonPaint, UrlDataManager& urlDataManager, 
+static void extract_json_paint_imagefilter(Json::Value& jsonPaint, UrlDataManager& urlDataManager,
                                            SkPaint* target) {
     if (jsonPaint.isMember(SKDEBUGCANVAS_ATTRIBUTE_IMAGEFILTER)) {
         Json::Value jsonImageFilter = jsonPaint[SKDEBUGCANVAS_ATTRIBUTE_IMAGEFILTER];
-        SkImageFilter* imageFilter = (SkImageFilter*) load_flattenable(jsonImageFilter, 
+        SkImageFilter* imageFilter = (SkImageFilter*) load_flattenable(jsonImageFilter,
                                                                        urlDataManager);
         if (imageFilter != nullptr) {
             target->setImageFilter(imageFilter);
             imageFilter->unref();
         }
     }
 }
 
-static void extract_json_paint_typeface(Json::Value& jsonPaint, UrlDataManager& urlDataManager, 
+static void extract_json_paint_typeface(Json::Value& jsonPaint, UrlDataManager& urlDataManager,
                                         SkPaint* target) {
     if (jsonPaint.isMember(SKDEBUGCANVAS_ATTRIBUTE_TYPEFACE)) {
         Json::Value jsonTypeface = jsonPaint[SKDEBUGCANVAS_ATTRIBUTE_TYPEFACE];
         Json::Value jsonData = jsonTypeface[SKDEBUGCANVAS_ATTRIBUTE_DATA];
         const void* data;
         Json::ArrayIndex length = decode_data(jsonData, urlDataManager, &data);
         SkMemoryStream buffer(data, length);
         SkTypeface* typeface = SkTypeface::Deserialize(&buffer);
         target->setTypeface(typeface);
     }
@@ skipping 11 matching lines @@
         else if (!strcmp(style, SKDEBUGCANVAS_STYLE_STROKEANDFILL)) {
             target->setStyle(SkPaint::kStrokeAndFill_Style);
         }
     }
 }
 
 static void extract_json_paint_strokewidth(Json::Value& jsonPaint, SkPaint* target) {
     if (jsonPaint.isMember(SKDEBUGCANVAS_ATTRIBUTE_STROKEWIDTH)) {
         float strokeWidth = jsonPaint[SKDEBUGCANVAS_ATTRIBUTE_STROKEWIDTH].asFloat();
         target->setStrokeWidth(strokeWidth);
-    }    
+    }
 }
 
 static void extract_json_paint_strokemiter(Json::Value& jsonPaint, SkPaint* target) {
     if (jsonPaint.isMember(SKDEBUGCANVAS_ATTRIBUTE_STROKEMITER)) {
         float strokeMiter = jsonPaint[SKDEBUGCANVAS_ATTRIBUTE_STROKEMITER].asFloat();
         target->setStrokeMiter(strokeMiter);
-    }    
+    }
 }
 
 static void extract_json_paint_strokejoin(Json::Value& jsonPaint, SkPaint* target) {
     if (jsonPaint.isMember(SKDEBUGCANVAS_ATTRIBUTE_STROKEJOIN)) {
         const char* join = jsonPaint[SKDEBUGCANVAS_ATTRIBUTE_STROKEJOIN].asCString();
         if (!strcmp(join, SKDEBUGCANVAS_MITER_JOIN)) {
             target->setStrokeJoin(SkPaint::kMiter_Join);
         }
         else if (!strcmp(join, SKDEBUGCANVAS_ROUND_JOIN)) {
             target->setStrokeJoin(SkPaint::kRound_Join);
@@ skipping 140 matching lines @@
     }
 }
 
 static void extract_json_paint_textskewx(Json::Value& jsonPaint, SkPaint* target) {
     if (jsonPaint.isMember(SKDEBUGCANVAS_ATTRIBUTE_TEXTSKEWX)) {
         float textSkewX = jsonPaint[SKDEBUGCANVAS_ATTRIBUTE_TEXTSKEWX].asFloat();
         target->setTextSkewX(textSkewX);
     }
 }
 
-static void extract_json_paint(Json::Value& paint, UrlDataManager& urlDataManager, 
+static void extract_json_paint(Json::Value& paint, UrlDataManager& urlDataManager,
                                SkPaint* result) {
     extract_json_paint_color(paint, result);
     extract_json_paint_shader(paint, urlDataManager, result);
     extract_json_paint_patheffect(paint, urlDataManager, result);
     extract_json_paint_maskfilter(paint, urlDataManager, result);
     extract_json_paint_colorfilter(paint, urlDataManager, result);
     extract_json_paint_xfermode(paint, urlDataManager, result);
     extract_json_paint_looper(paint, urlDataManager, result);
     extract_json_paint_imagefilter(paint, urlDataManager, result);
     extract_json_paint_typeface(paint, urlDataManager, result);
@@ skipping 16 matching lines @@
 static void extract_json_rect(Json::Value& rect, SkRect* result) {
     result->set(rect[0].asFloat(), rect[1].asFloat(), rect[2].asFloat(), rect[3].asFloat());
 }
 
 static void extract_json_irect(Json::Value& rect, SkIRect* result) {
     result->set(rect[0].asInt(), rect[1].asInt(), rect[2].asInt(), rect[3].asInt());
 }
 
 static void extract_json_rrect(Json::Value& rrect, SkRRect* result) {
     SkVector radii[4] = {
-                            { rrect[1][0].asFloat(), rrect[1][1].asFloat() }, 
-                            { rrect[2][0].asFloat(), rrect[2][1].asFloat() }, 
-                            { rrect[3][0].asFloat(), rrect[3][1].asFloat() }, 
+                            { rrect[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()), 
+    result->setRectRadii(SkRect::MakeLTRB(rrect[0][0].asFloat(), rrect[0][1].asFloat(),
+                                          rrect[0][2].asFloat(), rrect[0][3].asFloat()),
                                           radii);
 }
 
 static void extract_json_matrix(Json::Value& matrix, SkMatrix* result) {
-    SkScalar values[] = { 
+    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() 
+        matrix[2][0].asFloat(), matrix[2][1].asFloat(), matrix[2][2].asFloat()
     };
     result->set9(values);
 }
 
 static void extract_json_path(Json::Value& path, SkPath* result) {
     const char* fillType = path[SKDEBUGCANVAS_ATTRIBUTE_FILLTYPE].asCString();
     if (!strcmp(fillType, SKDEBUGCANVAS_FILLTYPE_WINDING)) {
         result->setFillType(SkPath::kWinding_FillType);
     }
     else if (!strcmp(fillType, SKDEBUGCANVAS_FILLTYPE_EVENODD)) {
@@ skipping 110 matching lines @@
 }
 
 Json::Value SkClipPathCommand::toJSON(UrlDataManager& urlDataManager) const {
     Json::Value result = INHERITED::toJSON(urlDataManager);
     result[SKDEBUGCANVAS_ATTRIBUTE_PATH] = make_json_path(fPath);
     result[SKDEBUGCANVAS_ATTRIBUTE_REGIONOP] = make_json_regionop(fOp);
     result[SKDEBUGCANVAS_ATTRIBUTE_ANTIALIAS] = fDoAA;
     return result;
 }
 
-SkClipPathCommand* SkClipPathCommand::fromJSON(Json::Value& command, 
+SkClipPathCommand* SkClipPathCommand::fromJSON(Json::Value& command,
                                                UrlDataManager& urlDataManager) {
     SkPath path;
     extract_json_path(command[SKDEBUGCANVAS_ATTRIBUTE_PATH], &path);
-    return new SkClipPathCommand(path, get_json_regionop(command[SKDEBUGCANVAS_ATTRIBUTE_REGIONOP]), 
+    return new SkClipPathCommand(path, get_json_regionop(command[SKDEBUGCANVAS_ATTRIBUTE_REGIONOP]),
                                  command[SKDEBUGCANVAS_ATTRIBUTE_ANTIALIAS].asBool());
 }
 
 SkClipRegionCommand::SkClipRegionCommand(const SkRegion& region, SkRegion::Op op)
     : INHERITED(kClipRegion_OpType) {
     fRegion = region;
     fOp = op;
 
     fInfo.push(SkObjectParser::RegionToString(region));
     fInfo.push(SkObjectParser::RegionOpToString(op));
 }
 
 void SkClipRegionCommand::execute(SkCanvas* canvas) const {
     canvas->clipRegion(fRegion, fOp);
 }
 
 Json::Value SkClipRegionCommand::toJSON(UrlDataManager& urlDataManager) const {
     Json::Value result = INHERITED::toJSON(urlDataManager);
     result[SKDEBUGCANVAS_ATTRIBUTE_REGION] = make_json_region(fRegion);
     result[SKDEBUGCANVAS_ATTRIBUTE_REGIONOP] = make_json_regionop(fOp);
     return result;
 }
 
-SkClipRegionCommand* SkClipRegionCommand::fromJSON(Json::Value& command, 
+SkClipRegionCommand* SkClipRegionCommand::fromJSON(Json::Value& command,
                                                    UrlDataManager& urlDataManager) {
     SkASSERT(false);
     return nullptr;
 }
 
 SkClipRectCommand::SkClipRectCommand(const SkRect& rect, SkRegion::Op op, bool doAA)
     : INHERITED(kClipRect_OpType) {
     fRect = rect;
     fOp = op;
     fDoAA = doAA;
 
     fInfo.push(SkObjectParser::RectToString(rect));
     fInfo.push(SkObjectParser::RegionOpToString(op));
     fInfo.push(SkObjectParser::BoolToString(doAA));
 }
 
 void SkClipRectCommand::execute(SkCanvas* canvas) const {
     canvas->clipRect(fRect, fOp, fDoAA);
 }
 
 Json::Value SkClipRectCommand::toJSON(UrlDataManager& urlDataManager) const {
     Json::Value result = INHERITED::toJSON(urlDataManager);
     result[SKDEBUGCANVAS_ATTRIBUTE_COORDS] = make_json_rect(fRect);
     result[SKDEBUGCANVAS_ATTRIBUTE_REGIONOP] = make_json_regionop(fOp);
     result[SKDEBUGCANVAS_ATTRIBUTE_ANTIALIAS] = Json::Value(fDoAA);
     return result;
 }
 
-SkClipRectCommand* SkClipRectCommand::fromJSON(Json::Value& command, 
+SkClipRectCommand* SkClipRectCommand::fromJSON(Json::Value& command,
                                                UrlDataManager& urlDataManager) {
     SkRect rect;
     extract_json_rect(command[SKDEBUGCANVAS_ATTRIBUTE_COORDS], &rect);
-    return new SkClipRectCommand(rect, get_json_regionop(command[SKDEBUGCANVAS_ATTRIBUTE_REGIONOP]), 
+    return new SkClipRectCommand(rect, get_json_regionop(command[SKDEBUGCANVAS_ATTRIBUTE_REGIONOP]),
                                  command[SKDEBUGCANVAS_ATTRIBUTE_ANTIALIAS].asBool());
 }
 
 SkClipRRectCommand::SkClipRRectCommand(const SkRRect& rrect, SkRegion::Op op, bool doAA)
     : INHERITED(kClipRRect_OpType) {
     fRRect = rrect;
     fOp = op;
     fDoAA = doAA;
 
     fInfo.push(SkObjectParser::RRectToString(rrect));
@@ skipping 11 matching lines @@
 }
 
 Json::Value SkClipRRectCommand::toJSON(UrlDataManager& urlDataManager) const {
     Json::Value result = INHERITED::toJSON(urlDataManager);
     result[SKDEBUGCANVAS_ATTRIBUTE_COORDS] = make_json_rrect(fRRect);
     result[SKDEBUGCANVAS_ATTRIBUTE_REGIONOP] = make_json_regionop(fOp);
     result[SKDEBUGCANVAS_ATTRIBUTE_ANTIALIAS] = Json::Value(fDoAA);
     return result;
 }
 
-SkClipRRectCommand* SkClipRRectCommand::fromJSON(Json::Value& command, 
+SkClipRRectCommand* SkClipRRectCommand::fromJSON(Json::Value& command,
                                                  UrlDataManager& urlDataManager) {
     SkRRect rrect;
     extract_json_rrect(command[SKDEBUGCANVAS_ATTRIBUTE_COORDS], &rrect);
-    return new SkClipRRectCommand(rrect, 
-                                  get_json_regionop(command[SKDEBUGCANVAS_ATTRIBUTE_REGIONOP]), 
+    return new SkClipRRectCommand(rrect,
+                                  get_json_regionop(command[SKDEBUGCANVAS_ATTRIBUTE_REGIONOP]),
                                   command[SKDEBUGCANVAS_ATTRIBUTE_ANTIALIAS].asBool());
 }
 
 SkConcatCommand::SkConcatCommand(const SkMatrix& matrix)
     : INHERITED(kConcat_OpType) {
     fMatrix = matrix;
 
     fInfo.push(SkObjectParser::MatrixToString(matrix));
 }
 
@@ skipping 50 matching lines @@
         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, urlDataManager);
         }
     }
     return result;
 }
 
-SkDrawBitmapCommand* SkDrawBitmapCommand::fromJSON(Json::Value& command, 
+SkDrawBitmapCommand* SkDrawBitmapCommand::fromJSON(Json::Value& command,
                                                    UrlDataManager& urlDataManager) {
     SkBitmap* bitmap = load_bitmap(command[SKDEBUGCANVAS_ATTRIBUTE_BITMAP], urlDataManager);
     if (bitmap == nullptr) {
         return nullptr;
     }
     Json::Value point = command[SKDEBUGCANVAS_ATTRIBUTE_COORDS];
     SkPaint* paintPtr;
     SkPaint paint;
     if (command.isMember(SKDEBUGCANVAS_ATTRIBUTE_PAINT)) {
         extract_json_paint(command[SKDEBUGCANVAS_ATTRIBUTE_PAINT], urlDataManager, &paint);
         paintPtr = &paint;
     }
     else {
         paintPtr = nullptr;
     }
-    SkDrawBitmapCommand* result = new SkDrawBitmapCommand(*bitmap, point[0].asFloat(), 
+    SkDrawBitmapCommand* result = new SkDrawBitmapCommand(*bitmap, point[0].asFloat(),
                                                           point[1].asFloat(), paintPtr);
     delete bitmap;
     return result;
 }
 
 SkDrawBitmapNineCommand::SkDrawBitmapNineCommand(const SkBitmap& bitmap, const SkIRect& center,
                                                  const SkRect& dst, const SkPaint* paint)
     : INHERITED(kDrawBitmapNine_OpType) {
     fBitmap = bitmap;
     fCenter = center;
@@ skipping 30 matching lines @@
         result[SKDEBUGCANVAS_ATTRIBUTE_BITMAP] = encoded;
         result[SKDEBUGCANVAS_ATTRIBUTE_CENTER] = MakeJsonIRect(fCenter);
         result[SKDEBUGCANVAS_ATTRIBUTE_DST] = make_json_rect(fDst);
         if (fPaintPtr != nullptr) {
             result[SKDEBUGCANVAS_ATTRIBUTE_PAINT] = make_json_paint(*fPaintPtr, urlDataManager);
         }
     }
     return result;
 }
 
-SkDrawBitmapNineCommand* SkDrawBitmapNineCommand::fromJSON(Json::Value& command, 
+SkDrawBitmapNineCommand* SkDrawBitmapNineCommand::fromJSON(Json::Value& command,
                                                            UrlDataManager& urlDataManager) {
     SkBitmap* bitmap = load_bitmap(command[SKDEBUGCANVAS_ATTRIBUTE_BITMAP], urlDataManager);
     if (bitmap == nullptr) {
         return nullptr;
     }
     SkIRect center;
     extract_json_irect(command[SKDEBUGCANVAS_ATTRIBUTE_CENTER], &center);
     SkRect dst;
     extract_json_rect(command[SKDEBUGCANVAS_ATTRIBUTE_DST], &dst);
     SkPaint* paintPtr;
@@ skipping 62 matching lines @@
         if (fPaintPtr != nullptr) {
             result[SKDEBUGCANVAS_ATTRIBUTE_PAINT] = make_json_paint(*fPaintPtr, urlDataManager);
         }
         if (fConstraint == SkCanvas::kStrict_SrcRectConstraint) {
             result[SKDEBUGCANVAS_ATTRIBUTE_STRICT] = Json::Value(true);
         }
     }
     return result;
 }
 
-SkDrawBitmapRectCommand* SkDrawBitmapRectCommand::fromJSON(Json::Value& command, 
+SkDrawBitmapRectCommand* SkDrawBitmapRectCommand::fromJSON(Json::Value& command,
                                                            UrlDataManager& urlDataManager) {
     SkBitmap* bitmap = load_bitmap(command[SKDEBUGCANVAS_ATTRIBUTE_BITMAP], urlDataManager);
     if (bitmap == nullptr) {
         return nullptr;
     }
     SkRect dst;
     extract_json_rect(command[SKDEBUGCANVAS_ATTRIBUTE_DST], &dst);
     SkPaint* paintPtr;
     SkPaint paint;
     if (command.isMember(SKDEBUGCANVAS_ATTRIBUTE_PAINT)) {
         extract_json_paint(command[SKDEBUGCANVAS_ATTRIBUTE_PAINT], urlDataManager, &paint);
         paintPtr = &paint;
     }
     else {
         paintPtr = nullptr;
     }
     SkCanvas::SrcRectConstraint constraint;
-    if (command.isMember(SKDEBUGCANVAS_ATTRIBUTE_STRICT) && 
+    if (command.isMember(SKDEBUGCANVAS_ATTRIBUTE_STRICT) &&
         command[SKDEBUGCANVAS_ATTRIBUTE_STRICT].asBool()) {
         constraint = SkCanvas::kStrict_SrcRectConstraint;
     }
     else {
         constraint = SkCanvas::kFast_SrcRectConstraint;
     }
     SkRect* srcPtr;
     SkRect src;
     if (command.isMember(SKDEBUGCANVAS_ATTRIBUTE_SRC)) {
         extract_json_rect(command[SKDEBUGCANVAS_ATTRIBUTE_SRC], &src);
@@ skipping 46 matching lines @@
     if (flatten(*fImage, &encoded, urlDataManager)) {
         result[SKDEBUGCANVAS_ATTRIBUTE_IMAGE] = encoded;
         result[SKDEBUGCANVAS_ATTRIBUTE_COORDS] = make_json_point(fLeft, fTop);
         if (fPaint.isValid()) {
             result[SKDEBUGCANVAS_ATTRIBUTE_PAINT] = make_json_paint(*fPaint.get(), urlDataManager);
         }
     }
     return result;
 }
 
-SkDrawImageCommand* SkDrawImageCommand::fromJSON(Json::Value& command, 
+SkDrawImageCommand* SkDrawImageCommand::fromJSON(Json::Value& command,
                                                  UrlDataManager& urlDataManager) {
     sk_sp<SkImage> image = load_image(command[SKDEBUGCANVAS_ATTRIBUTE_IMAGE], urlDataManager);
     if (image == nullptr) {
         return nullptr;
     }
     Json::Value point = command[SKDEBUGCANVAS_ATTRIBUTE_COORDS];
     SkPaint* paintPtr;
     SkPaint paint;
     if (command.isMember(SKDEBUGCANVAS_ATTRIBUTE_PAINT)) {
         extract_json_paint(command[SKDEBUGCANVAS_ATTRIBUTE_PAINT], urlDataManager, &paint);
@@ skipping 28 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(), 
+    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);
@@ skipping 12 matching lines @@
         if (fPaint.isValid()) {
             result[SKDEBUGCANVAS_ATTRIBUTE_PAINT] = make_json_paint(*fPaint.get(), urlDataManager);
         }
         if (fConstraint == SkCanvas::kStrict_SrcRectConstraint) {
             result[SKDEBUGCANVAS_ATTRIBUTE_STRICT] = Json::Value(true);
         }
     }
     return result;
 }
 
-SkDrawImageRectCommand* SkDrawImageRectCommand::fromJSON(Json::Value& command, 
+SkDrawImageRectCommand* SkDrawImageRectCommand::fromJSON(Json::Value& command,
                                                          UrlDataManager& urlDataManager) {
     sk_sp<SkImage> image = load_image(command[SKDEBUGCANVAS_ATTRIBUTE_IMAGE], urlDataManager);
     if (image == nullptr) {
         return nullptr;
     }
     SkRect dst;
     extract_json_rect(command[SKDEBUGCANVAS_ATTRIBUTE_DST], &dst);
     SkPaint* paintPtr;
     SkPaint paint;
     if (command.isMember(SKDEBUGCANVAS_ATTRIBUTE_PAINT)) {
         extract_json_paint(command[SKDEBUGCANVAS_ATTRIBUTE_PAINT], urlDataManager, &paint);
         paintPtr = &paint;
     }
     else {
         paintPtr = nullptr;
     }
     SkCanvas::SrcRectConstraint constraint;
-    if (command.isMember(SKDEBUGCANVAS_ATTRIBUTE_STRICT) && 
+    if (command.isMember(SKDEBUGCANVAS_ATTRIBUTE_STRICT) &&
         command[SKDEBUGCANVAS_ATTRIBUTE_STRICT].asBool()) {
         constraint = SkCanvas::kStrict_SrcRectConstraint;
     }
     else {
         constraint = SkCanvas::kFast_SrcRectConstraint;
     }
     SkRect* srcPtr;
     SkRect src;
     if (command.isMember(SKDEBUGCANVAS_ATTRIBUTE_SRC)) {
         extract_json_rect(command[SKDEBUGCANVAS_ATTRIBUTE_SRC], &src);
@@ skipping 36 matching lines @@
     return true;
 }
 
 Json::Value SkDrawOvalCommand::toJSON(UrlDataManager& urlDataManager) const {
     Json::Value result = INHERITED::toJSON(urlDataManager);
     result[SKDEBUGCANVAS_ATTRIBUTE_COORDS] = make_json_rect(fOval);
     result[SKDEBUGCANVAS_ATTRIBUTE_PAINT] = make_json_paint(fPaint, urlDataManager);
     return result;
 }
 
-SkDrawOvalCommand* SkDrawOvalCommand::fromJSON(Json::Value& command, 
+SkDrawOvalCommand* SkDrawOvalCommand::fromJSON(Json::Value& command,
                                                UrlDataManager& urlDataManager) {
     SkRect coords;
     extract_json_rect(command[SKDEBUGCANVAS_ATTRIBUTE_COORDS], &coords);
     SkPaint paint;
     extract_json_paint(command[SKDEBUGCANVAS_ATTRIBUTE_PAINT], urlDataManager, &paint);
     return new SkDrawOvalCommand(coords, paint);
 }
 
 SkDrawPaintCommand::SkDrawPaintCommand(const SkPaint& paint)
     : INHERITED(kDrawPaint_OpType) {
@@ skipping 11 matching lines @@
     canvas->drawPaint(fPaint);
     return true;
 }
 
 Json::Value SkDrawPaintCommand::toJSON(UrlDataManager& urlDataManager) const {
     Json::Value result = INHERITED::toJSON(urlDataManager);
     result[SKDEBUGCANVAS_ATTRIBUTE_PAINT] = make_json_paint(fPaint, urlDataManager);
     return result;
 }
 
-SkDrawPaintCommand* SkDrawPaintCommand::fromJSON(Json::Value& command, 
+SkDrawPaintCommand* SkDrawPaintCommand::fromJSON(Json::Value& command,
                                                  UrlDataManager& urlDataManager) {
     SkPaint paint;
     extract_json_paint(command[SKDEBUGCANVAS_ATTRIBUTE_PAINT], urlDataManager, &paint);
     return new SkDrawPaintCommand(paint);
 }
 
 SkDrawPathCommand::SkDrawPathCommand(const SkPath& path, const SkPaint& paint)
     : INHERITED(kDrawPath_OpType) {
     fPath = path;
     fPaint = paint;
@@ skipping 11 matching lines @@
     return true;
 }
 
 Json::Value SkDrawPathCommand::toJSON(UrlDataManager& urlDataManager) const {
     Json::Value result = INHERITED::toJSON(urlDataManager);
     result[SKDEBUGCANVAS_ATTRIBUTE_PATH] = make_json_path(fPath);
     result[SKDEBUGCANVAS_ATTRIBUTE_PAINT] = make_json_paint(fPaint, urlDataManager);
     return result;
 }
 
-SkDrawPathCommand* SkDrawPathCommand::fromJSON(Json::Value& command, 
+SkDrawPathCommand* SkDrawPathCommand::fromJSON(Json::Value& command,
                                                UrlDataManager& urlDataManager) {
     SkPath path;
     extract_json_path(command[SKDEBUGCANVAS_ATTRIBUTE_PATH], &path);
     SkPaint paint;
     extract_json_paint(command[SKDEBUGCANVAS_ATTRIBUTE_PAINT], urlDataManager, &paint);
     return new SkDrawPathCommand(path, paint);
 }
 
 SkBeginDrawPictureCommand::SkBeginDrawPictureCommand(const SkPicture* picture,
                                                      const SkMatrix* matrix,
@@ skipping 106 matching lines @@
     result[SKDEBUGCANVAS_ATTRIBUTE_MODE] = make_json_pointmode(fMode);
     Json::Value points(Json::arrayValue);
     for (size_t i = 0; i < fCount; i++) {
         points.append(make_json_point(fPts[i]));
     }
     result[SKDEBUGCANVAS_ATTRIBUTE_POINTS] = points;
     result[SKDEBUGCANVAS_ATTRIBUTE_PAINT] = make_json_paint(fPaint, urlDataManager);
     return result;
 }
 
-SkDrawPointsCommand* SkDrawPointsCommand::fromJSON(Json::Value& command, 
+SkDrawPointsCommand* SkDrawPointsCommand::fromJSON(Json::Value& command,
                                                    UrlDataManager& urlDataManager) {
     SkCanvas::PointMode mode;
     const char* jsonMode = command[SKDEBUGCANVAS_ATTRIBUTE_MODE].asCString();
     if (!strcmp(jsonMode, SKDEBUGCANVAS_POINTMODE_POINTS)) {
         mode = SkCanvas::kPoints_PointMode;
     }
     else if (!strcmp(jsonMode, SKDEBUGCANVAS_POINTMODE_LINES)) {
         mode = SkCanvas::kLines_PointMode;
     }
     else if (!strcmp(jsonMode, SKDEBUGCANVAS_POINTMODE_POLYGON)) {
@@ skipping 35 matching lines @@
     fInfo.push(SkObjectParser::PointsToString(pos, 1));
     fInfo.push(SkObjectParser::PaintToString(paint));
 }
 
 void SkDrawPosTextCommand::execute(SkCanvas* canvas) const {
     canvas->drawPosText(fText, fByteLength, fPos, fPaint);
 }
 
 Json::Value SkDrawPosTextCommand::toJSON(UrlDataManager& urlDataManager) const {
     Json::Value result = INHERITED::toJSON(urlDataManager);
-    result[SKDEBUGCANVAS_ATTRIBUTE_TEXT] = Json::Value((const char*) fText, 
+    result[SKDEBUGCANVAS_ATTRIBUTE_TEXT] = Json::Value((const char*) fText,
                                                        ((const char*) fText) + fByteLength);
     Json::Value coords(Json::arrayValue);
     size_t numCoords = fPaint.textToGlyphs(fText, fByteLength, nullptr);
     for (size_t i = 0; i < numCoords; i++) {
         coords.append(make_json_point(fPos[i]));
     }
     result[SKDEBUGCANVAS_ATTRIBUTE_COORDS] = coords;
     result[SKDEBUGCANVAS_ATTRIBUTE_PAINT] = make_json_paint(fPaint, urlDataManager);
     return result;
 }
 
-SkDrawPosTextCommand* SkDrawPosTextCommand::fromJSON(Json::Value& command, 
+SkDrawPosTextCommand* SkDrawPosTextCommand::fromJSON(Json::Value& command,
                                                      UrlDataManager& urlDataManager) {
     const char* text = command[SKDEBUGCANVAS_ATTRIBUTE_TEXT].asCString();
     SkPaint paint;
     extract_json_paint(command[SKDEBUGCANVAS_ATTRIBUTE_PAINT], urlDataManager, &paint);
     Json::Value coords = command[SKDEBUGCANVAS_ATTRIBUTE_COORDS];
     int count = (int) coords.size();
     SkPoint* points = (SkPoint*) sk_malloc_throw(count * sizeof(SkPoint));
     for (int i = 0; i < count; i++) {
         points[i] = SkPoint::Make(coords[i][0].asFloat(), coords[i][1].asFloat());
     }
@@ skipping 154 matching lines @@
         runs.append(run);
         iter.next();
     }
     result[SKDEBUGCANVAS_ATTRIBUTE_RUNS] = runs;
     result[SKDEBUGCANVAS_ATTRIBUTE_X] = Json::Value(fXPos);
     result[SKDEBUGCANVAS_ATTRIBUTE_Y] = Json::Value(fYPos);
     result[SKDEBUGCANVAS_ATTRIBUTE_PAINT] = make_json_paint(fPaint, urlDataManager);
     return result;
 }
 
-SkDrawTextBlobCommand* SkDrawTextBlobCommand::fromJSON(Json::Value& command, 
+SkDrawTextBlobCommand* SkDrawTextBlobCommand::fromJSON(Json::Value& command,
                                                        UrlDataManager& urlDataManager) {
     SkTextBlobBuilder builder;
     Json::Value runs = command[SKDEBUGCANVAS_ATTRIBUTE_RUNS];
     for (Json::ArrayIndex i = 0 ; i < runs.size(); i++) {
         Json::Value run = runs[i];
         SkPaint font;
         font.setTextEncoding(SkPaint::kGlyphID_TextEncoding);
         extract_json_paint(run[SKDEBUGCANVAS_ATTRIBUTE_FONT], urlDataManager, &font);
         Json::Value glyphs = run[SKDEBUGCANVAS_ATTRIBUTE_GLYPHS];
         int count = glyphs.size();
@@ skipping 83 matching lines @@
         result[SKDEBUGCANVAS_ATTRIBUTE_TEXTURECOORDS] = texCoords;
     }
     if (fXfermode.get() != nullptr) {
         Json::Value jsonXfermode;
         flatten(fXfermode, &jsonXfermode, urlDataManager);
         result[SKDEBUGCANVAS_ATTRIBUTE_XFERMODE] = jsonXfermode;
     }
     return result;
 }
 
-SkDrawPatchCommand* SkDrawPatchCommand::fromJSON(Json::Value& command, 
+SkDrawPatchCommand* SkDrawPatchCommand::fromJSON(Json::Value& command,
                                                  UrlDataManager& urlDataManager) {
     Json::Value jsonCubics = command[SKDEBUGCANVAS_ATTRIBUTE_CUBICS];
     SkPoint cubics[12];
     for (int i = 0; i < 12; i++) {
         cubics[i] = get_json_point(jsonCubics[i]);
     }
     SkColor* colorsPtr;
     SkColor colors[4];
     if (command.isMember(SKDEBUGCANVAS_ATTRIBUTE_COLORS)) {
         Json::Value jsonColors = command[SKDEBUGCANVAS_ATTRIBUTE_COLORS];
@@ skipping 40 matching lines @@
     canvas->drawRect(fRect, fPaint);
 }
 
 Json::Value SkDrawRectCommand::toJSON(UrlDataManager& urlDataManager) const {
     Json::Value result = INHERITED::toJSON(urlDataManager);
     result[SKDEBUGCANVAS_ATTRIBUTE_COORDS] = make_json_rect(fRect);
     result[SKDEBUGCANVAS_ATTRIBUTE_PAINT] = make_json_paint(fPaint, urlDataManager);
     return result;
 }
 
-SkDrawRectCommand* SkDrawRectCommand::fromJSON(Json::Value& command, 
+SkDrawRectCommand* SkDrawRectCommand::fromJSON(Json::Value& command,
                                                UrlDataManager& urlDataManager) {
     SkRect coords;
     extract_json_rect(command[SKDEBUGCANVAS_ATTRIBUTE_COORDS], &coords);
     SkPaint paint;
     extract_json_paint(command[SKDEBUGCANVAS_ATTRIBUTE_PAINT], urlDataManager, &paint);
     return new SkDrawRectCommand(coords, paint);
 }
 
 SkDrawRRectCommand::SkDrawRRectCommand(const SkRRect& rrect, const SkPaint& paint)
     : INHERITED(kDrawRRect_OpType) {
@@ skipping 13 matching lines @@
     return true;
 }
 
 Json::Value SkDrawRRectCommand::toJSON(UrlDataManager& urlDataManager) const {
     Json::Value result = INHERITED::toJSON(urlDataManager);
     result[SKDEBUGCANVAS_ATTRIBUTE_COORDS] = make_json_rrect(fRRect);
     result[SKDEBUGCANVAS_ATTRIBUTE_PAINT] = make_json_paint(fPaint, urlDataManager);
     return result;
 }
 
-SkDrawRRectCommand* SkDrawRRectCommand::fromJSON(Json::Value& command, 
+SkDrawRRectCommand* SkDrawRRectCommand::fromJSON(Json::Value& command,
                                                  UrlDataManager& urlDataManager) {
     SkRRect coords;
     extract_json_rrect(command[SKDEBUGCANVAS_ATTRIBUTE_COORDS], &coords);
     SkPaint paint;
     extract_json_paint(command[SKDEBUGCANVAS_ATTRIBUTE_PAINT], urlDataManager, &paint);
     return new SkDrawRRectCommand(coords, paint);
 }
 
 SkDrawDRRectCommand::SkDrawDRRectCommand(const SkRRect& outer,
                                          const SkRRect& inner,
@@ skipping 18 matching lines @@
 }
 
 Json::Value SkDrawDRRectCommand::toJSON(UrlDataManager& urlDataManager) const {
     Json::Value result = INHERITED::toJSON(urlDataManager);
     result[SKDEBUGCANVAS_ATTRIBUTE_OUTER] = make_json_rrect(fOuter);
     result[SKDEBUGCANVAS_ATTRIBUTE_INNER] = make_json_rrect(fInner);
     result[SKDEBUGCANVAS_ATTRIBUTE_PAINT] = make_json_paint(fPaint, urlDataManager);
     return result;
 }
 
-SkDrawDRRectCommand* SkDrawDRRectCommand::fromJSON(Json::Value& command, 
+SkDrawDRRectCommand* SkDrawDRRectCommand::fromJSON(Json::Value& command,
                                                    UrlDataManager& urlDataManager) {
     SkRRect outer;
     extract_json_rrect(command[SKDEBUGCANVAS_ATTRIBUTE_INNER], &outer);
     SkRRect inner;
     extract_json_rrect(command[SKDEBUGCANVAS_ATTRIBUTE_INNER], &inner);
     SkPaint paint;
     extract_json_paint(command[SKDEBUGCANVAS_ATTRIBUTE_PAINT], urlDataManager, &paint);
     return new SkDrawDRRectCommand(outer, inner, paint);
 }
 
@@ skipping 12 matching lines @@
     fInfo.push(SkObjectParser::ScalarToString(y, "SkScalar y: "));
     fInfo.push(SkObjectParser::PaintToString(paint));
 }
 
 void SkDrawTextCommand::execute(SkCanvas* canvas) const {
     canvas->drawText(fText, fByteLength, fX, fY, fPaint);
 }
 
 Json::Value SkDrawTextCommand::toJSON(UrlDataManager& urlDataManager) const {
     Json::Value result = INHERITED::toJSON(urlDataManager);
-    result[SKDEBUGCANVAS_ATTRIBUTE_TEXT] = Json::Value((const char*) fText, 
+    result[SKDEBUGCANVAS_ATTRIBUTE_TEXT] = Json::Value((const char*) fText,
                                                        ((const char*) fText) + fByteLength);
     Json::Value coords(Json::arrayValue);
     result[SKDEBUGCANVAS_ATTRIBUTE_COORDS] = make_json_point(fX, fY);
     result[SKDEBUGCANVAS_ATTRIBUTE_PAINT] = make_json_paint(fPaint, urlDataManager);
     return result;
 }
 
-SkDrawTextCommand* SkDrawTextCommand::fromJSON(Json::Value& command, 
+SkDrawTextCommand* SkDrawTextCommand::fromJSON(Json::Value& command,
                                                UrlDataManager& urlDataManager) {
     const char* text = command[SKDEBUGCANVAS_ATTRIBUTE_TEXT].asCString();
     SkPaint paint;
     extract_json_paint(command[SKDEBUGCANVAS_ATTRIBUTE_PAINT], urlDataManager, &paint);
     Json::Value coords = command[SKDEBUGCANVAS_ATTRIBUTE_COORDS];
-    return new SkDrawTextCommand(text, strlen(text), coords[0].asFloat(), coords[1].asFloat(), 
+    return new SkDrawTextCommand(text, strlen(text), coords[0].asFloat(), coords[1].asFloat(),
                                  paint);
 }
 
 SkDrawTextOnPathCommand::SkDrawTextOnPathCommand(const void* text, size_t byteLength,
                                                  const SkPath& path, const SkMatrix* matrix,
                                                  const SkPaint& paint)
     : INHERITED(kDrawTextOnPath_OpType) {
     fText = new char[byteLength];
     memcpy(fText, text, byteLength);
     fByteLength = byteLength;
@@ skipping 14 matching lines @@
 }
 
 void SkDrawTextOnPathCommand::execute(SkCanvas* canvas) const {
     canvas->drawTextOnPath(fText, fByteLength, fPath,
                            fMatrix.isIdentity() ? nullptr : &fMatrix,
                            fPaint);
 }
 
 Json::Value SkDrawTextOnPathCommand::toJSON(UrlDataManager& urlDataManager) const {
     Json::Value result = INHERITED::toJSON(urlDataManager);
-    result[SKDEBUGCANVAS_ATTRIBUTE_TEXT] = Json::Value((const char*) fText, 
+    result[SKDEBUGCANVAS_ATTRIBUTE_TEXT] = Json::Value((const char*) fText,
                                                        ((const char*) fText) + fByteLength);
     Json::Value coords(Json::arrayValue);
     result[SKDEBUGCANVAS_ATTRIBUTE_PATH] = make_json_path(fPath);
     if (!fMatrix.isIdentity()) {
         result[SKDEBUGCANVAS_ATTRIBUTE_MATRIX] = MakeJsonMatrix(fMatrix);
     }
     result[SKDEBUGCANVAS_ATTRIBUTE_PAINT] = make_json_paint(fPaint, urlDataManager);
     return result;
 }
 
-SkDrawTextOnPathCommand* SkDrawTextOnPathCommand::fromJSON(Json::Value& command, 
+SkDrawTextOnPathCommand* SkDrawTextOnPathCommand::fromJSON(Json::Value& command,
                                                            UrlDataManager& urlDataManager) {
     const char* text = command[SKDEBUGCANVAS_ATTRIBUTE_TEXT].asCString();
     SkPaint paint;
     extract_json_paint(command[SKDEBUGCANVAS_ATTRIBUTE_PAINT], urlDataManager, &paint);
     SkPath path;
     extract_json_path(command[SKDEBUGCANVAS_ATTRIBUTE_PATH], &path);
     SkMatrix* matrixPtr;
     SkMatrix matrix;
     if (command.isMember(SKDEBUGCANVAS_ATTRIBUTE_MATRIX)) {
         extract_json_matrix(command[SKDEBUGCANVAS_ATTRIBUTE_MATRIX], &matrix);
@@ skipping 138 matching lines @@
 void SkSaveLayerCommand::vizExecute(SkCanvas* canvas) const {
     canvas->save();
 }
 
 Json::Value SkSaveLayerCommand::toJSON(UrlDataManager& urlDataManager) const {
     Json::Value result = INHERITED::toJSON(urlDataManager);
     if (!fBounds.isEmpty()) {
         result[SKDEBUGCANVAS_ATTRIBUTE_BOUNDS] = make_json_rect(fBounds);
     }
     if (fPaintPtr != nullptr) {
-        result[SKDEBUGCANVAS_ATTRIBUTE_PAINT] = make_json_paint(*fPaintPtr, 
+        result[SKDEBUGCANVAS_ATTRIBUTE_PAINT] = make_json_paint(*fPaintPtr,
                                                                 urlDataManager);
     }
     if (fBackdrop != nullptr) {
         Json::Value jsonBackdrop;
         flatten(fBackdrop, &jsonBackdrop, urlDataManager);
         result[SKDEBUGCANVAS_ATTRIBUTE_BACKDROP] = jsonBackdrop;
     }
     if (fSaveLayerFlags != 0) {
         SkDebugf("unsupported: saveLayer flags\n");
         SkASSERT(false);
     }
     return result;
 }
 
-SkSaveLayerCommand* SkSaveLayerCommand::fromJSON(Json::Value& command, 
+SkSaveLayerCommand* SkSaveLayerCommand::fromJSON(Json::Value& command,
                                                  UrlDataManager& urlDataManager) {
     SkCanvas::SaveLayerRec rec;
     SkRect bounds;
     if (command.isMember(SKDEBUGCANVAS_ATTRIBUTE_BOUNDS)) {
         extract_json_rect(command[SKDEBUGCANVAS_ATTRIBUTE_BOUNDS], &bounds);
         rec.fBounds = &bounds;
     }
     SkPaint paint;
     if (command.isMember(SKDEBUGCANVAS_ATTRIBUTE_PAINT)) {
         extract_json_paint(command[SKDEBUGCANVAS_ATTRIBUTE_PAINT], urlDataManager, &paint);
@@ skipping 25 matching lines @@
     SkMatrix temp = SkMatrix::Concat(fUserMatrix, fMatrix);
     canvas->setMatrix(temp);
 }
 
 Json::Value SkSetMatrixCommand::toJSON(UrlDataManager& urlDataManager) const {
     Json::Value result = INHERITED::toJSON(urlDataManager);
     result[SKDEBUGCANVAS_ATTRIBUTE_MATRIX] = MakeJsonMatrix(fMatrix);
     return result;
 }
 
-SkSetMatrixCommand* SkSetMatrixCommand::fromJSON(Json::Value& command, 
+SkSetMatrixCommand* SkSetMatrixCommand::fromJSON(Json::Value& command,
                                                  UrlDataManager& urlDataManager) {
     SkMatrix matrix;
     extract_json_matrix(command[SKDEBUGCANVAS_ATTRIBUTE_MATRIX], &matrix);
     return new SkSetMatrixCommand(matrix);
 }