/*

 * 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 "tools/debugger/DrawCommand.h"

#include "include/core/SkAlphaType.h"

#include "include/core/SkBitmap.h"

#include "include/core/SkBlendMode.h"

#include "include/core/SkBlurTypes.h"

#include "include/core/SkClipOp.h"

#include "include/core/SkColorFilter.h"

#include "include/core/SkColorType.h"

#include "include/core/SkDrawable.h"

#include "include/core/SkFlattenable.h"

#include "include/core/SkFont.h"

#include "include/core/SkFontTypes.h"

#include "include/core/SkImageFilter.h"

#include "include/core/SkImageInfo.h"

#include "include/core/SkMaskFilter.h"

#include "include/core/SkPathEffect.h"

#include "include/core/SkPathTypes.h"

#include "include/core/SkPicture.h"

#include "include/core/SkPixmap.h"

#include "include/core/SkPoint3.h"

#include "include/core/SkRSXform.h"

#include "include/core/SkSamplingOptions.h"

#include "include/core/SkSize.h"

#include "include/core/SkStream.h"

#include "include/core/SkTypeface.h"

#include "include/encode/SkPngEncoder.h"

#include "include/private/base/SkDebug.h"

#include "include/private/base/SkMalloc.h"

#include "include/private/base/SkTo.h"

#include "include/private/gpu/ganesh/GrImageContext.h"

#include "include/utils/SkShadowUtils.h"

#include "src/base/SkAutoMalloc.h"

#include "src/core/SkCanvasPriv.h"

#include "src/core/SkFontPriv.h"

#include "src/core/SkMaskFilterBase.h"

#include "src/core/SkPaintDefaults.h"

#include "src/core/SkRectPriv.h"

#include "src/core/SkTextBlobPriv.h"

#include "src/core/SkWriteBuffer.h"

#include "src/image/SkImage_Base.h"

#include "src/utils/SkJSONWriter.h"

#include "tools/UrlDataManager.h"

#include "tools/debugger/DebugLayerManager.h"

#include "tools/debugger/JsonWriteBuffer.h"

#include <algorithm>

#include <cstring>

#include <utility>

class GrDirectContext;

#if defined(SK_GANESH)

#include "include/gpu/GrRecordingContext.h"

#endif

#define DEBUGCANVAS_ATTRIBUTE_DUMP "dump"

#define DEBUGCANVAS_ATTRIBUTE_COMMAND "command"

#define DEBUGCANVAS_ATTRIBUTE_VISIBLE "visible"

#define DEBUGCANVAS_ATTRIBUTE_MATRIX "matrix"

#define DEBUGCANVAS_ATTRIBUTE_DRAWDEPTHTRANS "drawDepthTranslation"

#define DEBUGCANVAS_ATTRIBUTE_COORDS "coords"

#define DEBUGCANVAS_ATTRIBUTE_EDGING "edging"

#define DEBUGCANVAS_ATTRIBUTE_HINTING "hinting"

#define DEBUGCANVAS_ATTRIBUTE_BOUNDS "bounds"

#define DEBUGCANVAS_ATTRIBUTE_PAINT "paint"

#define DEBUGCANVAS_ATTRIBUTE_OUTER "outer"

#define DEBUGCANVAS_ATTRIBUTE_INNER "inner"

#define DEBUGCANVAS_ATTRIBUTE_MODE "mode"

#define DEBUGCANVAS_ATTRIBUTE_POINTS "points"

#define DEBUGCANVAS_ATTRIBUTE_PATH "path"

#define DEBUGCANVAS_ATTRIBUTE_CLUSTERS "clusters"

#define DEBUGCANVAS_ATTRIBUTE_TEXT "text"

#define DEBUGCANVAS_ATTRIBUTE_COLOR "color"

#define DEBUGCANVAS_ATTRIBUTE_ALPHA "alpha"

#define DEBUGCANVAS_ATTRIBUTE_BLENDMODE "blendMode"

#define DEBUGCANVAS_ATTRIBUTE_SAMPLING "sampling"

#define DEBUGCANVAS_ATTRIBUTE_STYLE "style"

#define DEBUGCANVAS_ATTRIBUTE_STROKEWIDTH "strokeWidth"

#define DEBUGCANVAS_ATTRIBUTE_STROKEMITER "strokeMiter"

#define DEBUGCANVAS_ATTRIBUTE_STROKEJOIN "strokeJoin"

#define DEBUGCANVAS_ATTRIBUTE_CAP "cap"

#define DEBUGCANVAS_ATTRIBUTE_ANTIALIAS "antiAlias"

#define DEBUGCANVAS_ATTRIBUTE_DITHER "dither"

#define DEBUGCANVAS_ATTRIBUTE_FAKEBOLDTEXT "fakeBoldText"

#define DEBUGCANVAS_ATTRIBUTE_LINEARTEXT "linearText"

#define DEBUGCANVAS_ATTRIBUTE_SUBPIXELTEXT "subpixelText"

#define DEBUGCANVAS_ATTRIBUTE_DEVKERNTEXT "devKernText"

#define DEBUGCANVAS_ATTRIBUTE_LCDRENDERTEXT "lcdRenderText"

#define DEBUGCANVAS_ATTRIBUTE_EMBEDDEDBITMAPTEXT "embeddedBitmapText"

#define DEBUGCANVAS_ATTRIBUTE_AUTOHINTING "forceAutoHinting"

#define DEBUGCANVAS_ATTRIBUTE_REGION "region"

#define DEBUGCANVAS_ATTRIBUTE_REGIONOP "op"

#define DEBUGCANVAS_ATTRIBUTE_EDGESTYLE "edgeStyle"

#define DEBUGCANVAS_ATTRIBUTE_DEVICEREGION "deviceRegion"

#define DEBUGCANVAS_ATTRIBUTE_BLUR "blur"

#define DEBUGCANVAS_ATTRIBUTE_SIGMA "sigma"

#define DEBUGCANVAS_ATTRIBUTE_QUALITY "quality"

#define DEBUGCANVAS_ATTRIBUTE_TEXTSIZE "textSize"

#define DEBUGCANVAS_ATTRIBUTE_TEXTSCALEX "textScaleX"

#define DEBUGCANVAS_ATTRIBUTE_TEXTSKEWX "textSkewX"

#define DEBUGCANVAS_ATTRIBUTE_DASHING "dashing"

#define DEBUGCANVAS_ATTRIBUTE_INTERVALS "intervals"

#define DEBUGCANVAS_ATTRIBUTE_PHASE "phase"

#define DEBUGCANVAS_ATTRIBUTE_FILLTYPE "fillType"

#define DEBUGCANVAS_ATTRIBUTE_VERBS "verbs"

#define DEBUGCANVAS_ATTRIBUTE_NAME "name"

#define DEBUGCANVAS_ATTRIBUTE_DATA "data"

#define DEBUGCANVAS_ATTRIBUTE_VALUES "values"

#define DEBUGCANVAS_ATTRIBUTE_SHADER "shader"

#define DEBUGCANVAS_ATTRIBUTE_PATHEFFECT "pathEffect"

#define DEBUGCANVAS_ATTRIBUTE_MASKFILTER "maskFilter"

#define DEBUGCANVAS_ATTRIBUTE_XFERMODE "xfermode"

#define DEBUGCANVAS_ATTRIBUTE_BACKDROP "backdrop"

#define DEBUGCANVAS_ATTRIBUTE_COLORFILTER "colorfilter"

#define DEBUGCANVAS_ATTRIBUTE_IMAGEFILTER "imagefilter"

#define DEBUGCANVAS_ATTRIBUTE_IMAGE "image"

#define DEBUGCANVAS_ATTRIBUTE_IMAGE_INDEX "imageIndex"

#define DEBUGCANVAS_ATTRIBUTE_BITMAP "bitmap"

#define DEBUGCANVAS_ATTRIBUTE_SRC "src"

#define DEBUGCANVAS_ATTRIBUTE_DST "dst"

#define DEBUGCANVAS_ATTRIBUTE_CENTER "center"

#define DEBUGCANVAS_ATTRIBUTE_STRICT "strict"

#define DEBUGCANVAS_ATTRIBUTE_DESCRIPTION "description"

#define DEBUGCANVAS_ATTRIBUTE_X "x"

#define DEBUGCANVAS_ATTRIBUTE_Y "y"

#define DEBUGCANVAS_ATTRIBUTE_RUNS "runs"

#define DEBUGCANVAS_ATTRIBUTE_POSITIONS "positions"

#define DEBUGCANVAS_ATTRIBUTE_GLYPHS "glyphs"

#define DEBUGCANVAS_ATTRIBUTE_FONT "font"

#define DEBUGCANVAS_ATTRIBUTE_TYPEFACE "typeface"

#define DEBUGCANVAS_ATTRIBUTE_CUBICS "cubics"

#define DEBUGCANVAS_ATTRIBUTE_COLORS "colors"

#define DEBUGCANVAS_ATTRIBUTE_TEXTURECOORDS "textureCoords"

#define DEBUGCANVAS_ATTRIBUTE_STARTANGLE "startAngle"

#define DEBUGCANVAS_ATTRIBUTE_SWEEPANGLE "sweepAngle"

#define DEBUGCANVAS_ATTRIBUTE_USECENTER "useCenter"

#define DEBUGCANVAS_ATTRIBUTE_SHORTDESC "shortDesc"

#define DEBUGCANVAS_ATTRIBUTE_UNIQUE_ID "uniqueID"

#define DEBUGCANVAS_ATTRIBUTE_WIDTH "width"

#define DEBUGCANVAS_ATTRIBUTE_HEIGHT "height"

#define DEBUGCANVAS_ATTRIBUTE_ALPHA "alpha"

#define DEBUGCANVAS_ATTRIBUTE_LATTICE "lattice"

#define DEBUGCANVAS_ATTRIBUTE_LATTICEXCOUNT "xCount"

#define DEBUGCANVAS_ATTRIBUTE_LATTICEYCOUNT "yCount"

#define DEBUGCANVAS_ATTRIBUTE_LATTICEXDIVS "xDivs"

#define DEBUGCANVAS_ATTRIBUTE_LATTICEYDIVS "yDivs"

#define DEBUGCANVAS_ATTRIBUTE_LATTICEFLAGS "flags"

#define DEBUGCANVAS_ATTRIBUTE_ZPLANE "zPlane"

#define DEBUGCANVAS_ATTRIBUTE_LIGHTPOSITION "lightPositions"

#define DEBUGCANVAS_ATTRIBUTE_AMBIENTCOLOR "ambientColor"

#define DEBUGCANVAS_ATTRIBUTE_SPOTCOLOR "spotColor"

#define DEBUGCANVAS_ATTRIBUTE_LIGHTRADIUS "lightRadius"

#define DEBUGCANVAS_ATTRIBUTE_LAYERNODEID "layerNodeId"

#define DEBUGCANVAS_VERB_MOVE "move"

#define DEBUGCANVAS_VERB_LINE "line"

#define DEBUGCANVAS_VERB_QUAD "quad"

#define DEBUGCANVAS_VERB_CUBIC "cubic"

#define DEBUGCANVAS_VERB_CONIC "conic"

#define DEBUGCANVAS_VERB_CLOSE "close"

#define DEBUGCANVAS_STYLE_FILL "fill"

#define DEBUGCANVAS_STYLE_STROKE "stroke"

#define DEBUGCANVAS_STYLE_STROKEANDFILL "strokeAndFill"

#define DEBUGCANVAS_POINTMODE_POINTS "points"

#define DEBUGCANVAS_POINTMODE_LINES "lines"

#define DEBUGCANVAS_POINTMODE_POLYGON "polygon"

#define DEBUGCANVAS_CLIPOP_DIFFERENCE "difference"

#define DEBUGCANVAS_CLIPOP_INTERSECT "intersect"

#define DEBUGCANVAS_BLURSTYLE_NORMAL "normal"

#define DEBUGCANVAS_BLURSTYLE_SOLID "solid"

#define DEBUGCANVAS_BLURSTYLE_OUTER "outer"

#define DEBUGCANVAS_BLURSTYLE_INNER "inner"

#define DEBUGCANVAS_BLURQUALITY_LOW "low"

#define DEBUGCANVAS_BLURQUALITY_HIGH "high"

#define DEBUGCANVAS_FILLTYPE_WINDING "winding"

#define DEBUGCANVAS_FILLTYPE_EVENODD "evenOdd"

#define DEBUGCANVAS_FILLTYPE_INVERSEWINDING "inverseWinding"

#define DEBUGCANVAS_FILLTYPE_INVERSEEVENODD "inverseEvenOdd"

#define DEBUGCANVAS_CAP_BUTT "butt"

#define DEBUGCANVAS_CAP_ROUND "round"

#define DEBUGCANVAS_CAP_SQUARE "square"

#define DEBUGCANVAS_MITER_JOIN "miter"

#define DEBUGCANVAS_ROUND_JOIN "round"

#define DEBUGCANVAS_BEVEL_JOIN "bevel"

#define DEBUGCANVAS_COLORTYPE_ARGB4444 "ARGB4444"

#define DEBUGCANVAS_COLORTYPE_RGBA8888 "RGBA8888"

#define DEBUGCANVAS_COLORTYPE_BGRA8888 "BGRA8888"

#define DEBUGCANVAS_COLORTYPE_565 "565"

#define DEBUGCANVAS_COLORTYPE_GRAY8 "Gray8"

#define DEBUGCANVAS_COLORTYPE_INDEX8 "Index8"

#define DEBUGCANVAS_COLORTYPE_ALPHA8 "Alpha8"

#define DEBUGCANVAS_ALPHATYPE_OPAQUE "opaque"

#define DEBUGCANVAS_ALPHATYPE_PREMUL "premul"

#define DEBUGCANVAS_ALPHATYPE_UNPREMUL "unpremul"

#define DEBUGCANVAS_ALPHATYPE_UNKNOWN "unknown"

#define DEBUGCANVAS_HINTING_NONE "none"

#define DEBUGCANVAS_HINTING_SLIGHT "slight"

#define DEBUGCANVAS_HINTING_NORMAL "normal"

#define DEBUGCANVAS_HINTING_FULL "full"

#define DEBUGCANVAS_EDGING_ALIAS "alias"

#define DEBUGCANVAS_EDGING_ANTIALIAS "antialias"

#define DEBUGCANVAS_EDGING_SUBPIXELANTIALIAS "subpixelantialias"

#define DEBUGCANVAS_SHADOWFLAG_TRANSPARENT_OCC "transparentOccluder"

#define DEBUGCANVAS_SHADOWFLAG_GEOMETRIC_ONLY "geometricOnly"

static SkString* str_append(SkString* str, const SkRect& r) {

    str->appendf(" [%g %g %g %g]", r.left(), r.top(), r.right(), r.bottom());

    return str;

}

DrawCommand::DrawCommand(OpType type) : fOpType(type), fVisible(true) {}

const char* DrawCommand::GetCommandString(OpType type) {

    switch (type) {

        case kBeginDrawPicture_OpType: return "BeginDrawPicture";

        case kClear_OpType: return "DrawClear";

        case kClipPath_OpType: return "ClipPath";

        case kClipRegion_OpType: return "ClipRegion";

        case kClipRect_OpType: return "ClipRect";

        case kClipRRect_OpType: return "ClipRRect";

        case kResetClip_OpType: return "ResetClip";

        case kConcat_OpType: return "Concat";

        case kConcat44_OpType: return "Concat44";

        case kDrawAnnotation_OpType: return "DrawAnnotation";

        case kDrawBitmap_OpType: return "DrawBitmap";

        case kDrawBitmapRect_OpType: return "DrawBitmapRect";

        case kDrawDRRect_OpType: return "DrawDRRect";

        case kDrawImage_OpType: return "DrawImage";

        case kDrawImageLattice_OpType: return "DrawImageLattice";

        case kDrawImageRect_OpType: return "DrawImageRect";

        case kDrawImageRectLayer_OpType: return "DrawImageRectLayer";

        case kDrawOval_OpType: return "DrawOval";

        case kDrawPaint_OpType: return "DrawPaint";

        case kDrawPatch_OpType: return "DrawPatch";

        case kDrawPath_OpType: return "DrawPath";

        case kDrawArc_OpType: return "DrawArc";

        case kDrawPoints_OpType: return "DrawPoints";

        case kDrawRect_OpType: return "DrawRect";

        case kDrawRRect_OpType: return "DrawRRect";

        case kDrawRegion_OpType: return "DrawRegion";

        case kDrawShadow_OpType: return "DrawShadow";

        case kDrawTextBlob_OpType: return "DrawTextBlob";

        case kDrawVertices_OpType: return "DrawVertices";

        case kDrawAtlas_OpType: return "DrawAtlas";

        case kDrawDrawable_OpType: return "DrawDrawable";

        case kDrawEdgeAAQuad_OpType: return "DrawEdgeAAQuad";

        case kDrawEdgeAAImageSet_OpType: return "DrawEdgeAAImageSet";

        case kEndDrawPicture_OpType: return "EndDrawPicture";

        case kRestore_OpType: return "Restore";

        case kSave_OpType: return "Save";

        case kSaveLayer_OpType: return "SaveLayer";

        case kSetMatrix_OpType: return "SetMatrix";

        case kSetM44_OpType: return "SetM44";

        default:

            SkDebugf("OpType error 0x%08x\n", type);

            SkASSERT(0);

            break;

    }

    SkDEBUGFAIL("DrawType UNUSED\n");

    return nullptr;

}

Unexecuted instantiation: DrawCommand::GetCommandString(DrawCommand::OpType)

Unexecuted instantiation: DrawCommand::GetCommandString(DrawCommand::OpType)

void DrawCommand::toJSON(SkJSONWriter& writer, UrlDataManager& urlDataManager) const {

    writer.appendCString(DEBUGCANVAS_ATTRIBUTE_COMMAND, this->GetCommandString(fOpType));

    writer.appendBool(DEBUGCANVAS_ATTRIBUTE_VISIBLE, this->isVisible());

}

namespace {

void xlate_and_scale_to_bounds(SkCanvas* canvas, const SkRect& bounds) {

    const SkISize& size = canvas->getBaseLayerSize();

    static const SkScalar kInsetFrac = 0.9f;  // Leave a border around object

    canvas->translate(size.fWidth / 2.0f, size.fHeight / 2.0f);

    if (bounds.width() > bounds.height()) {

        canvas->scale(SkDoubleToScalar((kInsetFrac * size.fWidth) / bounds.width()),

                      SkDoubleToScalar((kInsetFrac * size.fHeight) / bounds.width()));

    } else {

        canvas->scale(SkDoubleToScalar((kInsetFrac * size.fWidth) / bounds.height()),

                      SkDoubleToScalar((kInsetFrac * size.fHeight) / bounds.height()));

    }

    canvas->translate(-bounds.centerX(), -bounds.centerY());

}

void render_path(SkCanvas* canvas, const SkPath& path) {

    canvas->clear(0xFFFFFFFF);

    const SkRect& bounds = path.getBounds();

    if (bounds.isEmpty()) {

        return;

    }

    SkAutoCanvasRestore acr(canvas, true);

    xlate_and_scale_to_bounds(canvas, bounds);

    SkPaint p;

    p.setColor(SK_ColorBLACK);

    p.setStyle(SkPaint::kStroke_Style);

    canvas->drawPath(path, p);

}

void render_region(SkCanvas* canvas, const SkRegion& region) {

    canvas->clear(0xFFFFFFFF);

    const SkIRect& bounds = region.getBounds();

    if (bounds.isEmpty()) {

        return;

    }

    SkAutoCanvasRestore acr(canvas, true);

    xlate_and_scale_to_bounds(canvas, SkRect::Make(bounds));

    SkPaint p;

    p.setColor(SK_ColorBLACK);

    p.setStyle(SkPaint::kStroke_Style);

    canvas->drawRegion(region, p);

}

void render_rrect(SkCanvas* canvas, const SkRRect& rrect) {

    canvas->clear(0xFFFFFFFF);

    canvas->save();

    const SkRect& bounds = rrect.getBounds();

    xlate_and_scale_to_bounds(canvas, bounds);

    SkPaint p;

    p.setColor(SK_ColorBLACK);

    p.setStyle(SkPaint::kStroke_Style);

    canvas->drawRRect(rrect, p);

    canvas->restore();

}

void render_drrect(SkCanvas* canvas, const SkRRect& outer, const SkRRect& inner) {

    canvas->clear(0xFFFFFFFF);

    canvas->save();

    const SkRect& bounds = outer.getBounds();

    xlate_and_scale_to_bounds(canvas, bounds);

    SkPaint p;

    p.setColor(SK_ColorBLACK);

    p.setStyle(SkPaint::kStroke_Style);

    canvas->drawDRRect(outer, inner, p);

    canvas->restore();

}

void render_shadow(SkCanvas* canvas, const SkPath& path, SkDrawShadowRec rec) {

    canvas->clear(0xFFFFFFFF);

    const SkRect& bounds = path.getBounds();

    if (bounds.isEmpty()) {

        return;

    }

    SkAutoCanvasRestore acr(canvas, true);

    xlate_and_scale_to_bounds(canvas, bounds);

    rec.fAmbientColor = SK_ColorBLACK;

    rec.fSpotColor    = SK_ColorBLACK;

    canvas->private_draw_shadow_rec(path, rec);

}

void apply_paint_blend_mode(const SkPaint& paint, SkJSONWriter& writer) {

    const auto mode = paint.getBlendMode_or(SkBlendMode::kSrcOver);

    if (mode != SkBlendMode::kSrcOver) {

        writer.appendCString(DEBUGCANVAS_ATTRIBUTE_BLENDMODE, SkBlendMode_Name(mode));

    }

}

}  // namespace

void DrawCommand::MakeJsonColor(SkJSONWriter& writer, const SkColor color) {

    writer.beginArray(nullptr, false);

    writer.appendS32(SkColorGetA(color));

    writer.appendS32(SkColorGetR(color));

    writer.appendS32(SkColorGetG(color));

    writer.appendS32(SkColorGetB(color));

    writer.endArray();

}

void DrawCommand::MakeJsonColor4f(SkJSONWriter& writer, const SkColor4f& color) {

    writer.beginArray(nullptr, false);

    writer.appendFloat(color.fA);

    writer.appendFloat(color.fR);

    writer.appendFloat(color.fG);

    writer.appendFloat(color.fB);

    writer.endArray();

}

void DrawCommand::MakeJsonPoint(SkJSONWriter& writer, const SkPoint& point) {

    writer.beginArray(nullptr, false);

    writer.appendFloat(point.x());

    writer.appendFloat(point.y());

    writer.endArray();

}

void DrawCommand::MakeJsonPoint(SkJSONWriter& writer, SkScalar x, SkScalar y) {

    writer.beginArray(nullptr, false);

    writer.appendFloat(x);

    writer.appendFloat(y);

    writer.endArray();

}

void DrawCommand::MakeJsonPoint3(SkJSONWriter& writer, const SkPoint3& point) {

    writer.beginArray(nullptr, false);

    writer.appendFloat(point.x());

    writer.appendFloat(point.y());

    writer.appendFloat(point.z());

    writer.endArray();

}

void DrawCommand::MakeJsonRect(SkJSONWriter& writer, const SkRect& rect) {

    writer.beginArray(nullptr, false);

    writer.appendFloat(rect.left());

    writer.appendFloat(rect.top());

    writer.appendFloat(rect.right());

    writer.appendFloat(rect.bottom());

    writer.endArray();

}

void DrawCommand::MakeJsonIRect(SkJSONWriter& writer, const SkIRect& rect) {

    writer.beginArray(nullptr, false);

    writer.appendS32(rect.left());

    writer.appendS32(rect.top());

    writer.appendS32(rect.right());

    writer.appendS32(rect.bottom());

    writer.endArray();

}

static void make_json_rrect(SkJSONWriter& writer, const SkRRect& rrect) {

    writer.beginArray(nullptr, false);

    DrawCommand::MakeJsonRect(writer, rrect.rect());

    DrawCommand::MakeJsonPoint(writer, rrect.radii(SkRRect::kUpperLeft_Corner));

    DrawCommand::MakeJsonPoint(writer, rrect.radii(SkRRect::kUpperRight_Corner));

    DrawCommand::MakeJsonPoint(writer, rrect.radii(SkRRect::kLowerRight_Corner));

    DrawCommand::MakeJsonPoint(writer, rrect.radii(SkRRect::kLowerLeft_Corner));

    writer.endArray();

}

void DrawCommand::MakeJsonMatrix(SkJSONWriter& writer, const SkMatrix& matrix) {

    writer.beginArray();

    for (int r = 0; r < 3; ++r) {

        writer.beginArray(nullptr, false);

        for (int c = 0; c < 3; ++c) {

            writer.appendFloat(matrix[r * 3 + c]);

        }

        writer.endArray();

    }

    writer.endArray();

}

void DrawCommand::MakeJsonMatrix44(SkJSONWriter& writer, const SkM44& matrix) {

    writer.beginArray();

    for (int r = 0; r < 4; ++r) {

        writer.beginArray(nullptr, false);

        for (int c = 0; c < 4; ++c) {

            writer.appendFloat(matrix.rc(r, c));

        }

        writer.endArray();

    }

    writer.endArray();

}

void DrawCommand::MakeJsonPath(SkJSONWriter& writer, const SkPath& path) {

    writer.beginObject();

    SkDynamicMemoryWStream wstream;

    path.dump(&wstream, false);

    auto data = wstream.detachAsData();

    writer.appendString(DEBUGCANVAS_ATTRIBUTE_DUMP,

                        static_cast<const char*>(data->data()), data->size());

    switch (path.getFillType()) {

        case SkPathFillType::kWinding:

            writer.appendNString(DEBUGCANVAS_ATTRIBUTE_FILLTYPE, DEBUGCANVAS_FILLTYPE_WINDING);

            break;

        case SkPathFillType::kEvenOdd:

            writer.appendNString(DEBUGCANVAS_ATTRIBUTE_FILLTYPE, DEBUGCANVAS_FILLTYPE_EVENODD);

            break;

        case SkPathFillType::kInverseWinding:

            writer.appendNString(DEBUGCANVAS_ATTRIBUTE_FILLTYPE,

                                 DEBUGCANVAS_FILLTYPE_INVERSEWINDING);

            break;

        case SkPathFillType::kInverseEvenOdd:

            writer.appendNString(DEBUGCANVAS_ATTRIBUTE_FILLTYPE,

                                 DEBUGCANVAS_FILLTYPE_INVERSEEVENODD);

            break;

    }

    writer.beginArray(DEBUGCANVAS_ATTRIBUTE_VERBS);

    SkPath::Iter iter(path, false);

    SkPoint      pts[4];

    SkPath::Verb verb;

    while ((verb = iter.next(pts)) != SkPath::kDone_Verb) {

        if (verb == SkPath::kClose_Verb) {

            writer.appendNString(DEBUGCANVAS_VERB_CLOSE);

            continue;

        }

        writer.beginObject();  // verb

        switch (verb) {

            case SkPath::kLine_Verb: {

                writer.appendName(DEBUGCANVAS_VERB_LINE);

                MakeJsonPoint(writer, pts[1]);

                break;

            }

            case SkPath::kQuad_Verb: {

                writer.beginArray(DEBUGCANVAS_VERB_QUAD);

                MakeJsonPoint(writer, pts[1]);

                MakeJsonPoint(writer, pts[2]);

                writer.endArray();  // quad coords

                break;

            }

            case SkPath::kCubic_Verb: {

                writer.beginArray(DEBUGCANVAS_VERB_CUBIC);

                MakeJsonPoint(writer, pts[1]);

                MakeJsonPoint(writer, pts[2]);

                MakeJsonPoint(writer, pts[3]);

                writer.endArray();  // cubic coords

                break;

            }

            case SkPath::kConic_Verb: {

                writer.beginArray(DEBUGCANVAS_VERB_CONIC);

                MakeJsonPoint(writer, pts[1]);

                MakeJsonPoint(writer, pts[2]);

                writer.appendFloat(iter.conicWeight());

                writer.endArray();  // conic coords

                break;

            }

            case SkPath::kMove_Verb: {

                writer.appendName(DEBUGCANVAS_VERB_MOVE);

                MakeJsonPoint(writer, pts[0]);

                break;

            }

            case SkPath::kClose_Verb:

            case SkPath::kDone_Verb:

                // Unreachable

                break;

        }

        writer.endObject();  // verb

    }

    writer.endArray();   // verbs

    writer.endObject();  // path

}

void DrawCommand::MakeJsonRegion(SkJSONWriter& writer, const SkRegion& region) {

    // TODO: Actually serialize the rectangles, rather than just devolving to path

    SkPath path;

    region.getBoundaryPath(&path);

    MakeJsonPath(writer, path);

}

void DrawCommand::MakeJsonSampling(SkJSONWriter& writer, const SkSamplingOptions& sampling) {

    writer.beginObject();

    writer.appendS32("maxAniso", sampling.maxAniso);

    writer.appendBool("useCubic", sampling.useCubic);

    writer.appendS32("filter", (int)sampling.filter);

    writer.appendS32("mipmap", (int)sampling.mipmap);

    writer.appendFloat("cubic.B", sampling.cubic.B);

    writer.appendFloat("cubic.C", sampling.cubic.C);

    writer.endObject();

}

static const char* clipop_name(SkClipOp op) {

    switch (op) {

        case SkClipOp::kDifference: return DEBUGCANVAS_CLIPOP_DIFFERENCE;

        case SkClipOp::kIntersect: return DEBUGCANVAS_CLIPOP_INTERSECT;

        default: SkASSERT(false); return "<invalid region op>";

    }

}

Unexecuted instantiation: DrawCommand.cpp:clipop_name(SkClipOp)

Unexecuted instantiation: DrawCommand.cpp:clipop_name(SkClipOp)

static const char* pointmode_name(SkCanvas::PointMode mode) {

    switch (mode) {

        case SkCanvas::kPoints_PointMode: return DEBUGCANVAS_POINTMODE_POINTS;

        case SkCanvas::kLines_PointMode: return DEBUGCANVAS_POINTMODE_LINES;

        case SkCanvas::kPolygon_PointMode: return DEBUGCANVAS_POINTMODE_POLYGON;

        default: SkASSERT(false); return "<invalid point mode>";

    }

}

Unexecuted instantiation: DrawCommand.cpp:pointmode_name(SkCanvas::PointMode)

Unexecuted instantiation: DrawCommand.cpp:pointmode_name(SkCanvas::PointMode)

static void store_scalar(SkJSONWriter& writer,

                         const char*   key,

                         SkScalar      value,

                         SkScalar      defaultValue) {

    if (value != defaultValue) {

        writer.appendFloat(key, value);

    }

}

static void store_bool(SkJSONWriter& writer, const char* key, bool value, bool defaultValue) {

    if (value != defaultValue) {

        writer.appendBool(key, value);

    }

}

static SkString encode_data(const void*     bytes,

                            size_t          count,

                            const char*     contentType,

                            UrlDataManager& urlDataManager) {

    sk_sp<SkData> data(SkData::MakeWithCopy(bytes, count));

    return urlDataManager.addData(data.get(), contentType);

}

void DrawCommand::flatten(const SkFlattenable* flattenable,

                          SkJSONWriter&        writer,

                          UrlDataManager&      urlDataManager) {

    SkBinaryWriteBuffer buffer({});  // TODO(kjlubick, bungeman) feed SkSerialProcs through API

    flattenable->flatten(buffer);

    void* data = sk_malloc_throw(buffer.bytesWritten());

    buffer.writeToMemory(data);

    SkString url =

            encode_data(data, buffer.bytesWritten(), "application/octet-stream", urlDataManager);

    writer.appendCString(DEBUGCANVAS_ATTRIBUTE_NAME, flattenable->getTypeName());

    writer.appendString(DEBUGCANVAS_ATTRIBUTE_DATA, url);

    writer.beginObject(DEBUGCANVAS_ATTRIBUTE_VALUES);

    JsonWriteBuffer jsonBuffer(&writer, &urlDataManager);

    flattenable->flatten(jsonBuffer);

    writer.endObject();  // values

    sk_free(data);

}

void DrawCommand::WritePNG(const SkBitmap& bitmap, SkWStream& out) {

    SkPixmap pm;

    SkAssertResult(bitmap.peekPixels(&pm));

    SkPngEncoder::Options options;

    options.fZLibLevel   = 1;

    options.fFilterFlags = SkPngEncoder::FilterFlag::kNone;

    SkPngEncoder::Encode(&out, pm, options);

}

Unexecuted instantiation: DrawCommand::WritePNG(SkBitmap const&, SkWStream&)

Unexecuted instantiation: DrawCommand::WritePNG(SkBitmap const&, SkWStream&)

// flattens an image to a Json stream, also called from shader flatten

bool DrawCommand::flatten(const SkImage&  image,

                          SkJSONWriter&   writer,

                          UrlDataManager& urlDataManager) {

    // For MSKP files, there is no need to encode the image,

    // just report its id.

    if (urlDataManager.hasImageIndex()) {

        writer.appendName(DEBUGCANVAS_ATTRIBUTE_IMAGE_INDEX);

        writer.appendU64(urlDataManager.lookupImage(&image));

        return true;

    }

    writer.beginObject(DEBUGCANVAS_ATTRIBUTE_IMAGE);

    size_t       rowBytes = 4 * image.width();

    SkAutoMalloc buffer(rowBytes * image.height());

    SkImageInfo  dstInfo =

            SkImageInfo::Make(image.dimensions(), kN32_SkColorType, kPremul_SkAlphaType);

    // "cheat" for this debug tool and use image's context

    GrDirectContext* dContext = nullptr;

#if defined(SK_GANESH)

    dContext = GrAsDirectContext(as_IB(&image)->context());

#endif

    if (!image.readPixels(dContext, dstInfo, buffer.get(), rowBytes, 0, 0)) {

        SkDebugf("DrawCommand::flatten SkImage: readPixels failed\n");

        writer.endObject();

        return false;

    }

    SkBitmap bm;

    bm.installPixels(dstInfo, buffer.get(), rowBytes);

    SkDynamicMemoryWStream out;

    DrawCommand::WritePNG(bm, out);

    sk_sp<SkData> encoded = out.detachAsData();

    if (encoded == nullptr) {

        SkDebugf("DrawCommand::flatten SkImage: could not encode image as PNG\n");

        writer.endObject();

        return false;

    }

    auto dataPtr = encoded->data();

    if (!dataPtr) {

      SkDebugf("DrawCommand::flatten SkImage: encoding as PNG produced zero length data\n");

      writer.endObject();

      return false;

    }

    SkString url = encode_data(encoded->data(), encoded->size(), "image/png", urlDataManager);

    writer.appendString(DEBUGCANVAS_ATTRIBUTE_DATA, url);

    writer.endObject();

    return true;

}

static const char* color_type_name(SkColorType colorType) {

    switch (colorType) {

        case kARGB_4444_SkColorType: return DEBUGCANVAS_COLORTYPE_ARGB4444;

        case kRGBA_8888_SkColorType: return DEBUGCANVAS_COLORTYPE_RGBA8888;

        case kBGRA_8888_SkColorType: return DEBUGCANVAS_COLORTYPE_BGRA8888;

        case kRGB_565_SkColorType: return DEBUGCANVAS_COLORTYPE_565;

        case kGray_8_SkColorType: return DEBUGCANVAS_COLORTYPE_GRAY8;

        case kAlpha_8_SkColorType: return DEBUGCANVAS_COLORTYPE_ALPHA8;

        default: SkASSERT(false); return DEBUGCANVAS_COLORTYPE_RGBA8888;

    }

}

Unexecuted instantiation: DrawCommand.cpp:color_type_name(SkColorType)

Unexecuted instantiation: DrawCommand.cpp:color_type_name(SkColorType)

static const char* alpha_type_name(SkAlphaType alphaType) {

    switch (alphaType) {

        case kOpaque_SkAlphaType: return DEBUGCANVAS_ALPHATYPE_OPAQUE;

        case kPremul_SkAlphaType: return DEBUGCANVAS_ALPHATYPE_PREMUL;

        case kUnpremul_SkAlphaType: return DEBUGCANVAS_ALPHATYPE_UNPREMUL;

        default: SkASSERT(false); return DEBUGCANVAS_ALPHATYPE_OPAQUE;

    }

}

Unexecuted instantiation: DrawCommand.cpp:alpha_type_name(SkAlphaType)

Unexecuted instantiation: DrawCommand.cpp:alpha_type_name(SkAlphaType)

bool DrawCommand::flatten(const SkBitmap& bitmap,

                          SkJSONWriter&   writer,

                          UrlDataManager& urlDataManager) {

    sk_sp<SkImage> image(bitmap.asImage());

    writer.appendCString(DEBUGCANVAS_ATTRIBUTE_COLOR, color_type_name(bitmap.colorType()));

    writer.appendCString(DEBUGCANVAS_ATTRIBUTE_ALPHA, alpha_type_name(bitmap.alphaType()));

    // Image will appear to have no uses, TODO(nifong): provide the user with a useful explanation

    bool success = flatten(*image, writer, urlDataManager);

    return success;

}

static void apply_font_hinting(const SkFont& font, SkJSONWriter& writer) {

    SkFontHinting hinting = font.getHinting();

    if (hinting != SkPaintDefaults_Hinting) {

        switch (hinting) {

            case SkFontHinting::kNone:

                writer.appendNString(DEBUGCANVAS_ATTRIBUTE_HINTING, DEBUGCANVAS_HINTING_NONE);

                break;

            case SkFontHinting::kSlight:

                writer.appendNString(DEBUGCANVAS_ATTRIBUTE_HINTING, DEBUGCANVAS_HINTING_SLIGHT);

                break;

            case SkFontHinting::kNormal:

                writer.appendNString(DEBUGCANVAS_ATTRIBUTE_HINTING, DEBUGCANVAS_HINTING_NORMAL);

                break;

            case SkFontHinting::kFull:

                writer.appendNString(DEBUGCANVAS_ATTRIBUTE_HINTING, DEBUGCANVAS_HINTING_FULL);

                break;

        }

    }

}

static void apply_font_edging(const SkFont& font, SkJSONWriter& writer) {

    switch (font.getEdging()) {

        case SkFont::Edging::kAlias:

            writer.appendNString(DEBUGCANVAS_ATTRIBUTE_EDGING, DEBUGCANVAS_EDGING_ALIAS);

            break;

        case SkFont::Edging::kAntiAlias:

            writer.appendNString(DEBUGCANVAS_ATTRIBUTE_EDGING, DEBUGCANVAS_EDGING_ANTIALIAS);

            break;

        case SkFont::Edging::kSubpixelAntiAlias:

            writer.appendNString(DEBUGCANVAS_ATTRIBUTE_EDGING,

                                 DEBUGCANVAS_EDGING_SUBPIXELANTIALIAS);

            break;

    }

}

static void apply_paint_color(const SkPaint& paint, SkJSONWriter& writer) {

    SkColor color = paint.getColor();

    if (color != SK_ColorBLACK) {

        writer.appendName(DEBUGCANVAS_ATTRIBUTE_COLOR);

        DrawCommand::MakeJsonColor(writer, color);

    }

}

static void apply_paint_style(const SkPaint& paint, SkJSONWriter& writer) {

    SkPaint::Style style = paint.getStyle();

    if (style != SkPaint::kFill_Style) {

        switch (style) {

            case SkPaint::kStroke_Style: {

                writer.appendNString(DEBUGCANVAS_ATTRIBUTE_STYLE, DEBUGCANVAS_STYLE_STROKE);

                break;

            }

            case SkPaint::kStrokeAndFill_Style: {

                writer.appendNString(DEBUGCANVAS_ATTRIBUTE_STYLE, DEBUGCANVAS_STYLE_STROKEANDFILL);

                break;

            }

            default: SkASSERT(false);

        }

    }

}

Unexecuted instantiation: DrawCommand.cpp:apply_paint_style(SkPaint const&, SkJSONWriter&)

Unexecuted instantiation: DrawCommand.cpp:apply_paint_style(SkPaint const&, SkJSONWriter&)

static void apply_paint_cap(const SkPaint& paint, SkJSONWriter& writer) {

    SkPaint::Cap cap = paint.getStrokeCap();

    if (cap != SkPaint::kDefault_Cap) {

        switch (cap) {

            case SkPaint::kButt_Cap:

                writer.appendNString(DEBUGCANVAS_ATTRIBUTE_CAP, DEBUGCANVAS_CAP_BUTT);

                break;

            case SkPaint::kRound_Cap:

                writer.appendNString(DEBUGCANVAS_ATTRIBUTE_CAP, DEBUGCANVAS_CAP_ROUND);

                break;

            case SkPaint::kSquare_Cap:

                writer.appendNString(DEBUGCANVAS_ATTRIBUTE_CAP, DEBUGCANVAS_CAP_SQUARE);

                break;

            default: SkASSERT(false);

        }

    }

}

Unexecuted instantiation: DrawCommand.cpp:apply_paint_cap(SkPaint const&, SkJSONWriter&)

Unexecuted instantiation: DrawCommand.cpp:apply_paint_cap(SkPaint const&, SkJSONWriter&)

static void apply_paint_join(const SkPaint& paint, SkJSONWriter& writer) {

    SkPaint::Join join = paint.getStrokeJoin();

    if (join != SkPaint::kDefault_Join) {

        switch (join) {

            case SkPaint::kMiter_Join:

                writer.appendNString(DEBUGCANVAS_ATTRIBUTE_STROKEJOIN, DEBUGCANVAS_MITER_JOIN);

                break;

            case SkPaint::kRound_Join:

                writer.appendNString(DEBUGCANVAS_ATTRIBUTE_STROKEJOIN, DEBUGCANVAS_ROUND_JOIN);

                break;

            case SkPaint::kBevel_Join:

                writer.appendNString(DEBUGCANVAS_ATTRIBUTE_STROKEJOIN, DEBUGCANVAS_BEVEL_JOIN);

                break;

            default: SkASSERT(false);

        }

    }

}

Unexecuted instantiation: DrawCommand.cpp:apply_paint_join(SkPaint const&, SkJSONWriter&)

Unexecuted instantiation: DrawCommand.cpp:apply_paint_join(SkPaint const&, SkJSONWriter&)

static void apply_paint_maskfilter(const SkPaint&  paint,

                                   SkJSONWriter&   writer,

                                   UrlDataManager& urlDataManager) {

    SkMaskFilter* maskFilter = paint.getMaskFilter();

    if (maskFilter != nullptr) {

        SkMaskFilterBase::BlurRec blurRec;

        if (as_MFB(maskFilter)->asABlur(&blurRec)) {

            writer.beginObject(DEBUGCANVAS_ATTRIBUTE_BLUR);

            writer.appendFloat(DEBUGCANVAS_ATTRIBUTE_SIGMA, blurRec.fSigma);

            switch (blurRec.fStyle) {

                case SkBlurStyle::kNormal_SkBlurStyle:

                    writer.appendNString(DEBUGCANVAS_ATTRIBUTE_STYLE, DEBUGCANVAS_BLURSTYLE_NORMAL);

                    break;

                case SkBlurStyle::kSolid_SkBlurStyle:

                    writer.appendNString(DEBUGCANVAS_ATTRIBUTE_STYLE, DEBUGCANVAS_BLURSTYLE_SOLID);

                    break;

                case SkBlurStyle::kOuter_SkBlurStyle:

                    writer.appendNString(DEBUGCANVAS_ATTRIBUTE_STYLE, DEBUGCANVAS_BLURSTYLE_OUTER);

                    break;

                case SkBlurStyle::kInner_SkBlurStyle:

                    writer.appendNString(DEBUGCANVAS_ATTRIBUTE_STYLE, DEBUGCANVAS_BLURSTYLE_INNER);

                    break;

                default: SkASSERT(false);

            }

            writer.endObject();  // blur

        } else {

            writer.beginObject(DEBUGCANVAS_ATTRIBUTE_MASKFILTER);

            DrawCommand::flatten(maskFilter, writer, urlDataManager);

            writer.endObject();  // maskFilter

        }

    }

}

Unexecuted instantiation: DrawCommand.cpp:apply_paint_maskfilter(SkPaint const&, SkJSONWriter&, UrlDataManager&)

Unexecuted instantiation: DrawCommand.cpp:apply_paint_maskfilter(SkPaint const&, SkJSONWriter&, UrlDataManager&)

static void apply_paint_patheffect(const SkPaint&  paint,

                                   SkJSONWriter&   writer,

                                   UrlDataManager& urlDataManager) {

    SkPathEffect* pathEffect = paint.getPathEffect();

    if (pathEffect != nullptr) {