From d116561ddcca3f961b30cd9e485d81b654bc10ec Mon Sep 17 00:00:00 2001 From: caryclark Date: Wed, 10 Feb 2016 04:34:08 -0800 Subject: [PATCH] Revert of Moved Canvas->JSON and JSON->Canvas functionality into SkDebugCanvas. (patchset #3 id:40001 of https://codereview.chromium.org/1681643002/ ) Reason for revert: breaks various android builds, e.g. https://android-build.storage.googleapis.com/builds/git_master-skia-linux-bullhead-userdebug/2596406/acb02999d48ace628601452700d4b4f8dcd5ed71b426e6ecdb1c7f5bc5452f7b/logs/build_error.log?Signature=BkLEdMOdi0LelP0v939QECdTZzznSD2dLFIkPu52E7%2BPr5Oj1ktq5nNlxGZn%2F4ZhCKXAw2%2FNHxy27nNJ8lffcgXn7PhQpa82bP%2B8F%2Bbyo9j%2BT%2B3etmOdQFEejJSRsEv2RrVWtKsKYRX%2FuZinrF9yD37jUpSbKNZvmvIbKa4V4IQ%3D&GoogleAccessId=701025073339-mqn0q2nvir9iurm6q5d00tdv7blbgvjr%40developer.gserviceaccount.com&Expires=1455108483 external/skia/bench/../tools/debugger/SkDrawCommand.cpp:602:9: error: use of undeclared identifier 'free' free(data); Original issue's description: > Moved Canvas->JSON and JSON->Canvas functionality into SkDebugCanvas. > SkJSONCanvas and SkJSONRenderer will be deleted once the debug server > has been updated. > GOLD_TRYBOT_URL= https://gold.skia.org/search2?unt=true&query=source_type%3Dgm&master=false&issue=1681643002 > > Committed: https://skia.googlesource.com/skia/+/32fff1ba0c759d97ab78320b7ae46dd7696a4e6e > > Committed: https://skia.googlesource.com/skia/+/46cb6d6b82b0ab71033aef91419e8beae25bb8a4 TBR=jcgregorio@google.com,joshualitt@chromium.org,ethannicholas@google.com # Skipping CQ checks because original CL landed less than 1 days ago. NOPRESUBMIT=true NOTREECHECKS=true NOTRY=true Review URL: https://codereview.chromium.org/1683093002 --- gyp/SampleApp.gyp | 1 - gyp/debugger.gyp | 1 - tools/debugger/SkDrawCommand.cpp | 1839 ------------------------------------- tools/debugger/SkDrawCommand.h | 89 +- tools/debugger/SkObjectParser.cpp | 7 +- 5 files changed, 7 insertions(+), 1930 deletions(-) diff --git a/gyp/SampleApp.gyp b/gyp/SampleApp.gyp index c22eaa2..bb48aff 100644 --- a/gyp/SampleApp.gyp +++ b/gyp/SampleApp.gyp @@ -157,7 +157,6 @@ 'views.gyp:views', 'views_animated.gyp:views_animated', 'xml.gyp:xml', - 'jsoncpp.gyp:jsoncpp', ], 'msvs_settings': { 'VCLinkerTool': { diff --git a/gyp/debugger.gyp b/gyp/debugger.gyp index c86538d..e7e8275 100644 --- a/gyp/debugger.gyp +++ b/gyp/debugger.gyp @@ -136,7 +136,6 @@ 'dependencies': [ 'debugger_qt_mocs', 'skia_lib.gyp:skia_lib', - 'jsoncpp.gyp:jsoncpp', ], 'cflags': [ # Clang gets confused by QWeakPointer, see http://llvm.org/bugs/show_bug.cgi?id=13127 diff --git a/tools/debugger/SkDrawCommand.cpp b/tools/debugger/SkDrawCommand.cpp index 51ac318..17c59e6 100644 --- a/tools/debugger/SkDrawCommand.cpp +++ b/tools/debugger/SkDrawCommand.cpp @@ -8,138 +8,10 @@ #include "SkDrawCommand.h" -#include "SkBlurMaskFilter.h" -#include "SkColorFilter.h" -#include "SkDashPathEffect.h" -#include "SkImageFilter.h" -#include "SkMaskFilter.h" #include "SkObjectParser.h" -#include "SkPaintDefaults.h" -#include "SkPathEffect.h" #include "SkPicture.h" #include "SkTextBlob.h" #include "SkTextBlobRunIterator.h" -#include "SkTHash.h" -#include "SkTypeface.h" -#include "SkValidatingReadBuffer.h" -#include "SkWriteBuffer.h" - -#define SKDEBUGCANVAS_SEND_BINARIES false - -#define SKDEBUGCANVAS_ATTRIBUTE_COMMAND "command" -#define SKDEBUGCANVAS_ATTRIBUTE_MATRIX "matrix" -#define SKDEBUGCANVAS_ATTRIBUTE_COORDS "coords" -#define SKDEBUGCANVAS_ATTRIBUTE_BOUNDS "bounds" -#define SKDEBUGCANVAS_ATTRIBUTE_PAINT "paint" -#define SKDEBUGCANVAS_ATTRIBUTE_OUTER "outer" -#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_CAP "cap" -#define SKDEBUGCANVAS_ATTRIBUTE_ANTIALIAS "antiAlias" -#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_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_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" -#define SKDEBUGCANVAS_STYLE_STROKEANDFILL "strokeAndFill" - -#define SKDEBUGCANVAS_POINTMODE_POINTS "points" -#define SKDEBUGCANVAS_POINTMODE_LINES "lines" -#define SKDEBUGCANVAS_POINTMODE_POLYGON "polygon" - -#define SKDEBUGCANVAS_REGIONOP_DIFFERENCE "difference" -#define SKDEBUGCANVAS_REGIONOP_INTERSECT "intersect" -#define SKDEBUGCANVAS_REGIONOP_UNION "union" -#define SKDEBUGCANVAS_REGIONOP_XOR "xor" -#define SKDEBUGCANVAS_REGIONOP_REVERSE_DIFFERENCE "reverseDifference" -#define SKDEBUGCANVAS_REGIONOP_REPLACE "replace" - -#define SKDEBUGCANVAS_BLURSTYLE_NORMAL "normal" -#define SKDEBUGCANVAS_BLURSTYLE_SOLID "solid" -#define SKDEBUGCANVAS_BLURSTYLE_OUTER "outer" -#define SKDEBUGCANVAS_BLURSTYLE_INNER "inner" - -#define SKDEBUGCANVAS_BLURQUALITY_LOW "low" -#define SKDEBUGCANVAS_BLURQUALITY_HIGH "high" - -#define SKDEBUGCANVAS_ALIGN_LEFT "left" -#define SKDEBUGCANVAS_ALIGN_CENTER "center" -#define SKDEBUGCANVAS_ALIGN_RIGHT "right" - -#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_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" - -typedef SkDrawCommand* (*FROM_JSON)(Json::Value); // TODO(chudy): Refactor into non subclass model. @@ -198,55 +70,6 @@ SkString SkDrawCommand::toString() const { return SkString(GetCommandString(fOpType)); } -Json::Value SkDrawCommand::toJSON() const { - Json::Value result; - result[SKDEBUGCANVAS_ATTRIBUTE_COMMAND] = this->GetCommandString(fOpType); - return result; -} - -#define INSTALL_FACTORY(name) factories.set(SkString(GetCommandString(k ## name ##_OpType)), \ - (FROM_JSON) Sk ## name ## Command::fromJSON) -SkDrawCommand* SkDrawCommand::fromJSON(Json::Value& command) { - static SkTHashMap factories; - static bool initialized = false; - if (!initialized) { - initialized = true; - INSTALL_FACTORY(Restore); - INSTALL_FACTORY(ClipPath); - INSTALL_FACTORY(ClipRegion); - INSTALL_FACTORY(ClipRect); - INSTALL_FACTORY(ClipRRect); - INSTALL_FACTORY(Concat); - INSTALL_FACTORY(DrawBitmap); - INSTALL_FACTORY(DrawBitmapRect); - INSTALL_FACTORY(DrawBitmapNine); - INSTALL_FACTORY(DrawImage); - INSTALL_FACTORY(DrawImageRect); - INSTALL_FACTORY(DrawOval); - INSTALL_FACTORY(DrawPaint); - 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(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")); @@ -256,23 +79,6 @@ 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) { @@ -394,986 +200,6 @@ void render_drrect(SkCanvas* canvas, const SkRRect& outer, const SkRRect& inner) }; -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)); - result.append(Json::Value(y)); - return result; -} - -static Json::Value make_json_rect(const SkRect& rect) { - Json::Value result(Json::arrayValue); - result.append(Json::Value(rect.left())); - result.append(Json::Value(rect.top())); - result.append(Json::Value(rect.right())); - result.append(Json::Value(rect.bottom())); - return result; -} - -static Json::Value make_json_irect(const SkIRect& rect) { - Json::Value result(Json::arrayValue); - result.append(Json::Value(rect.left())); - result.append(Json::Value(rect.top())); - result.append(Json::Value(rect.right())); - result.append(Json::Value(rect.bottom())); - return result; -} - -static Json::Value make_json_rrect(const SkRRect& rrect) { - Json::Value result(Json::arrayValue); - result.append(make_json_rect(rrect.rect())); - result.append(make_json_point(rrect.radii(SkRRect::kUpperLeft_Corner))); - result.append(make_json_point(rrect.radii(SkRRect::kUpperRight_Corner))); - result.append(make_json_point(rrect.radii(SkRRect::kLowerRight_Corner))); - result.append(make_json_point(rrect.radii(SkRRect::kLowerLeft_Corner))); - return result; -} - -static Json::Value make_json_matrix(const SkMatrix& matrix) { - Json::Value result(Json::arrayValue); - Json::Value row1(Json::arrayValue); - row1.append(Json::Value(matrix[0])); - row1.append(Json::Value(matrix[1])); - row1.append(Json::Value(matrix[2])); - result.append(row1); - Json::Value row2(Json::arrayValue); - row2.append(Json::Value(matrix[3])); - 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: - 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); - break; - } - case SkPath::kQuad_Verb: { - Json::Value quad(Json::objectValue); - Json::Value coords(Json::arrayValue); - coords.append(make_json_point(pts[1])); - coords.append(make_json_point(pts[2])); - quad[SKDEBUGCANVAS_VERB_QUAD] = coords; - verbs.append(quad); - break; - } - case SkPath::kCubic_Verb: { - Json::Value cubic(Json::objectValue); - Json::Value coords(Json::arrayValue); - coords.append(make_json_point(pts[1])); - coords.append(make_json_point(pts[2])); - coords.append(make_json_point(pts[3])); - cubic[SKDEBUGCANVAS_VERB_CUBIC] = coords; - verbs.append(cubic); - break; - } - case SkPath::kConic_Verb: { - Json::Value conic(Json::objectValue); - Json::Value coords(Json::arrayValue); - coords.append(make_json_point(pts[1])); - coords.append(make_json_point(pts[2])); - coords.append(Json::Value(iter.conicWeight())); - conic[SKDEBUGCANVAS_VERB_CONIC] = coords; - verbs.append(conic); - break; - } - case SkPath::kMove_Verb: { - Json::Value move(Json::objectValue); - move[SKDEBUGCANVAS_VERB_MOVE] = make_json_point(pts[0]); - verbs.append(move); - break; - } - case SkPath::kClose_Verb: - verbs.append(Json::Value(SKDEBUGCANVAS_VERB_CLOSE)); - break; - case SkPath::kDone_Verb: - break; - } - } - result[SKDEBUGCANVAS_ATTRIBUTE_VERBS] = verbs; - return result; -} - -static Json::Value make_json_region(const SkRegion& region) { - return Json::Value(""); -} - -static Json::Value make_json_regionop(SkRegion::Op op) { - switch (op) { - case SkRegion::kDifference_Op: - return Json::Value(SKDEBUGCANVAS_REGIONOP_DIFFERENCE); - case SkRegion::kIntersect_Op: - return Json::Value(SKDEBUGCANVAS_REGIONOP_INTERSECT); - case SkRegion::kUnion_Op: - return Json::Value(SKDEBUGCANVAS_REGIONOP_UNION); - case SkRegion::kXOR_Op: - return Json::Value(SKDEBUGCANVAS_REGIONOP_XOR); - case SkRegion::kReverseDifference_Op: - return Json::Value(SKDEBUGCANVAS_REGIONOP_REVERSE_DIFFERENCE); - case SkRegion::kReplace_Op: - return Json::Value(SKDEBUGCANVAS_REGIONOP_REPLACE); - default: - SkASSERT(false); - return Json::Value(""); - }; -} - -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: - return Json::Value(SKDEBUGCANVAS_POINTMODE_POLYGON); - default: - SkASSERT(false); - return Json::Value(""); - }; -} - -void store_scalar(Json::Value* target, const char* key, SkScalar value, SkScalar defaultValue) { - if (value != defaultValue) { - (*target)[key] = Json::Value(value); - } -} - -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* data, size_t count, Json::Value* target) { - // just use a brain-dead JSON array for now, switch to base64 or something else smarter down the - // road - for (size_t i = 0; i < count; i++) { - target->append(((const uint8_t*)data)[i]); - } -} - -static void flatten(const SkFlattenable* flattenable, Json::Value* target, bool sendBinaries) { - if (sendBinaries) { - SkWriteBuffer buffer; - flattenable->flatten(buffer); - void* data = sk_malloc_throw(buffer.bytesWritten()); - buffer.writeToMemory(data); - Json::Value bytes; - encode_data(data, buffer.bytesWritten(), &bytes); - Json::Value jsonFlattenable; - jsonFlattenable[SKDEBUGCANVAS_ATTRIBUTE_NAME] = Json::Value(flattenable->getTypeName()); - jsonFlattenable[SKDEBUGCANVAS_ATTRIBUTE_BYTES] = bytes; - (*target) = jsonFlattenable; - free(data); - } else { - (*target)[SKDEBUGCANVAS_ATTRIBUTE_DESCRIPTION] = Json::Value(flattenable->getTypeName()); - } -} - -static bool SK_WARN_UNUSED_RESULT flatten(const SkImage& image, Json::Value* target, - bool sendBinaries) { - if (sendBinaries) { - SkData* encoded = image.encode(SkImageEncoder::kPNG_Type, 100); - if (encoded == nullptr) { - // PNG encode doesn't necessarily support all color formats, convert to a different - // format - size_t rowBytes = 4 * image.width(); - void* buffer = sk_malloc_throw(rowBytes * image.height()); - SkImageInfo dstInfo = SkImageInfo::Make(image.width(), image.height(), - kN32_SkColorType, kPremul_SkAlphaType); - if (!image.readPixels(dstInfo, buffer, rowBytes, 0, 0)) { - SkDebugf("readPixels failed\n"); - return false; - } - SkImage* converted = SkImage::NewRasterCopy(dstInfo, buffer, rowBytes); - encoded = converted->encode(SkImageEncoder::kPNG_Type, 100); - if (encoded == nullptr) { - SkDebugf("image encode failed\n"); - return false; - } - free(converted); - free(buffer); - } - Json::Value bytes; - encode_data(encoded->data(), encoded->size(), &bytes); - (*target)[SKDEBUGCANVAS_ATTRIBUTE_BYTES] = bytes; - encoded->unref(); - } else { - SkString description = SkStringPrintf("%dx%d pixel image", image.width(), image.height()); - (*target)[SKDEBUGCANVAS_ATTRIBUTE_DESCRIPTION] = Json::Value(description.c_str()); - } - return true; -} - -static const char* color_type_name(SkColorType colorType) { - switch (colorType) { - case kARGB_4444_SkColorType: - return SKDEBUGCANVAS_COLORTYPE_ARGB4444; - case kRGBA_8888_SkColorType: - return SKDEBUGCANVAS_COLORTYPE_RGBA8888; - case kBGRA_8888_SkColorType: - return SKDEBUGCANVAS_COLORTYPE_BGRA8888; - case kRGB_565_SkColorType: - return SKDEBUGCANVAS_COLORTYPE_565; - case kGray_8_SkColorType: - return SKDEBUGCANVAS_COLORTYPE_GRAY8; - case kIndex_8_SkColorType: - return SKDEBUGCANVAS_COLORTYPE_INDEX8; - case kAlpha_8_SkColorType: - return SKDEBUGCANVAS_COLORTYPE_ALPHA8; - default: - SkASSERT(false); - return SKDEBUGCANVAS_COLORTYPE_RGBA8888; - } -} - -static const char* alpha_type_name(SkAlphaType alphaType) { - switch (alphaType) { - case kOpaque_SkAlphaType: - return SKDEBUGCANVAS_ALPHATYPE_OPAQUE; - case kPremul_SkAlphaType: - return SKDEBUGCANVAS_ALPHATYPE_PREMUL; - case kUnpremul_SkAlphaType: - return SKDEBUGCANVAS_ALPHATYPE_UNPREMUL; - default: - SkASSERT(false); - return SKDEBUGCANVAS_ALPHATYPE_OPAQUE; - } -} - -// note that the caller is responsible for freeing the pointer -static Json::ArrayIndex decode_data(Json::Value bytes, void** target) { - Json::ArrayIndex size = bytes.size(); - *target = sk_malloc_throw(size); - for (Json::ArrayIndex i = 0; i < size; i++) { - ((uint8_t*) *target)[i] = bytes[i].asInt(); - } - return size; -} - -static SkFlattenable* load_flattenable(Json::Value jsonFlattenable) { - if (!jsonFlattenable.isMember(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; - } - void* data; - int size = decode_data(jsonFlattenable[SKDEBUGCANVAS_ATTRIBUTE_BYTES], &data); - SkValidatingReadBuffer buffer(data, size); - SkFlattenable* result = factory(buffer); - free(data); - if (!buffer.isValid()) { - SkDebugf("invalid buffer loading flattenable\n"); - return nullptr; - } - return result; -} - -static SkColorType colortype_from_name(const char* name) { - if (!strcmp(name, SKDEBUGCANVAS_COLORTYPE_ARGB4444)) { - return kARGB_4444_SkColorType; - } - else if (!strcmp(name, SKDEBUGCANVAS_COLORTYPE_RGBA8888)) { - return kRGBA_8888_SkColorType; - } - else if (!strcmp(name, SKDEBUGCANVAS_COLORTYPE_BGRA8888)) { - return kBGRA_8888_SkColorType; - } - else if (!strcmp(name, SKDEBUGCANVAS_COLORTYPE_565)) { - return kRGB_565_SkColorType; - } - else if (!strcmp(name, SKDEBUGCANVAS_COLORTYPE_GRAY8)) { - return kGray_8_SkColorType; - } - else if (!strcmp(name, SKDEBUGCANVAS_COLORTYPE_INDEX8)) { - return kIndex_8_SkColorType; - } - else if (!strcmp(name, SKDEBUGCANVAS_COLORTYPE_ALPHA8)) { - return kAlpha_8_SkColorType; - } - SkASSERT(false); - return kN32_SkColorType; -} - -static SkBitmap* convert_colortype(SkBitmap* bitmap, SkColorType colorType) { - if (bitmap->colorType() == colorType ) { - return bitmap; - } - SkBitmap* dst = new SkBitmap(); - if (bitmap->copyTo(dst, colorType)) { - delete bitmap; - return dst; - } - SkASSERT(false); - delete dst; - return bitmap; -} - -// caller is responsible for freeing return value -static SkBitmap* load_bitmap(const Json::Value& jsonBitmap) { - if (!jsonBitmap.isMember(SKDEBUGCANVAS_ATTRIBUTE_BYTES)) { - SkDebugf("invalid bitmap\n"); - return nullptr; - } - void* data; - int size = decode_data(jsonBitmap[SKDEBUGCANVAS_ATTRIBUTE_BYTES], &data); - SkMemoryStream stream(data, size); - SkImageDecoder* decoder = SkImageDecoder::Factory(&stream); - SkBitmap* bitmap = new SkBitmap(); - SkImageDecoder::Result result = decoder->decode(&stream, bitmap, - SkImageDecoder::kDecodePixels_Mode); - free(decoder); - if (result != SkImageDecoder::kFailure) { - free(data); - if (jsonBitmap.isMember(SKDEBUGCANVAS_ATTRIBUTE_COLOR)) { - const char* ctName = jsonBitmap[SKDEBUGCANVAS_ATTRIBUTE_COLOR].asCString(); - SkColorType ct = colortype_from_name(ctName); - if (ct != kIndex_8_SkColorType) { - bitmap = convert_colortype(bitmap, ct); - } - } - return bitmap; - } - SkDebugf("image decode failed\n"); - free(data); - return nullptr; -} - -static SkImage* load_image(const Json::Value& jsonImage) { - SkBitmap* bitmap = load_bitmap(jsonImage); - if (bitmap == nullptr) { - return nullptr; - } - SkImage* result = SkImage::NewFromBitmap(*bitmap); - delete bitmap; - return result; -} - -static bool SK_WARN_UNUSED_RESULT flatten(const SkBitmap& bitmap, Json::Value* target, - bool sendBinaries) { - bitmap.lockPixels(); - SkAutoTUnref image(SkImage::NewFromBitmap(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, sendBinaries); - return success; -} - -static void apply_paint_color(const SkPaint& paint, Json::Value* target) { - SkColor color = paint.getColor(); - if (color != SK_ColorBLACK) { - Json::Value colorValue(Json::arrayValue); - colorValue.append(Json::Value(SkColorGetA(color))); - colorValue.append(Json::Value(SkColorGetR(color))); - colorValue.append(Json::Value(SkColorGetG(color))); - colorValue.append(Json::Value(SkColorGetB(color))); - (*target)[SKDEBUGCANVAS_ATTRIBUTE_COLOR] = colorValue;; - } -} - -static void apply_paint_style(const SkPaint& paint, Json::Value* target) { - SkPaint::Style style = paint.getStyle(); - if (style != SkPaint::kFill_Style) { - switch (style) { - case SkPaint::kStroke_Style: { - Json::Value stroke(SKDEBUGCANVAS_STYLE_STROKE); - (*target)[SKDEBUGCANVAS_ATTRIBUTE_STYLE] = stroke; - break; - } - case SkPaint::kStrokeAndFill_Style: { - Json::Value strokeAndFill(SKDEBUGCANVAS_STYLE_STROKEANDFILL); - (*target)[SKDEBUGCANVAS_ATTRIBUTE_STYLE] = strokeAndFill; - break; - } - 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: { - (*target)[SKDEBUGCANVAS_ATTRIBUTE_CAP] = Json::Value(SKDEBUGCANVAS_CAP_BUTT); - break; - } - case SkPaint::kRound_Cap: { - (*target)[SKDEBUGCANVAS_ATTRIBUTE_CAP] = Json::Value(SKDEBUGCANVAS_CAP_ROUND); - break; - } - case SkPaint::kSquare_Cap: { - (*target)[SKDEBUGCANVAS_ATTRIBUTE_CAP] = Json::Value(SKDEBUGCANVAS_CAP_SQUARE); - break; - } - default: SkASSERT(false); - } - } -} -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); - break; - case SkBlurStyle::kSolid_SkBlurStyle: - blur[SKDEBUGCANVAS_ATTRIBUTE_STYLE] = Json::Value(SKDEBUGCANVAS_BLURSTYLE_SOLID); - break; - case SkBlurStyle::kOuter_SkBlurStyle: - blur[SKDEBUGCANVAS_ATTRIBUTE_STYLE] = Json::Value(SKDEBUGCANVAS_BLURSTYLE_OUTER); - break; - case SkBlurStyle::kInner_SkBlurStyle: - 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); - break; - case SkBlurQuality::kHigh_SkBlurQuality: - 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; - } - } -} - -static void apply_paint_patheffect(const SkPaint& paint, Json::Value* target, bool sendBinaries) { - 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])); - } - 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, sendBinaries); - (*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, - bool sendBinaries) { - SkTypeface* typeface = paint.getTypeface(); - if (typeface != nullptr) { - if (sendBinaries) { - Json::Value jsonTypeface; - SkDynamicMemoryWStream buffer; - typeface->serialize(&buffer); - void* data = sk_malloc_throw(buffer.bytesWritten()); - buffer.copyTo(data); - Json::Value bytes; - encode_data(data, buffer.bytesWritten(), &bytes); - jsonTypeface[SKDEBUGCANVAS_ATTRIBUTE_BYTES] = bytes; - free(data); - (*target)[SKDEBUGCANVAS_ATTRIBUTE_TYPEFACE] = jsonTypeface; - } - } -} - -static void apply_paint_shader(const SkPaint& paint, Json::Value* target, bool sendBinaries) { - SkFlattenable* shader = paint.getShader(); - if (shader != nullptr) { - Json::Value jsonShader; - flatten(shader, &jsonShader, sendBinaries); - (*target)[SKDEBUGCANVAS_ATTRIBUTE_SHADER] = jsonShader; - } -} - -static void apply_paint_xfermode(const SkPaint& paint, Json::Value* target, bool sendBinaries) { - SkFlattenable* xfermode = paint.getXfermode(); - if (xfermode != nullptr) { - Json::Value jsonXfermode; - flatten(xfermode, &jsonXfermode, sendBinaries); - (*target)[SKDEBUGCANVAS_ATTRIBUTE_XFERMODE] = jsonXfermode; - } -} - -static void apply_paint_imagefilter(const SkPaint& paint, Json::Value* target, bool sendBinaries) { - SkFlattenable* imageFilter = paint.getImageFilter(); - if (imageFilter != nullptr) { - Json::Value jsonImageFilter; - flatten(imageFilter, &jsonImageFilter, sendBinaries); - (*target)[SKDEBUGCANVAS_ATTRIBUTE_IMAGEFILTER] = jsonImageFilter; - } -} - -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; - } -} - -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_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_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_imagefilter(paint, &result, sendBinaries); - apply_paint_colorfilter(paint, &result, sendBinaries); - apply_paint_typeface(paint, &result, sendBinaries); - return result; -} - -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())); - } -} - -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(); - } - } -} - -static void extract_json_paint_patheffect(Json::Value& jsonPaint, SkPaint* target) { - if (jsonPaint.isMember(SKDEBUGCANVAS_ATTRIBUTE_PATHEFFECT)) { - Json::Value jsonPathEffect = jsonPaint[SKDEBUGCANVAS_ATTRIBUTE_PATHEFFECT]; - SkPathEffect* pathEffect = (SkPathEffect*) load_flattenable(jsonPathEffect); - if (pathEffect != nullptr) { - target->setPathEffect(pathEffect); - pathEffect->unref(); - } - } -} - -static void extract_json_paint_maskfilter(Json::Value& jsonPaint, SkPaint* target) { - if (jsonPaint.isMember(SKDEBUGCANVAS_ATTRIBUTE_MASKFILTER)) { - Json::Value jsonMaskFilter = jsonPaint[SKDEBUGCANVAS_ATTRIBUTE_MASKFILTER]; - SkMaskFilter* maskFilter = (SkMaskFilter*) load_flattenable(jsonMaskFilter); - if (maskFilter != nullptr) { - target->setMaskFilter(maskFilter); - maskFilter->unref(); - } - } -} - -static void extract_json_paint_colorfilter(Json::Value& jsonPaint, SkPaint* target) { - if (jsonPaint.isMember(SKDEBUGCANVAS_ATTRIBUTE_COLORFILTER)) { - Json::Value jsonColorFilter = jsonPaint[SKDEBUGCANVAS_ATTRIBUTE_COLORFILTER]; - SkColorFilter* colorFilter = (SkColorFilter*) load_flattenable(jsonColorFilter); - if (colorFilter != nullptr) { - target->setColorFilter(colorFilter); - colorFilter->unref(); - } - } -} - -static void extract_json_paint_xfermode(Json::Value& jsonPaint, SkPaint* target) { - 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_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(); - } - } -} - -static void extract_json_paint_style(Json::Value& jsonPaint, SkPaint* target) { - if (jsonPaint.isMember(SKDEBUGCANVAS_ATTRIBUTE_STYLE)) { - const char* style = jsonPaint[SKDEBUGCANVAS_ATTRIBUTE_STYLE].asCString(); - if (!strcmp(style, SKDEBUGCANVAS_STYLE_FILL)) { - target->setStyle(SkPaint::kFill_Style); - } - else if (!strcmp(style, SKDEBUGCANVAS_STYLE_STROKE)) { - target->setStyle(SkPaint::kStroke_Style); - } - 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_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_antialias(Json::Value& jsonPaint, SkPaint* target) { - if (jsonPaint.isMember(SKDEBUGCANVAS_ATTRIBUTE_ANTIALIAS)) { - target->setAntiAlias(jsonPaint[SKDEBUGCANVAS_ATTRIBUTE_ANTIALIAS].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)) { - style = SkBlurStyle::kSolid_SkBlurStyle; - } - else if (!strcmp(jsonStyle, SKDEBUGCANVAS_BLURSTYLE_OUTER)) { - style = SkBlurStyle::kOuter_SkBlurStyle; - } - else if (!strcmp(jsonStyle, SKDEBUGCANVAS_BLURSTYLE_INNER)) { - style = SkBlurStyle::kInner_SkBlurStyle; - } - else { - SkASSERT(false); - style = SkBlurStyle::kNormal_SkBlurStyle; - } - SkBlurMaskFilter::BlurFlags flags; - const char* jsonQuality = blur[SKDEBUGCANVAS_ATTRIBUTE_QUALITY].asCString(); - if (!strcmp(jsonQuality, SKDEBUGCANVAS_BLURQUALITY_LOW)) { - flags = SkBlurMaskFilter::BlurFlags::kNone_BlurFlag; - } - else if (!strcmp(jsonQuality, SKDEBUGCANVAS_BLURQUALITY_HIGH)) { - flags = SkBlurMaskFilter::BlurFlags::kHighQuality_BlurFlag; - } - else { - SkASSERT(false); - flags = SkBlurMaskFilter::BlurFlags::kNone_BlurFlag; - } - target->setMaskFilter(SkBlurMaskFilter::Create(style, sigma, flags)); - } -} - -static void extract_json_paint_dashing(Json::Value& jsonPaint, SkPaint* target) { - if (jsonPaint.isMember(SKDEBUGCANVAS_ATTRIBUTE_DASHING)) { - Json::Value dash = jsonPaint[SKDEBUGCANVAS_ATTRIBUTE_DASHING]; - Json::Value jsonIntervals = dash[SKDEBUGCANVAS_ATTRIBUTE_INTERVALS]; - Json::ArrayIndex count = jsonIntervals.size(); - SkScalar* intervals = (SkScalar*) sk_malloc_throw(count * sizeof(SkScalar)); - for (Json::ArrayIndex i = 0; i < count; i++) { - intervals[i] = jsonIntervals[i].asFloat(); - } - SkScalar phase = dash[SKDEBUGCANVAS_ATTRIBUTE_PHASE].asFloat(); - target->setPathEffect(SkDashPathEffect::Create(intervals, count, phase)); - free(intervals); - } -} - -static void extract_json_paint_textalign(Json::Value& jsonPaint, SkPaint* target) { - if (jsonPaint.isMember(SKDEBUGCANVAS_ATTRIBUTE_TEXTALIGN)) { - SkPaint::Align textAlign; - const char* jsonAlign = jsonPaint[SKDEBUGCANVAS_ATTRIBUTE_TEXTALIGN].asCString(); - if (!strcmp(jsonAlign, SKDEBUGCANVAS_ALIGN_LEFT)) { - textAlign = SkPaint::kLeft_Align; - } - else if (!strcmp(jsonAlign, SKDEBUGCANVAS_ALIGN_CENTER)) { - textAlign = SkPaint::kCenter_Align; - } - else if (!strcmp(jsonAlign, SKDEBUGCANVAS_ALIGN_RIGHT)) { - textAlign = SkPaint::kRight_Align; - } - else { - SkASSERT(false); - textAlign = SkPaint::kLeft_Align; - } - target->setTextAlign(textAlign); - } -} - -static void extract_json_paint_textsize(Json::Value& jsonPaint, SkPaint* target) { - if (jsonPaint.isMember(SKDEBUGCANVAS_ATTRIBUTE_TEXTSIZE)) { - float textSize = jsonPaint[SKDEBUGCANVAS_ATTRIBUTE_TEXTSIZE].asFloat(); - target->setTextSize(textSize); - } -} - -static void extract_json_paint_textscalex(Json::Value& jsonPaint, SkPaint* target) { - if (jsonPaint.isMember(SKDEBUGCANVAS_ATTRIBUTE_TEXTSCALEX)) { - float textScaleX = jsonPaint[SKDEBUGCANVAS_ATTRIBUTE_TEXTSCALEX].asFloat(); - target->setTextScaleX(textScaleX); - } -} - -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_typeface(Json::Value& jsonPaint, SkPaint* target) { - if (jsonPaint.isMember(SKDEBUGCANVAS_ATTRIBUTE_TYPEFACE)) { - Json::Value jsonTypeface = jsonPaint[SKDEBUGCANVAS_ATTRIBUTE_TYPEFACE]; - Json::Value bytes = jsonTypeface[SKDEBUGCANVAS_ATTRIBUTE_BYTES]; - void* data; - Json::ArrayIndex length = decode_data(bytes, &data); - SkMemoryStream buffer(data, length); - SkTypeface* typeface = SkTypeface::Deserialize(&buffer); - free(data); - target->setTypeface(typeface); - } -} - -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_imagefilter(paint, result); - extract_json_paint_style(paint, result); - extract_json_paint_strokewidth(paint, result); - extract_json_paint_strokemiter(paint, result); - extract_json_paint_cap(paint, result); - extract_json_paint_antialias(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) { - 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[4][0].asFloat(), rrect[4][1].asFloat() } - }; - result->setRectRadii(SkRect::MakeLTRB(rrect[0][0].asFloat(), rrect[0][1].asFloat(), - rrect[0][2].asFloat(), rrect[0][3].asFloat()), - radii); -} - -static void extract_json_matrix(Json::Value& matrix, SkMatrix* result) { - SkScalar values[] = { - matrix[0][0].asFloat(), matrix[0][1].asFloat(), matrix[0][2].asFloat(), - matrix[1][0].asFloat(), matrix[1][1].asFloat(), matrix[1][2].asFloat(), - matrix[2][0].asFloat(), matrix[2][1].asFloat(), matrix[2][2].asFloat() - }; - result->set9(values); -} - -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)) { - result->setFillType(SkPath::kEvenOdd_FillType); - } - else if (!strcmp(fillType, SKDEBUGCANVAS_FILLTYPE_INVERSEWINDING)) { - result->setFillType(SkPath::kInverseWinding_FillType); - } - else if (!strcmp(fillType, SKDEBUGCANVAS_FILLTYPE_INVERSEEVENODD)) { - result->setFillType(SkPath::kInverseEvenOdd_FillType); - } - Json::Value verbs = path[SKDEBUGCANVAS_ATTRIBUTE_VERBS]; - for (Json::ArrayIndex i = 0; i < verbs.size(); i++) { - Json::Value verb = verbs[i]; - if (verb.isString()) { - SkASSERT(!strcmp(verb.asCString(), SKDEBUGCANVAS_VERB_CLOSE)); - result->close(); - } - else { - if (verb.isMember(SKDEBUGCANVAS_VERB_MOVE)) { - Json::Value move = verb[SKDEBUGCANVAS_VERB_MOVE]; - result->moveTo(move[0].asFloat(), move[1].asFloat()); - } - else if (verb.isMember(SKDEBUGCANVAS_VERB_LINE)) { - Json::Value line = verb[SKDEBUGCANVAS_VERB_LINE]; - result->lineTo(line[0].asFloat(), line[1].asFloat()); - } - else if (verb.isMember(SKDEBUGCANVAS_VERB_QUAD)) { - Json::Value quad = verb[SKDEBUGCANVAS_VERB_QUAD]; - result->quadTo(quad[0][0].asFloat(), quad[0][1].asFloat(), - quad[1][0].asFloat(), quad[1][1].asFloat()); - } - else if (verb.isMember(SKDEBUGCANVAS_VERB_CUBIC)) { - Json::Value cubic = verb[SKDEBUGCANVAS_VERB_CUBIC]; - result->cubicTo(cubic[0][0].asFloat(), cubic[0][1].asFloat(), - cubic[1][0].asFloat(), cubic[1][1].asFloat(), - cubic[2][0].asFloat(), cubic[2][1].asFloat()); - } - else if (verb.isMember(SKDEBUGCANVAS_VERB_CONIC)) { - Json::Value conic = verb[SKDEBUGCANVAS_VERB_CONIC]; - result->conicTo(conic[0][0].asFloat(), conic[0][1].asFloat(), - conic[1][0].asFloat(), conic[1][1].asFloat(), - conic[2].asFloat()); - } - else { - SkASSERT(false); - } - } - } -} - -SkRegion::Op get_json_regionop(Json::Value& jsonOp) { - const char* op = jsonOp.asCString(); - if (!strcmp(op, SKDEBUGCANVAS_REGIONOP_DIFFERENCE)) { - return SkRegion::kDifference_Op; - } - else if (!strcmp(op, SKDEBUGCANVAS_REGIONOP_INTERSECT)) { - return SkRegion::kIntersect_Op; - } - else if (!strcmp(op, SKDEBUGCANVAS_REGIONOP_UNION)) { - return SkRegion::kUnion_Op; - } - else if (!strcmp(op, SKDEBUGCANVAS_REGIONOP_XOR)) { - return SkRegion::kXOR_Op; - } - 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; -} - SkClipPathCommand::SkClipPathCommand(const SkPath& path, SkRegion::Op op, bool doAA) : INHERITED(kClipPath_OpType) { @@ -1395,21 +221,6 @@ bool SkClipPathCommand::render(SkCanvas* canvas) const { return true; } -Json::Value SkClipPathCommand::toJSON() const { - Json::Value result = INHERITED::toJSON(); - 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) { - SkPath path; - extract_json_path(command[SKDEBUGCANVAS_ATTRIBUTE_PATH], &path); - 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; @@ -1423,18 +234,6 @@ void SkClipRegionCommand::execute(SkCanvas* canvas) const { canvas->clipRegion(fRegion, fOp); } -Json::Value SkClipRegionCommand::toJSON() const { - Json::Value result = INHERITED::toJSON(); - result[SKDEBUGCANVAS_ATTRIBUTE_REGION] = make_json_region(fRegion); - result[SKDEBUGCANVAS_ATTRIBUTE_REGIONOP] = make_json_regionop(fOp); - return result; -} - -SkClipRegionCommand* SkClipRegionCommand::fromJSON(Json::Value& command) { - SkASSERT(false); - return nullptr; -} - SkClipRectCommand::SkClipRectCommand(const SkRect& rect, SkRegion::Op op, bool doAA) : INHERITED(kClipRect_OpType) { fRect = rect; @@ -1450,21 +249,6 @@ void SkClipRectCommand::execute(SkCanvas* canvas) const { canvas->clipRect(fRect, fOp, fDoAA); } -Json::Value SkClipRectCommand::toJSON() const { - Json::Value result = INHERITED::toJSON(); - 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) { - SkRect rect; - extract_json_rect(command[SKDEBUGCANVAS_ATTRIBUTE_COORDS], &rect); - 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; @@ -1485,22 +269,6 @@ bool SkClipRRectCommand::render(SkCanvas* canvas) const { return true; } -Json::Value SkClipRRectCommand::toJSON() const { - Json::Value result = INHERITED::toJSON(); - 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) { - SkRRect rrect; - extract_json_rrect(command[SKDEBUGCANVAS_ATTRIBUTE_COORDS], &rrect); - 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; @@ -1512,18 +280,6 @@ void SkConcatCommand::execute(SkCanvas* canvas) const { canvas->concat(fMatrix); } -Json::Value SkConcatCommand::toJSON() const { - Json::Value result = INHERITED::toJSON(); - result[SKDEBUGCANVAS_ATTRIBUTE_MATRIX] = make_json_matrix(fMatrix); - return result; -} - -SkConcatCommand* SkConcatCommand::fromJSON(Json::Value& command) { - SkMatrix matrix; - extract_json_matrix(command[SKDEBUGCANVAS_ATTRIBUTE_MATRIX], &matrix); - return new SkConcatCommand(matrix); -} - SkDrawBitmapCommand::SkDrawBitmapCommand(const SkBitmap& bitmap, SkScalar left, SkScalar top, const SkPaint* paint) : INHERITED(kDrawBitmap_OpType) { @@ -1554,41 +310,6 @@ bool SkDrawBitmapCommand::render(SkCanvas* canvas) const { return true; } -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); - } - } - return result; -} - -SkDrawBitmapCommand* SkDrawBitmapCommand::fromJSON(Json::Value& command) { - SkBitmap* bitmap = load_bitmap(command[SKDEBUGCANVAS_ATTRIBUTE_BITMAP]); - 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], &paint); - paintPtr = &paint; - } - else { - paintPtr = nullptr; - } - 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) { @@ -1620,44 +341,6 @@ bool SkDrawBitmapNineCommand::render(SkCanvas* canvas) const { return true; } -Json::Value SkDrawBitmapNineCommand::toJSON() const { - Json::Value result = INHERITED::toJSON(); - Json::Value encoded; - if (flatten(fBitmap, &encoded, SKDEBUGCANVAS_SEND_BINARIES)) { - result[SKDEBUGCANVAS_ATTRIBUTE_BITMAP] = encoded; - result[SKDEBUGCANVAS_ATTRIBUTE_CENTER] = make_json_irect(fCenter); - result[SKDEBUGCANVAS_ATTRIBUTE_DST] = make_json_rect(fDst); - if (fPaintPtr != nullptr) { - result[SKDEBUGCANVAS_ATTRIBUTE_PAINT] = make_json_paint(*fPaintPtr, - SKDEBUGCANVAS_SEND_BINARIES); - } - } - return result; -} - -SkDrawBitmapNineCommand* SkDrawBitmapNineCommand::fromJSON(Json::Value& command) { - SkBitmap* bitmap = load_bitmap(command[SKDEBUGCANVAS_ATTRIBUTE_BITMAP]); - if (bitmap == nullptr) { - return nullptr; - } - SkIRect center; - extract_json_irect(command[SKDEBUGCANVAS_ATTRIBUTE_CENTER], ¢er); - 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], &paint); - paintPtr = &paint; - } - else { - paintPtr = nullptr; - } - SkDrawBitmapNineCommand* result = new SkDrawBitmapNineCommand(*bitmap, center, dst, paintPtr); - delete bitmap; - return result; -} - SkDrawBitmapRectCommand::SkDrawBitmapRectCommand(const SkBitmap& bitmap, const SkRect* src, const SkRect& dst, const SkPaint* paint, SkCanvas::SrcRectConstraint constraint) @@ -1698,65 +381,6 @@ bool SkDrawBitmapRectCommand::render(SkCanvas* canvas) const { return true; } -Json::Value SkDrawBitmapRectCommand::toJSON() const { - Json::Value result = INHERITED::toJSON(); - Json::Value encoded; - if (flatten(fBitmap, &encoded, SKDEBUGCANVAS_SEND_BINARIES)) { - result[SKDEBUGCANVAS_ATTRIBUTE_BITMAP] = encoded; - if (!fSrc.isEmpty()) { - result[SKDEBUGCANVAS_ATTRIBUTE_SRC] = make_json_rect(fSrc); - } - result[SKDEBUGCANVAS_ATTRIBUTE_DST] = make_json_rect(fDst); - if (fPaintPtr != nullptr) { - result[SKDEBUGCANVAS_ATTRIBUTE_PAINT] = make_json_paint(*fPaintPtr, - SKDEBUGCANVAS_SEND_BINARIES); - } - if (fConstraint == SkCanvas::kStrict_SrcRectConstraint) { - result[SKDEBUGCANVAS_ATTRIBUTE_STRICT] = Json::Value(true); - } - } - return result; -} - -SkDrawBitmapRectCommand* SkDrawBitmapRectCommand::fromJSON(Json::Value& command) { - SkBitmap* bitmap = load_bitmap(command[SKDEBUGCANVAS_ATTRIBUTE_BITMAP]); - 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], &paint); - paintPtr = &paint; - } - else { - paintPtr = nullptr; - } - SkCanvas::SrcRectConstraint constraint; - 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); - srcPtr = &src; - } - else { - srcPtr = nullptr; - } - SkDrawBitmapRectCommand* result = new SkDrawBitmapRectCommand(*bitmap, srcPtr, dst, paintPtr, - constraint); - delete bitmap; - return result; -} - SkDrawImageCommand::SkDrawImageCommand(const SkImage* image, SkScalar left, SkScalar top, const SkPaint* paint) : INHERITED(kDrawImage_OpType) @@ -1789,41 +413,6 @@ bool SkDrawImageCommand::render(SkCanvas* canvas) const { return true; } -Json::Value SkDrawImageCommand::toJSON() const { - Json::Value result = INHERITED::toJSON(); - Json::Value encoded; - if (flatten(*fImage, &encoded, SKDEBUGCANVAS_SEND_BINARIES)) { - 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(), - SKDEBUGCANVAS_SEND_BINARIES); - } - } - return result; -} - -SkDrawImageCommand* SkDrawImageCommand::fromJSON(Json::Value& command) { - SkImage* image = load_image(command[SKDEBUGCANVAS_ATTRIBUTE_IMAGE]); - 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], &paint); - paintPtr = &paint; - } - else { - paintPtr = nullptr; - } - SkDrawImageCommand* result = new SkDrawImageCommand(image, point[0].asFloat(), - point[1].asFloat(), paintPtr); - image->unref(); - return result; -} - SkDrawImageRectCommand::SkDrawImageRectCommand(const SkImage* image, const SkRect* src, const SkRect& dst, const SkPaint* paint, SkCanvas::SrcRectConstraint constraint) @@ -1865,65 +454,6 @@ bool SkDrawImageRectCommand::render(SkCanvas* canvas) const { return true; } -Json::Value SkDrawImageRectCommand::toJSON() const { - Json::Value result = INHERITED::toJSON(); - Json::Value encoded; - if (flatten(*fImage.get(), &encoded, SKDEBUGCANVAS_SEND_BINARIES)) { - result[SKDEBUGCANVAS_ATTRIBUTE_BITMAP] = encoded; - if (fSrc.isValid()) { - result[SKDEBUGCANVAS_ATTRIBUTE_SRC] = make_json_rect(*fSrc.get()); - } - result[SKDEBUGCANVAS_ATTRIBUTE_DST] = make_json_rect(fDst); - if (fPaint.isValid()) { - result[SKDEBUGCANVAS_ATTRIBUTE_PAINT] = make_json_paint(*fPaint.get(), - SKDEBUGCANVAS_SEND_BINARIES); - } - if (fConstraint == SkCanvas::kStrict_SrcRectConstraint) { - result[SKDEBUGCANVAS_ATTRIBUTE_STRICT] = Json::Value(true); - } - } - return result; -} - -SkDrawImageRectCommand* SkDrawImageRectCommand::fromJSON(Json::Value& command) { - SkImage* image = load_image(command[SKDEBUGCANVAS_ATTRIBUTE_IMAGE]); - 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], &paint); - paintPtr = &paint; - } - else { - paintPtr = nullptr; - } - SkCanvas::SrcRectConstraint constraint; - 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); - srcPtr = &src; - } - else { - srcPtr = nullptr; - } - SkDrawImageRectCommand* result = new SkDrawImageRectCommand(image, srcPtr, dst, paintPtr, - constraint); - image->unref(); - return result; -} - SkDrawOvalCommand::SkDrawOvalCommand(const SkRect& oval, const SkPaint& paint) : INHERITED(kDrawOval_OpType) { fOval = oval; @@ -1953,21 +483,6 @@ bool SkDrawOvalCommand::render(SkCanvas* canvas) const { return true; } -Json::Value SkDrawOvalCommand::toJSON() const { - Json::Value result = INHERITED::toJSON(); - result[SKDEBUGCANVAS_ATTRIBUTE_COORDS] = make_json_rect(fOval); - result[SKDEBUGCANVAS_ATTRIBUTE_PAINT] = make_json_paint(fPaint, SKDEBUGCANVAS_SEND_BINARIES); - return result; -} - -SkDrawOvalCommand* SkDrawOvalCommand::fromJSON(Json::Value& command) { - SkRect coords; - extract_json_rect(command[SKDEBUGCANVAS_ATTRIBUTE_COORDS], &coords); - SkPaint paint; - extract_json_paint(command[SKDEBUGCANVAS_ATTRIBUTE_PAINT], &paint); - return new SkDrawOvalCommand(coords, paint); -} - SkDrawPaintCommand::SkDrawPaintCommand(const SkPaint& paint) : INHERITED(kDrawPaint_OpType) { fPaint = paint; @@ -1985,18 +500,6 @@ bool SkDrawPaintCommand::render(SkCanvas* canvas) const { return true; } -Json::Value SkDrawPaintCommand::toJSON() const { - Json::Value result = INHERITED::toJSON(); - result[SKDEBUGCANVAS_ATTRIBUTE_PAINT] = make_json_paint(fPaint, SKDEBUGCANVAS_SEND_BINARIES); - return result; -} - -SkDrawPaintCommand* SkDrawPaintCommand::fromJSON(Json::Value& command) { - SkPaint paint; - extract_json_paint(command[SKDEBUGCANVAS_ATTRIBUTE_PAINT], &paint); - return new SkDrawPaintCommand(paint); -} - SkDrawPathCommand::SkDrawPathCommand(const SkPath& path, const SkPaint& paint) : INHERITED(kDrawPath_OpType) { fPath = path; @@ -2015,21 +518,6 @@ bool SkDrawPathCommand::render(SkCanvas* canvas) const { return true; } -Json::Value SkDrawPathCommand::toJSON() const { - Json::Value result = INHERITED::toJSON(); - result[SKDEBUGCANVAS_ATTRIBUTE_PATH] = make_json_path(fPath); - result[SKDEBUGCANVAS_ATTRIBUTE_PAINT] = make_json_paint(fPaint, SKDEBUGCANVAS_SEND_BINARIES); - return result; -} - -SkDrawPathCommand* SkDrawPathCommand::fromJSON(Json::Value& command) { - SkPath path; - extract_json_path(command[SKDEBUGCANVAS_ATTRIBUTE_PATH], &path); - SkPaint paint; - extract_json_paint(command[SKDEBUGCANVAS_ATTRIBUTE_PAINT], &paint); - return new SkDrawPathCommand(path, paint); -} - SkBeginDrawPictureCommand::SkBeginDrawPictureCommand(const SkPicture* picture, const SkMatrix* matrix, const SkPaint* paint) @@ -2136,47 +624,6 @@ bool SkDrawPointsCommand::render(SkCanvas* canvas) const { return true; } -Json::Value SkDrawPointsCommand::toJSON() const { - Json::Value result = INHERITED::toJSON(); - 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, SKDEBUGCANVAS_SEND_BINARIES); - return result; -} - -SkDrawPointsCommand* SkDrawPointsCommand::fromJSON(Json::Value& command) { - 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)) { - mode = SkCanvas::kPolygon_PointMode; - } - else { - SkASSERT(false); - return nullptr; - } - Json::Value jsonPoints = command[SKDEBUGCANVAS_ATTRIBUTE_POINTS]; - int count = (int) jsonPoints.size(); - SkPoint* points = (SkPoint*) sk_malloc_throw(count * sizeof(SkPoint)); - for (int i = 0; i < count; i++) { - points[i] = SkPoint::Make(jsonPoints[i][0].asFloat(), jsonPoints[i][1].asFloat()); - } - SkPaint paint; - extract_json_paint(command[SKDEBUGCANVAS_ATTRIBUTE_PAINT], &paint); - SkDrawPointsCommand* result = new SkDrawPointsCommand(mode, count, points, paint); - free(points); - return result; -} - SkDrawPosTextCommand::SkDrawPosTextCommand(const void* text, size_t byteLength, const SkPoint pos[], const SkPaint& paint) : INHERITED(kDrawPosText_OpType) { @@ -2201,31 +648,6 @@ void SkDrawPosTextCommand::execute(SkCanvas* canvas) const { canvas->drawPosText(fText, fByteLength, fPos, fPaint); } -Json::Value SkDrawPosTextCommand::toJSON() const { - Json::Value result = INHERITED::toJSON(); - result[SKDEBUGCANVAS_ATTRIBUTE_TEXT] = Json::Value((const char*) fText, - ((const char*) fText) + fByteLength); - Json::Value coords(Json::arrayValue); - for (size_t i = 0; i < fByteLength; i++) { - coords.append(make_json_point(fPos[i])); - } - result[SKDEBUGCANVAS_ATTRIBUTE_COORDS] = coords; - result[SKDEBUGCANVAS_ATTRIBUTE_PAINT] = make_json_paint(fPaint, SKDEBUGCANVAS_SEND_BINARIES); - return result; -} - -SkDrawPosTextCommand* SkDrawPosTextCommand::fromJSON(Json::Value& command) { - const char* text = command[SKDEBUGCANVAS_ATTRIBUTE_TEXT].asCString(); - SkPaint paint; - extract_json_paint(command[SKDEBUGCANVAS_ATTRIBUTE_PAINT], &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()); - } - return new SkDrawPosTextCommand(text, strlen(text), points, paint); -} SkDrawPosTextHCommand::SkDrawPosTextHCommand(const void* text, size_t byteLength, const SkScalar xpos[], SkScalar constY, @@ -2316,93 +738,6 @@ bool SkDrawTextBlobCommand::render(SkCanvas* canvas) const { return true; } -Json::Value SkDrawTextBlobCommand::toJSON() const { - Json::Value result = INHERITED::toJSON(); - Json::Value runs(Json::arrayValue); - SkTextBlobRunIterator iter(fBlob.get()); - while (!iter.done()) { - Json::Value run(Json::objectValue); - Json::Value jsonPositions(Json::arrayValue); - Json::Value jsonGlyphs(Json::arrayValue); - const SkScalar* iterPositions = iter.pos(); - const uint16_t* iterGlyphs = iter.glyphs(); - for (uint32_t i = 0; i < iter.glyphCount(); i++) { - switch (iter.positioning()) { - case SkTextBlob::kFull_Positioning: - jsonPositions.append(make_json_point(iterPositions[i * 2], - iterPositions[i * 2 + 1])); - break; - case SkTextBlob::kHorizontal_Positioning: - jsonPositions.append(Json::Value(iterPositions[i])); - break; - case SkTextBlob::kDefault_Positioning: - break; - } - jsonGlyphs.append(Json::Value(iterGlyphs[i])); - } - if (iter.positioning() != SkTextBlob::kDefault_Positioning) { - run[SKDEBUGCANVAS_ATTRIBUTE_POSITIONS] = jsonPositions; - } - run[SKDEBUGCANVAS_ATTRIBUTE_GLYPHS] = jsonGlyphs; - SkPaint fontPaint; - iter.applyFontToPaint(&fontPaint); - run[SKDEBUGCANVAS_ATTRIBUTE_FONT] = make_json_paint(fontPaint, SKDEBUGCANVAS_SEND_BINARIES); - run[SKDEBUGCANVAS_ATTRIBUTE_COORDS] = make_json_point(iter.offset()); - 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, SKDEBUGCANVAS_SEND_BINARIES); - return result; -} - -SkDrawTextBlobCommand* SkDrawTextBlobCommand::fromJSON(Json::Value& command) { - 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], &font); - Json::Value glyphs = run[SKDEBUGCANVAS_ATTRIBUTE_GLYPHS]; - int count = glyphs.size(); - Json::Value coords = run[SKDEBUGCANVAS_ATTRIBUTE_COORDS]; - SkScalar x = coords[0].asFloat(); - SkScalar y = coords[1].asFloat(); - if (run.isMember(SKDEBUGCANVAS_ATTRIBUTE_POSITIONS)) { - Json::Value positions = run[SKDEBUGCANVAS_ATTRIBUTE_POSITIONS]; - if (positions.size() > 0 && positions[0].isNumeric()) { - SkTextBlobBuilder::RunBuffer buffer = builder.allocRunPosH(font, count, y); - for (int j = 0; j < count; j++) { - buffer.glyphs[j] = glyphs[j].asUInt(); - buffer.pos[j] = positions[j].asFloat(); - } - } - else { - SkTextBlobBuilder::RunBuffer buffer = builder.allocRunPos(font, count); - for (int j = 0; j < count; j++) { - buffer.glyphs[j] = glyphs[j].asUInt(); - buffer.pos[j * 2] = positions[j][0].asFloat(); - buffer.pos[j * 2 + 1] = positions[j][1].asFloat(); - } - } - } - else { - SkTextBlobBuilder::RunBuffer buffer = builder.allocRun(font, count, x, y); - for (int j = 0; j < count; j++) { - buffer.glyphs[j] = glyphs[j].asUInt(); - } - } - } - SkScalar x = command[SKDEBUGCANVAS_ATTRIBUTE_X].asFloat(); - SkScalar y = command[SKDEBUGCANVAS_ATTRIBUTE_Y].asFloat(); - 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) @@ -2433,21 +768,6 @@ void SkDrawRectCommand::execute(SkCanvas* canvas) const { canvas->drawRect(fRect, fPaint); } -Json::Value SkDrawRectCommand::toJSON() const { - Json::Value result = INHERITED::toJSON(); - result[SKDEBUGCANVAS_ATTRIBUTE_COORDS] = make_json_rect(fRect); - result[SKDEBUGCANVAS_ATTRIBUTE_PAINT] = make_json_paint(fPaint, SKDEBUGCANVAS_SEND_BINARIES); - return result; -} - -SkDrawRectCommand* SkDrawRectCommand::fromJSON(Json::Value& command) { - SkRect coords; - extract_json_rect(command[SKDEBUGCANVAS_ATTRIBUTE_COORDS], &coords); - SkPaint paint; - extract_json_paint(command[SKDEBUGCANVAS_ATTRIBUTE_PAINT], &paint); - return new SkDrawRectCommand(coords, paint); -} - SkDrawRRectCommand::SkDrawRRectCommand(const SkRRect& rrect, const SkPaint& paint) : INHERITED(kDrawRRect_OpType) { fRRect = rrect; @@ -2466,21 +786,6 @@ bool SkDrawRRectCommand::render(SkCanvas* canvas) const { return true; } -Json::Value SkDrawRRectCommand::toJSON() const { - Json::Value result = INHERITED::toJSON(); - result[SKDEBUGCANVAS_ATTRIBUTE_COORDS] = make_json_rrect(fRRect); - result[SKDEBUGCANVAS_ATTRIBUTE_PAINT] = make_json_paint(fPaint, SKDEBUGCANVAS_SEND_BINARIES); - return result; -} - -SkDrawRRectCommand* SkDrawRRectCommand::fromJSON(Json::Value& command) { - SkRRect coords; - extract_json_rrect(command[SKDEBUGCANVAS_ATTRIBUTE_COORDS], &coords); - SkPaint paint; - extract_json_paint(command[SKDEBUGCANVAS_ATTRIBUTE_PAINT], &paint); - return new SkDrawRRectCommand(coords, paint); -} - SkDrawDRRectCommand::SkDrawDRRectCommand(const SkRRect& outer, const SkRRect& inner, const SkPaint& paint) @@ -2503,24 +808,6 @@ bool SkDrawDRRectCommand::render(SkCanvas* canvas) const { return true; } -Json::Value SkDrawDRRectCommand::toJSON() const { - Json::Value result = INHERITED::toJSON(); - result[SKDEBUGCANVAS_ATTRIBUTE_OUTER] = make_json_rrect(fOuter); - result[SKDEBUGCANVAS_ATTRIBUTE_INNER] = make_json_rrect(fInner); - result[SKDEBUGCANVAS_ATTRIBUTE_PAINT] = make_json_paint(fPaint, SKDEBUGCANVAS_SEND_BINARIES); - return result; -} - -SkDrawDRRectCommand* SkDrawDRRectCommand::fromJSON(Json::Value& command) { - 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], &paint); - return new SkDrawDRRectCommand(outer, inner, paint); -} - SkDrawTextCommand::SkDrawTextCommand(const void* text, size_t byteLength, SkScalar x, SkScalar y, const SkPaint& paint) : INHERITED(kDrawText_OpType) { @@ -2541,25 +828,6 @@ void SkDrawTextCommand::execute(SkCanvas* canvas) const { canvas->drawText(fText, fByteLength, fX, fY, fPaint); } -Json::Value SkDrawTextCommand::toJSON() const { - Json::Value result = INHERITED::toJSON(); - 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, SKDEBUGCANVAS_SEND_BINARIES); - return result; -} - -SkDrawTextCommand* SkDrawTextCommand::fromJSON(Json::Value& command) { - const char* text = command[SKDEBUGCANVAS_ATTRIBUTE_TEXT].asCString(); - SkPaint paint; - extract_json_paint(command[SKDEBUGCANVAS_ATTRIBUTE_PAINT], &paint); - Json::Value coords = command[SKDEBUGCANVAS_ATTRIBUTE_COORDS]; - 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) @@ -2589,37 +857,6 @@ void SkDrawTextOnPathCommand::execute(SkCanvas* canvas) const { fPaint); } -Json::Value SkDrawTextOnPathCommand::toJSON() const { - Json::Value result = INHERITED::toJSON(); - 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] = make_json_matrix(fMatrix); - } - result[SKDEBUGCANVAS_ATTRIBUTE_PAINT] = make_json_paint(fPaint, SKDEBUGCANVAS_SEND_BINARIES); - return result; -} - -SkDrawTextOnPathCommand* SkDrawTextOnPathCommand::fromJSON(Json::Value& command) { - const char* text = command[SKDEBUGCANVAS_ATTRIBUTE_TEXT].asCString(); - SkPaint paint; - extract_json_paint(command[SKDEBUGCANVAS_ATTRIBUTE_PAINT], &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); - matrixPtr = &matrix; - } - else { - matrixPtr = nullptr; - } - return new SkDrawTextOnPathCommand(text, strlen(text), path, matrixPtr, paint); -} - SkDrawVerticesCommand::SkDrawVerticesCommand(SkCanvas::VertexMode vmode, int vertexCount, const SkPoint vertices[], const SkPoint texs[], const SkColor colors[], SkXfermode* xfermode, @@ -2690,10 +927,6 @@ void SkRestoreCommand::execute(SkCanvas* canvas) const { canvas->restore(); } -SkRestoreCommand* SkRestoreCommand::fromJSON(Json::Value& command) { - return new SkRestoreCommand(); -} - SkSaveCommand::SkSaveCommand() : INHERITED(kSave_OpType) { } @@ -2702,10 +935,6 @@ void SkSaveCommand::execute(SkCanvas* canvas) const { canvas->save(); } -SkSaveCommand* SkSaveCommand::fromJSON(Json::Value& command) { - return new SkSaveCommand(); -} - SkSaveLayerCommand::SkSaveLayerCommand(const SkCanvas::SaveLayerRec& rec) : INHERITED(kSaveLayer_OpType) { if (rec.fBounds) { @@ -2722,13 +951,6 @@ SkSaveLayerCommand::SkSaveLayerCommand(const SkCanvas::SaveLayerRec& rec) } fSaveLayerFlags = rec.fSaveLayerFlags; - if (rec.fBackdrop) { - fBackdrop = rec.fBackdrop; - fBackdrop->ref(); - } else { - fBackdrop = nullptr; - } - if (rec.fBounds) { fInfo.push(SkObjectParser::RectToString(*rec.fBounds, "Bounds: ")); } @@ -2738,12 +960,6 @@ SkSaveLayerCommand::SkSaveLayerCommand(const SkCanvas::SaveLayerRec& rec) fInfo.push(SkObjectParser::SaveLayerFlagsToString(fSaveLayerFlags)); } -SkSaveLayerCommand::~SkSaveLayerCommand() { - if (fBackdrop != nullptr) { - fBackdrop->unref(); - } -} - void SkSaveLayerCommand::execute(SkCanvas* canvas) const { canvas->saveLayer(SkCanvas::SaveLayerRec(fBounds.isEmpty() ? nullptr : &fBounds, fPaintPtr, @@ -2754,50 +970,6 @@ void SkSaveLayerCommand::vizExecute(SkCanvas* canvas) const { canvas->save(); } -Json::Value SkSaveLayerCommand::toJSON() const { - Json::Value result = INHERITED::toJSON(); - if (!fBounds.isEmpty()) { - result[SKDEBUGCANVAS_ATTRIBUTE_BOUNDS] = make_json_rect(fBounds); - } - if (fPaintPtr != nullptr) { - result[SKDEBUGCANVAS_ATTRIBUTE_PAINT] = make_json_paint(*fPaintPtr, - SKDEBUGCANVAS_SEND_BINARIES); - } - if (fBackdrop != nullptr) { - Json::Value jsonBackdrop; - flatten(fBackdrop, &jsonBackdrop, SKDEBUGCANVAS_SEND_BINARIES); - result[SKDEBUGCANVAS_ATTRIBUTE_BACKDROP] = jsonBackdrop; - } - if (fSaveLayerFlags != 0) { - SkDebugf("unsupported: saveLayer flags\n"); - SkASSERT(false); - } - return result; -} - -SkSaveLayerCommand* SkSaveLayerCommand::fromJSON(Json::Value& command) { - 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], &paint); - rec.fPaint = &paint; - } - if (command.isMember(SKDEBUGCANVAS_ATTRIBUTE_BACKDROP)) { - Json::Value backdrop = command[SKDEBUGCANVAS_ATTRIBUTE_BACKDROP]; - rec.fBackdrop = (SkImageFilter*) load_flattenable(backdrop); - } - SkSaveLayerCommand* result = new SkSaveLayerCommand(rec); - if (rec.fBackdrop != nullptr) { - rec.fBackdrop->unref(); - } - return result; -} - SkSetMatrixCommand::SkSetMatrixCommand(const SkMatrix& matrix) : INHERITED(kSetMatrix_OpType) { fUserMatrix.reset(); @@ -2815,14 +987,3 @@ void SkSetMatrixCommand::execute(SkCanvas* canvas) const { 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); -} diff --git a/tools/debugger/SkDrawCommand.h b/tools/debugger/SkDrawCommand.h index a93461a..f67df92 100644 --- a/tools/debugger/SkDrawCommand.h +++ b/tools/debugger/SkDrawCommand.h @@ -15,7 +15,6 @@ #include "SkRRect.h" #include "SkString.h" #include "SkTDArray.h" -#include "SkJSONCPP.h" class SK_API SkDrawCommand { public: @@ -100,14 +99,6 @@ public: virtual bool render(SkCanvas* canvas) const { return false; } - virtual Json::Value toJSON() const; - - /* Converts a JSON representation of a command into a newly-allocated SkDrawCommand object. It - * is the caller's responsibility to delete this object. This method may return null if an error - * occurs. - */ - static SkDrawCommand* fromJSON(Json::Value& command); - static const char* GetCommandString(OpType type); protected: @@ -123,7 +114,6 @@ public: SkRestoreCommand(); void execute(SkCanvas* canvas) const override; Action action() const override { return kPopLayer_Action; } - static SkRestoreCommand* fromJSON(Json::Value& command); private: typedef SkDrawCommand INHERITED; @@ -133,9 +123,6 @@ class SkClearCommand : public SkDrawCommand { public: SkClearCommand(SkColor color); void execute(SkCanvas* canvas) const override; - Json::Value toJSON() const override; - static SkClearCommand* fromJSON(Json::Value& command); - private: SkColor fColor; @@ -147,9 +134,6 @@ public: SkClipPathCommand(const SkPath& path, SkRegion::Op op, bool doAA); void execute(SkCanvas* canvas) const override; bool render(SkCanvas* canvas) const override; - Json::Value toJSON() const override; - static SkClipPathCommand* fromJSON(Json::Value& command); - private: SkPath fPath; SkRegion::Op fOp; @@ -162,9 +146,6 @@ class SkClipRegionCommand : public SkDrawCommand { public: SkClipRegionCommand(const SkRegion& region, SkRegion::Op op); void execute(SkCanvas* canvas) const override; - Json::Value toJSON() const override; - static SkClipRegionCommand* fromJSON(Json::Value& command); - private: SkRegion fRegion; SkRegion::Op fOp; @@ -176,8 +157,6 @@ class SkClipRectCommand : public SkDrawCommand { public: SkClipRectCommand(const SkRect& rect, SkRegion::Op op, bool doAA); void execute(SkCanvas* canvas) const override; - Json::Value toJSON() const override; - static SkClipRectCommand* fromJSON(Json::Value& command); const SkRect& rect() const { return fRect; } SkRegion::Op op() const { return fOp; } @@ -196,8 +175,6 @@ public: SkClipRRectCommand(const SkRRect& rrect, SkRegion::Op op, bool doAA); void execute(SkCanvas* canvas) const override; bool render(SkCanvas* canvas) const override; - Json::Value toJSON() const override; - static SkClipRRectCommand* fromJSON(Json::Value& command); const SkRRect& rrect() const { return fRRect; } SkRegion::Op op() const { return fOp; } @@ -215,9 +192,6 @@ class SkConcatCommand : public SkDrawCommand { public: SkConcatCommand(const SkMatrix& matrix); void execute(SkCanvas* canvas) const override; - Json::Value toJSON() const override; - static SkConcatCommand* fromJSON(Json::Value& command); - private: SkMatrix fMatrix; @@ -230,9 +204,6 @@ public: const SkPaint* paint); void execute(SkCanvas* canvas) const override; bool render(SkCanvas* canvas) const override; - Json::Value toJSON() const override; - static SkDrawBitmapCommand* fromJSON(Json::Value& command); - private: SkBitmap fBitmap; SkScalar fLeft; @@ -249,9 +220,6 @@ public: const SkRect& dst, const SkPaint* paint); void execute(SkCanvas* canvas) const override; bool render(SkCanvas* canvas) const override; - Json::Value toJSON() const override; - static SkDrawBitmapNineCommand* fromJSON(Json::Value& command); - private: SkBitmap fBitmap; SkIRect fCenter; @@ -269,8 +237,6 @@ public: SkCanvas::SrcRectConstraint); void execute(SkCanvas* canvas) const override; bool render(SkCanvas* canvas) const override; - Json::Value toJSON() const override; - static SkDrawBitmapRectCommand* fromJSON(Json::Value& command); const SkBitmap& bitmap() const { return fBitmap; } @@ -308,9 +274,6 @@ public: SkDrawImageCommand(const SkImage* image, SkScalar left, SkScalar top, const SkPaint* paint); void execute(SkCanvas* canvas) const override; bool render(SkCanvas* canvas) const override; - Json::Value toJSON() const override; - static SkDrawImageCommand* fromJSON(Json::Value& command); - private: SkAutoTUnref fImage; SkScalar fLeft; @@ -326,9 +289,6 @@ public: const SkPaint* paint, SkCanvas::SrcRectConstraint constraint); void execute(SkCanvas* canvas) const override; bool render(SkCanvas* canvas) const override; - Json::Value toJSON() const override; - static SkDrawImageRectCommand* fromJSON(Json::Value& command); - private: SkAutoTUnref fImage; SkTLazy fSrc; @@ -344,9 +304,6 @@ public: SkDrawOvalCommand(const SkRect& oval, const SkPaint& paint); void execute(SkCanvas* canvas) const override; bool render(SkCanvas* canvas) const override; - Json::Value toJSON() const override; - static SkDrawOvalCommand* fromJSON(Json::Value& command); - private: SkRect fOval; SkPaint fPaint; @@ -359,9 +316,6 @@ public: SkDrawPaintCommand(const SkPaint& paint); void execute(SkCanvas* canvas) const override; bool render(SkCanvas* canvas) const override; - Json::Value toJSON() const override; - static SkDrawPaintCommand* fromJSON(Json::Value& command); - private: SkPaint fPaint; @@ -373,8 +327,6 @@ public: SkDrawPathCommand(const SkPath& path, const SkPaint& paint); void execute(SkCanvas* canvas) const override; bool render(SkCanvas* canvas) const override; - Json::Value toJSON() const override; - static SkDrawPathCommand* fromJSON(Json::Value& command); private: SkPath fPath; @@ -419,9 +371,6 @@ public: virtual ~SkDrawPointsCommand() { delete [] fPts; } void execute(SkCanvas* canvas) const override; bool render(SkCanvas* canvas) const override; - Json::Value toJSON() const override; - static SkDrawPointsCommand* fromJSON(Json::Value& command); - private: SkCanvas::PointMode fMode; size_t fCount; @@ -437,9 +386,6 @@ public: const SkPaint& paint); virtual ~SkDrawTextCommand() { delete [] fText; } void execute(SkCanvas* canvas) const override; - Json::Value toJSON() const override; - static SkDrawTextCommand* fromJSON(Json::Value& command); - private: char* fText; size_t fByteLength; @@ -456,9 +402,6 @@ public: const SkPaint& paint); virtual ~SkDrawPosTextCommand() { delete [] fPos; delete [] fText; } void execute(SkCanvas* canvas) const override; - Json::Value toJSON() const override; - static SkDrawPosTextCommand* fromJSON(Json::Value& command); - private: char* fText; size_t fByteLength; @@ -474,9 +417,6 @@ public: const SkMatrix* matrix, const SkPaint& paint); virtual ~SkDrawTextOnPathCommand() { delete [] fText; } void execute(SkCanvas* canvas) const override; - Json::Value toJSON() const override; - static SkDrawTextOnPathCommand* fromJSON(Json::Value& command); - private: char* fText; size_t fByteLength; @@ -493,7 +433,6 @@ public: SkScalar constY, const SkPaint& paint); virtual ~SkDrawPosTextHCommand() { delete [] fXpos; delete [] fText; } void execute(SkCanvas* canvas) const override; - private: SkScalar* fXpos; char* fText; @@ -510,8 +449,6 @@ public: void execute(SkCanvas* canvas) const override; bool render(SkCanvas* canvas) const override; - Json::Value toJSON() const override; - static SkDrawTextBlobCommand* fromJSON(Json::Value& command); private: SkAutoTUnref fBlob; @@ -544,8 +481,6 @@ class SkDrawRectCommand : public SkDrawCommand { public: SkDrawRectCommand(const SkRect& rect, const SkPaint& paint); void execute(SkCanvas* canvas) const override; - Json::Value toJSON() const override; - static SkDrawRectCommand* fromJSON(Json::Value& command); const SkRect& rect() const { return fRect; } const SkPaint& paint() const { return fPaint; } @@ -561,9 +496,6 @@ public: SkDrawRRectCommand(const SkRRect& rrect, const SkPaint& paint); void execute(SkCanvas* canvas) const override; bool render(SkCanvas* canvas) const override; - Json::Value toJSON() const override; - static SkDrawRRectCommand* fromJSON(Json::Value& command); - private: SkRRect fRRect; SkPaint fPaint; @@ -577,9 +509,6 @@ public: const SkPaint& paint); void execute(SkCanvas* canvas) const override; bool render(SkCanvas* canvas) const override; - Json::Value toJSON() const override; - static SkDrawDRRectCommand* fromJSON(Json::Value& command); - private: SkRRect fOuter; SkRRect fInner; @@ -597,7 +526,6 @@ public: const SkPaint& paint); virtual ~SkDrawVerticesCommand(); void execute(SkCanvas* canvas) const override; - private: SkCanvas::VertexMode fVmode; int fVertexCount; @@ -617,8 +545,6 @@ public: SkSaveCommand(); void execute(SkCanvas* canvas) const override; Action action() const override { return kPushLayer_Action; } - static SkSaveCommand* fromJSON(Json::Value& command); - private: typedef SkDrawCommand INHERITED; }; @@ -626,10 +552,7 @@ private: class SkSaveLayerCommand : public SkDrawCommand { public: SkSaveLayerCommand(const SkCanvas::SaveLayerRec&); - virtual ~SkSaveLayerCommand(); void execute(SkCanvas* canvas) const override; - Json::Value toJSON() const override; - static SkSaveLayerCommand* fromJSON(Json::Value& command); void vizExecute(SkCanvas* canvas) const override; Action action() const override{ return kPushLayer_Action; } void setActive(bool active) override { fActive = active; } @@ -638,11 +561,10 @@ public: const SkPaint* paint() const { return fPaintPtr; } private: - SkRect fBounds; - SkPaint fPaint; - SkPaint* fPaintPtr; - const SkImageFilter* fBackdrop; - uint32_t fSaveLayerFlags; + SkRect fBounds; + SkPaint fPaint; + SkPaint* fPaintPtr; + uint32_t fSaveLayerFlags; bool fActive; @@ -654,9 +576,6 @@ public: SkSetMatrixCommand(const SkMatrix& matrix); void setUserMatrix(const SkMatrix&) override; void execute(SkCanvas* canvas) const override; - Json::Value toJSON() const override; - static SkSetMatrixCommand* fromJSON(Json::Value& command); - private: SkMatrix fUserMatrix; SkMatrix fMatrix; diff --git a/tools/debugger/SkObjectParser.cpp b/tools/debugger/SkObjectParser.cpp index 5f3fa44..6d71a38 100644 --- a/tools/debugger/SkObjectParser.cpp +++ b/tools/debugger/SkObjectParser.cpp @@ -26,12 +26,11 @@ SkString* SkObjectParser::BitmapToString(const SkBitmap& bitmap) { mBitmap->appendS32(bitmap.width()); mBitmap->append(" H: "); mBitmap->appendS32(bitmap.height()); - + const char* gColorTypeStrings[] = { - "None", "A8", "565", "4444", "RGBA", "BGRA", "Index8", "G8", "RGBAf16" + "None", "A8", "565", "4444", "RGBA", "BGRA", "Index8", "G8" }; - static_assert(kLastEnum_SkColorType + 1 == SK_ARRAY_COUNT(gColorTypeStrings), - "colortype names do not match colortype enum"); + SkASSERT(kLastEnum_SkColorType + 1 == SK_ARRAY_COUNT(gColorTypeStrings)); mBitmap->append(" ColorType: "); mBitmap->append(gColorTypeStrings[bitmap.colorType()]); -- 2.7.4