[skottie] Relocate to modules/skottie

TBR=
Change-Id: I218d251ca56578a3a7fd4fb86cba9abdc10fb3bd
Reviewed-on: https://skia-review.googlesource.com/130322
Reviewed-by: Florin Malita <fmalita@chromium.org>
Commit-Queue: Florin Malita <fmalita@chromium.org>

10 files changed, 0 insertions, 2684 deletions

diff --git a/experimental/skottie/Skottie.cpp b/experimental/skottie/Skottie.cpp
deleted file mode 100644
index 8396b5ba90..0000000000
--- a/experimental/skottie/Skottie.cpp
+++ /dev/null
@@ -1,1327 +0,0 @@
-/*
- * Copyright 2017 Google Inc.
- *
- * Use of this source code is governed by a BSD-style license that can be
- * found in the LICENSE file.
- */
-
-#include "Skottie.h"
-
-#include "SkCanvas.h"
-#include "SkottieAdapter.h"
-#include "SkottieAnimator.h"
-#include "SkottieJson.h"
-#include "SkottieValue.h"
-#include "SkData.h"
-#include "SkImage.h"
-#include "SkMakeUnique.h"
-#include "SkOSPath.h"
-#include "SkPaint.h"
-#include "SkParse.h"
-#include "SkPoint.h"
-#include "SkSGClipEffect.h"
-#include "SkSGColor.h"
-#include "SkSGDraw.h"
-#include "SkSGGeometryTransform.h"
-#include "SkSGGradient.h"
-#include "SkSGGroup.h"
-#include "SkSGImage.h"
-#include "SkSGInvalidationController.h"
-#include "SkSGMaskEffect.h"
-#include "SkSGMerge.h"
-#include "SkSGOpacityEffect.h"
-#include "SkSGPath.h"
-#include "SkSGRect.h"
-#include "SkSGRoundEffect.h"
-#include "SkSGScene.h"
-#include "SkSGTransform.h"
-#include "SkSGTrimEffect.h"
-#include "SkStream.h"
-#include "SkTArray.h"
-#include "SkTime.h"
-#include "SkTHash.h"
-
-#include <cmath>
-#include <vector>
-
-#include "stdlib.h"
-
-namespace skottie {
-
-#define LOG SkDebugf
-
-namespace {
-
-struct AssetInfo {
-    json::ValueRef fAsset;
-    mutable bool   fIsAttaching; // Used for cycle detection
-};
-
-using AssetMap = SkTHashMap<SkString, AssetInfo>;
-
-struct AttachContext {
-    const ResourceProvider& fResources;
-    const AssetMap&         fAssets;
-    const float             fFrameRate;
-    sksg::AnimatorList&     fAnimators;
-};
-
-bool LogFail(const json::ValueRef& json, const char* msg) {
-    const auto dump = json.toString();
-    LOG("!! %s: %s\n", msg, dump.c_str());
-    return false;
-}
-
-sk_sp<sksg::Matrix> AttachMatrix(const json::ValueRef& t, AttachContext* ctx,
-                                        sk_sp<sksg::Matrix> parentMatrix) {
-    if (!t.isObject())
-        return nullptr;
-
-    auto matrix = sksg::Matrix::Make(SkMatrix::I(), std::move(parentMatrix));
-    auto adapter = sk_make_sp<TransformAdapter>(matrix);
-    auto anchor_attached = BindProperty<VectorValue>(t["a"], &ctx->fAnimators,
-            [adapter](const VectorValue& a) {
-                adapter->setAnchorPoint(ValueTraits<VectorValue>::As<SkPoint>(a));
-            });
-    auto position_attached = BindProperty<VectorValue>(t["p"], &ctx->fAnimators,
-            [adapter](const VectorValue& p) {
-                adapter->setPosition(ValueTraits<VectorValue>::As<SkPoint>(p));
-            });
-    auto scale_attached = BindProperty<VectorValue>(t["s"], &ctx->fAnimators,
-            [adapter](const VectorValue& s) {
-                adapter->setScale(ValueTraits<VectorValue>::As<SkVector>(s));
-            });
-
-    auto jrotation = t["r"];
-    if (jrotation.isNull()) {
-        // 3d rotations have separate rx,ry,rz components.  While we don't fully support them,
-        // we can still make use of rz.
-        jrotation = t["rz"];
-    }
-    auto rotation_attached = BindProperty<ScalarValue>(jrotation, &ctx->fAnimators,
-            [adapter](const ScalarValue& r) {
-                adapter->setRotation(r);
-            });
-    auto skew_attached = BindProperty<ScalarValue>(t["sk"], &ctx->fAnimators,
-            [adapter](const ScalarValue& sk) {
-                adapter->setSkew(sk);
-            });
-    auto skewaxis_attached = BindProperty<ScalarValue>(t["sa"], &ctx->fAnimators,
-            [adapter](const ScalarValue& sa) {
-                adapter->setSkewAxis(sa);
-            });
-
-    if (!anchor_attached &&
-        !position_attached &&
-        !scale_attached &&
-        !rotation_attached &&
-        !skew_attached &&
-        !skewaxis_attached) {
-        LogFail(t, "Could not parse transform");
-        return nullptr;
-    }
-
-    return matrix;
-}
-
-sk_sp<sksg::RenderNode> AttachOpacity(const json::ValueRef& jtransform, AttachContext* ctx,
-                                      sk_sp<sksg::RenderNode> childNode) {
-    if (!jtransform.isObject() || !childNode)
-        return childNode;
-
-    static constexpr ScalarValue kNoopOpacity = 100;
-    auto opacityNode = sksg::OpacityEffect::Make(childNode);
-
-    if (!BindProperty<ScalarValue>(jtransform["o"], &ctx->fAnimators,
-        [opacityNode](const ScalarValue& o) {
-            // BM opacity is [0..100]
-            opacityNode->setOpacity(o * 0.01f);
-        }, &kNoopOpacity)) {
-        // We can ignore static full opacity.
-        return childNode;
-    }
-
-    return std::move(opacityNode);
-}
-
-sk_sp<sksg::RenderNode> AttachComposition(const json::ValueRef&, AttachContext* ctx);
-
-sk_sp<sksg::Path> AttachPath(const json::ValueRef& jpath, AttachContext* ctx) {
-    auto path_node = sksg::Path::Make();
-    return BindProperty<ShapeValue>(jpath, &ctx->fAnimators,
-        [path_node](const ShapeValue& p) {
-            path_node->setPath(ValueTraits<ShapeValue>::As<SkPath>(p));
-        })
-        ? path_node
-        : nullptr;
-}
-
-sk_sp<sksg::GeometryNode> AttachPathGeometry(const json::ValueRef& jpath, AttachContext* ctx) {
-    SkASSERT(jpath.isObject());
-
-    return AttachPath(jpath["ks"], ctx);
-}
-
-sk_sp<sksg::GeometryNode> AttachRRectGeometry(const json::ValueRef& jrect, AttachContext* ctx) {
-    SkASSERT(jrect.isObject());
-
-    auto rect_node = sksg::RRect::Make();
-    auto adapter = sk_make_sp<RRectAdapter>(rect_node);
-
-    auto p_attached = BindProperty<VectorValue>(jrect["p"], &ctx->fAnimators,
-        [adapter](const VectorValue& p) {
-                adapter->setPosition(ValueTraits<VectorValue>::As<SkPoint>(p));
-        });
-    auto s_attached = BindProperty<VectorValue>(jrect["s"], &ctx->fAnimators,
-        [adapter](const VectorValue& s) {
-            adapter->setSize(ValueTraits<VectorValue>::As<SkSize>(s));
-        });
-    auto r_attached = BindProperty<ScalarValue>(jrect["r"], &ctx->fAnimators,
-        [adapter](const ScalarValue& r) {
-            adapter->setRadius(SkSize::Make(r, r));
-        });
-
-    if (!p_attached && !s_attached && !r_attached) {
-        return nullptr;
-    }
-
-    return std::move(rect_node);
-}
-
-sk_sp<sksg::GeometryNode> AttachEllipseGeometry(const json::ValueRef& jellipse, AttachContext* ctx) {
-    SkASSERT(jellipse.isObject());
-
-    auto rect_node = sksg::RRect::Make();
-    auto adapter = sk_make_sp<RRectAdapter>(rect_node);
-
-    auto p_attached = BindProperty<VectorValue>(jellipse["p"], &ctx->fAnimators,
-        [adapter](const VectorValue& p) {
-            adapter->setPosition(ValueTraits<VectorValue>::As<SkPoint>(p));
-        });
-    auto s_attached = BindProperty<VectorValue>(jellipse["s"], &ctx->fAnimators,
-        [adapter](const VectorValue& s) {
-            const auto sz = ValueTraits<VectorValue>::As<SkSize>(s);
-            adapter->setSize(sz);
-            adapter->setRadius(SkSize::Make(sz.width() / 2, sz.height() / 2));
-        });
-
-    if (!p_attached && !s_attached) {
-        return nullptr;
-    }
-
-    return std::move(rect_node);
-}
-
-sk_sp<sksg::GeometryNode> AttachPolystarGeometry(const json::ValueRef& jstar, AttachContext* ctx) {
-    SkASSERT(jstar.isObject());
-
-    static constexpr PolyStarAdapter::Type gTypes[] = {
-        PolyStarAdapter::Type::kStar, // "sy": 1
-        PolyStarAdapter::Type::kPoly, // "sy": 2
-    };
-
-    const auto type = jstar["sy"].toDefault<int>(0) - 1;
-    if (type < 0 || type >= SkTo<int>(SK_ARRAY_COUNT(gTypes))) {
-        LogFail(jstar, "Unknown polystar type");
-        return nullptr;
-    }
-
-    auto path_node = sksg::Path::Make();
-    auto adapter = sk_make_sp<PolyStarAdapter>(path_node, gTypes[type]);
-
-    BindProperty<VectorValue>(jstar["p"], &ctx->fAnimators,
-        [adapter](const VectorValue& p) {
-            adapter->setPosition(ValueTraits<VectorValue>::As<SkPoint>(p));
-        });
-    BindProperty<ScalarValue>(jstar["pt"], &ctx->fAnimators,
-        [adapter](const ScalarValue& pt) {
-            adapter->setPointCount(pt);
-        });
-    BindProperty<ScalarValue>(jstar["ir"], &ctx->fAnimators,
-        [adapter](const ScalarValue& ir) {
-            adapter->setInnerRadius(ir);
-        });
-    BindProperty<ScalarValue>(jstar["or"], &ctx->fAnimators,
-        [adapter](const ScalarValue& otr) {
-            adapter->setOuterRadius(otr);
-        });
-    BindProperty<ScalarValue>(jstar["is"], &ctx->fAnimators,
-        [adapter](const ScalarValue& is) {
-            adapter->setInnerRoundness(is);
-        });
-    BindProperty<ScalarValue>(jstar["os"], &ctx->fAnimators,
-        [adapter](const ScalarValue& os) {
-            adapter->setOuterRoundness(os);
-        });
-    BindProperty<ScalarValue>(jstar["r"], &ctx->fAnimators,
-        [adapter](const ScalarValue& r) {
-            adapter->setRotation(r);
-        });
-
-    return std::move(path_node);
-}
-
-sk_sp<sksg::Color> AttachColor(const json::ValueRef& obj, AttachContext* ctx) {
-    SkASSERT(obj.isObject());
-
-    auto color_node = sksg::Color::Make(SK_ColorBLACK);
-    auto color_attached = BindProperty<VectorValue>(obj["c"], &ctx->fAnimators,
-        [color_node](const VectorValue& c) {
-            color_node->setColor(ValueTraits<VectorValue>::As<SkColor>(c));
-        });
-
-    return color_attached ? color_node : nullptr;
-}
-
-sk_sp<sksg::Gradient> AttachGradient(const json::ValueRef& obj, AttachContext* ctx) {
-    SkASSERT(obj.isObject());
-
-    const auto stops = obj["g"];
-    if (!stops.isObject())
-        return nullptr;
-
-    const auto stopCount = stops["p"].toDefault<int>(-1);
-    if (stopCount < 0)
-        return nullptr;
-
-    sk_sp<sksg::Gradient> gradient_node;
-    sk_sp<GradientAdapter> adapter;
-
-    if (obj["t"].toDefault<int>(1) == 1) {
-        auto linear_node = sksg::LinearGradient::Make();
-        adapter = sk_make_sp<LinearGradientAdapter>(linear_node, stopCount);
-        gradient_node = std::move(linear_node);
-    } else {
-        auto radial_node = sksg::RadialGradient::Make();
-        adapter = sk_make_sp<RadialGradientAdapter>(radial_node, stopCount);
-
-        // TODO: highlight, angle
-        gradient_node = std::move(radial_node);
-    }
-
-    BindProperty<VectorValue>(stops["k"], &ctx->fAnimators,
-        [adapter](const VectorValue& stops) {
-            adapter->setColorStops(stops);
-        });
-    BindProperty<VectorValue>(obj["s"], &ctx->fAnimators,
-        [adapter](const VectorValue& s) {
-            adapter->setStartPoint(ValueTraits<VectorValue>::As<SkPoint>(s));
-        });
-    BindProperty<VectorValue>(obj["e"], &ctx->fAnimators,
-        [adapter](const VectorValue& e) {
-            adapter->setEndPoint(ValueTraits<VectorValue>::As<SkPoint>(e));
-        });
-
-    return gradient_node;
-}
-
-sk_sp<sksg::PaintNode> AttachPaint(const json::ValueRef& jpaint, AttachContext* ctx,
-                                   sk_sp<sksg::PaintNode> paint_node) {
-    if (paint_node) {
-        paint_node->setAntiAlias(true);
-
-        BindProperty<ScalarValue>(jpaint["o"], &ctx->fAnimators,
-            [paint_node](const ScalarValue& o) {
-                // BM opacity is [0..100]
-                paint_node->setOpacity(o * 0.01f);
-        });
-    }
-
-    return paint_node;
-}
-
-sk_sp<sksg::PaintNode> AttachStroke(const json::ValueRef& jstroke, AttachContext* ctx,
-                                    sk_sp<sksg::PaintNode> stroke_node) {
-    SkASSERT(jstroke.isObject());
-
-    if (!stroke_node)
-        return nullptr;
-
-    stroke_node->setStyle(SkPaint::kStroke_Style);
-
-    auto width_attached = BindProperty<ScalarValue>(jstroke["w"], &ctx->fAnimators,
-        [stroke_node](const ScalarValue& w) {
-            stroke_node->setStrokeWidth(w);
-        });
-    if (!width_attached)
-        return nullptr;
-
-    stroke_node->setStrokeMiter(jstroke["ml"].toDefault(4.0f));
-
-    static constexpr SkPaint::Join gJoins[] = {
-        SkPaint::kMiter_Join,
-        SkPaint::kRound_Join,
-        SkPaint::kBevel_Join,
-    };
-    stroke_node->setStrokeJoin(gJoins[SkTPin<int>(jstroke["lj"].toDefault<int>(1) - 1,
-                                                  0, SK_ARRAY_COUNT(gJoins) - 1)]);
-
-    static constexpr SkPaint::Cap gCaps[] = {
-        SkPaint::kButt_Cap,
-        SkPaint::kRound_Cap,
-        SkPaint::kSquare_Cap,
-    };
-    stroke_node->setStrokeCap(gCaps[SkTPin<int>(jstroke["lc"].toDefault<int>(1) - 1,
-                                                0, SK_ARRAY_COUNT(gCaps) - 1)]);
-
-    return stroke_node;
-}
-
-sk_sp<sksg::PaintNode> AttachColorFill(const json::ValueRef& jfill, AttachContext* ctx) {
-    SkASSERT(jfill.isObject());
-
-    return AttachPaint(jfill, ctx, AttachColor(jfill, ctx));
-}
-
-sk_sp<sksg::PaintNode> AttachGradientFill(const json::ValueRef& jfill, AttachContext* ctx) {
-    SkASSERT(jfill.isObject());
-
-    return AttachPaint(jfill, ctx, AttachGradient(jfill, ctx));
-}
-
-sk_sp<sksg::PaintNode> AttachColorStroke(const json::ValueRef& jstroke, AttachContext* ctx) {
-    SkASSERT(jstroke.isObject());
-
-    return AttachStroke(jstroke, ctx, AttachPaint(jstroke, ctx, AttachColor(jstroke, ctx)));
-}
-
-sk_sp<sksg::PaintNode> AttachGradientStroke(const json::ValueRef& jstroke, AttachContext* ctx) {
-    SkASSERT(jstroke.isObject());
-
-    return AttachStroke(jstroke, ctx, AttachPaint(jstroke, ctx, AttachGradient(jstroke, ctx)));
-}
-
-std::vector<sk_sp<sksg::GeometryNode>> AttachMergeGeometryEffect(
-    const json::ValueRef& jmerge, AttachContext* ctx, std::vector<sk_sp<sksg::GeometryNode>>&& geos) {
-    std::vector<sk_sp<sksg::GeometryNode>> merged;
-
-    static constexpr sksg::Merge::Mode gModes[] = {
-        sksg::Merge::Mode::kMerge,      // "mm": 1
-        sksg::Merge::Mode::kUnion,      // "mm": 2
-        sksg::Merge::Mode::kDifference, // "mm": 3
-        sksg::Merge::Mode::kIntersect,  // "mm": 4
-        sksg::Merge::Mode::kXOR      ,  // "mm": 5
-    };
-
-    const auto mode = gModes[SkTPin<int>(jmerge["mm"].toDefault(1) - 1,
-                                         0, SK_ARRAY_COUNT(gModes) - 1)];
-    merged.push_back(sksg::Merge::Make(std::move(geos), mode));
-
-    return merged;
-}
-
-std::vector<sk_sp<sksg::GeometryNode>> AttachTrimGeometryEffect(
-    const json::ValueRef& jtrim, AttachContext* ctx, std::vector<sk_sp<sksg::GeometryNode>>&& geos) {
-
-    enum class Mode {
-        kMerged,   // "m": 1
-        kSeparate, // "m": 2
-    } gModes[] = { Mode::kMerged, Mode::kSeparate };
-
-    const auto mode = gModes[SkTPin<int>(jtrim["m"].toDefault(1) - 1,
-                                         0, SK_ARRAY_COUNT(gModes) - 1)];
-
-    std::vector<sk_sp<sksg::GeometryNode>> inputs;
-    if (mode == Mode::kMerged) {
-        inputs.push_back(sksg::Merge::Make(std::move(geos), sksg::Merge::Mode::kMerge));
-    } else {
-        inputs = std::move(geos);
-    }
-
-    std::vector<sk_sp<sksg::GeometryNode>> trimmed;
-    trimmed.reserve(inputs.size());
-    for (const auto& i : inputs) {
-        const auto trimEffect = sksg::TrimEffect::Make(i);
-        trimmed.push_back(trimEffect);
-
-        const auto adapter = sk_make_sp<TrimEffectAdapter>(std::move(trimEffect));
-        BindProperty<ScalarValue>(jtrim["s"], &ctx->fAnimators,
-            [adapter](const ScalarValue& s) {
-                adapter->setStart(s);
-            });
-        BindProperty<ScalarValue>(jtrim["e"], &ctx->fAnimators,
-            [adapter](const ScalarValue& e) {
-                adapter->setEnd(e);
-            });
-        BindProperty<ScalarValue>(jtrim["o"], &ctx->fAnimators,
-            [adapter](const ScalarValue& o) {
-                adapter->setOffset(o);
-            });
-    }
-
-    return trimmed;
-}
-
-std::vector<sk_sp<sksg::GeometryNode>> AttachRoundGeometryEffect(
-    const json::ValueRef& jtrim, AttachContext* ctx, std::vector<sk_sp<sksg::GeometryNode>>&& geos) {
-
-    std::vector<sk_sp<sksg::GeometryNode>> rounded;
-    rounded.reserve(geos.size());
-
-    for (const auto& g : geos) {
-        const auto roundEffect = sksg::RoundEffect::Make(std::move(g));
-        rounded.push_back(roundEffect);
-
-        BindProperty<ScalarValue>(jtrim["r"], &ctx->fAnimators,
-            [roundEffect](const ScalarValue& r) {
-                roundEffect->setRadius(r);
-            });
-    }
-
-    return rounded;
-}
-
-using GeometryAttacherT = sk_sp<sksg::GeometryNode> (*)(const json::ValueRef&, AttachContext*);
-static constexpr GeometryAttacherT gGeometryAttachers[] = {
-    AttachPathGeometry,
-    AttachRRectGeometry,
-    AttachEllipseGeometry,
-    AttachPolystarGeometry,
-};
-
-using PaintAttacherT = sk_sp<sksg::PaintNode> (*)(const json::ValueRef&, AttachContext*);
-static constexpr PaintAttacherT gPaintAttachers[] = {
-    AttachColorFill,
-    AttachColorStroke,
-    AttachGradientFill,
-    AttachGradientStroke,
-};
-
-using GeometryEffectAttacherT =
-    std::vector<sk_sp<sksg::GeometryNode>> (*)(const json::ValueRef&,
-                                               AttachContext*,
-                                               std::vector<sk_sp<sksg::GeometryNode>>&&);
-static constexpr GeometryEffectAttacherT gGeometryEffectAttachers[] = {
-    AttachMergeGeometryEffect,
-    AttachTrimGeometryEffect,
-    AttachRoundGeometryEffect,
-};
-
-enum class ShapeType {
-    kGeometry,
-    kGeometryEffect,
-    kPaint,
-    kGroup,
-    kTransform,
-};
-
-struct ShapeInfo {
-    const char* fTypeString;
-    ShapeType   fShapeType;
-    uint32_t    fAttacherIndex; // index into respective attacher tables
-};
-
-const ShapeInfo* FindShapeInfo(const json::ValueRef& shape) {
-    static constexpr ShapeInfo gShapeInfo[] = {
-        { "el", ShapeType::kGeometry      , 2 }, // ellipse   -> AttachEllipseGeometry
-        { "fl", ShapeType::kPaint         , 0 }, // fill      -> AttachColorFill
-        { "gf", ShapeType::kPaint         , 2 }, // gfill     -> AttachGradientFill
-        { "gr", ShapeType::kGroup         , 0 }, // group     -> Inline handler
-        { "gs", ShapeType::kPaint         , 3 }, // gstroke   -> AttachGradientStroke
-        { "mm", ShapeType::kGeometryEffect, 0 }, // merge     -> AttachMergeGeometryEffect
-        { "rc", ShapeType::kGeometry      , 1 }, // rrect     -> AttachRRectGeometry
-        { "rd", ShapeType::kGeometryEffect, 2 }, // round     -> AttachRoundGeometryEffect
-        { "sh", ShapeType::kGeometry      , 0 }, // shape     -> AttachPathGeometry
-        { "sr", ShapeType::kGeometry      , 3 }, // polystar  -> AttachPolyStarGeometry
-        { "st", ShapeType::kPaint         , 1 }, // stroke    -> AttachColorStroke
-        { "tm", ShapeType::kGeometryEffect, 1 }, // trim      -> AttachTrimGeometryEffect
-        { "tr", ShapeType::kTransform     , 0 }, // transform -> Inline handler
-    };
-
-    SkString type;
-    if (!shape["ty"].to(&type) || type.isEmpty())
-        return nullptr;
-
-    const auto* info = bsearch(type.c_str(),
-                               gShapeInfo,
-                               SK_ARRAY_COUNT(gShapeInfo),
-                               sizeof(ShapeInfo),
-                               [](const void* key, const void* info) {
-                                  return strcmp(static_cast<const char*>(key),
-                                                static_cast<const ShapeInfo*>(info)->fTypeString);
-                               });
-
-    return static_cast<const ShapeInfo*>(info);
-}
-
-struct GeometryEffectRec {
-    const json::ValueRef      fJson;
-    GeometryEffectAttacherT fAttach;
-};
-
-struct AttachShapeContext {
-    AttachShapeContext(AttachContext* ctx,
-                       std::vector<sk_sp<sksg::GeometryNode>>* geos,
-                       std::vector<GeometryEffectRec>* effects,
-                       size_t committedAnimators)
-        : fCtx(ctx)
-        , fGeometryStack(geos)
-        , fGeometryEffectStack(effects)
-        , fCommittedAnimators(committedAnimators) {}
-
-    AttachContext*                          fCtx;
-    std::vector<sk_sp<sksg::GeometryNode>>* fGeometryStack;
-    std::vector<GeometryEffectRec>*         fGeometryEffectStack;
-    size_t                                  fCommittedAnimators;
-};
-
-sk_sp<sksg::RenderNode> AttachShape(const json::ValueRef& jshape, AttachShapeContext* shapeCtx) {
-    if (!jshape.isArray())
-        return nullptr;
-
-    SkDEBUGCODE(const auto initialGeometryEffects = shapeCtx->fGeometryEffectStack->size();)
-
-    sk_sp<sksg::Group> shape_group = sksg::Group::Make();
-    sk_sp<sksg::RenderNode> shape_wrapper = shape_group;
-    sk_sp<sksg::Matrix> shape_matrix;
-
-    struct ShapeRec {
-        const json::ValueRef fJson;
-        const ShapeInfo&   fInfo;
-    };
-
-    // First pass (bottom->top):
-    //
-    //   * pick up the group transform and opacity
-    //   * push local geometry effects onto the stack
-    //   * store recs for next pass
-    //
-    std::vector<ShapeRec> recs;
-    for (size_t i = 0; i < jshape.size(); ++i) {
-        const auto s = jshape[jshape.size() - 1 - i];
-        const auto* info = FindShapeInfo(s);
-        if (!info) {
-            LogFail(s["ty"], "Unknown shape");
-            continue;
-        }
-
-        recs.push_back({ s, *info });
-
-        switch (info->fShapeType) {
-        case ShapeType::kTransform:
-            if ((shape_matrix = AttachMatrix(s, shapeCtx->fCtx, nullptr))) {
-                shape_wrapper = sksg::Transform::Make(std::move(shape_wrapper), shape_matrix);
-            }
-            shape_wrapper = AttachOpacity(s, shapeCtx->fCtx, std::move(shape_wrapper));
-            break;
-        case ShapeType::kGeometryEffect:
-            SkASSERT(info->fAttacherIndex < SK_ARRAY_COUNT(gGeometryEffectAttachers));
-            shapeCtx->fGeometryEffectStack->push_back(
-                { s, gGeometryEffectAttachers[info->fAttacherIndex] });
-            break;
-        default:
-            break;
-        }
-    }
-
-    // Second pass (top -> bottom, after 2x reverse):
-    //
-    //   * track local geometry
-    //   * emit local paints
-    //
-    std::vector<sk_sp<sksg::GeometryNode>> geos;
-    std::vector<sk_sp<sksg::RenderNode  >> draws;
-    for (auto rec = recs.rbegin(); rec != recs.rend(); ++rec) {
-        switch (rec->fInfo.fShapeType) {
-        case ShapeType::kGeometry: {
-            SkASSERT(rec->fInfo.fAttacherIndex < SK_ARRAY_COUNT(gGeometryAttachers));
-            if (auto geo = gGeometryAttachers[rec->fInfo.fAttacherIndex](rec->fJson,
-                                                                         shapeCtx->fCtx)) {
-                geos.push_back(std::move(geo));
-            }
-        } break;
-        case ShapeType::kGeometryEffect: {
-            // Apply the current effect and pop from the stack.
-            SkASSERT(rec->fInfo.fAttacherIndex < SK_ARRAY_COUNT(gGeometryEffectAttachers));
-            if (!geos.empty()) {
-                geos = gGeometryEffectAttachers[rec->fInfo.fAttacherIndex](rec->fJson,
-                                                                           shapeCtx->fCtx,
-                                                                           std::move(geos));
-            }
-
-            SkASSERT(shapeCtx->fGeometryEffectStack->back().fJson == rec->fJson);
-            SkASSERT(shapeCtx->fGeometryEffectStack->back().fAttach ==
-                     gGeometryEffectAttachers[rec->fInfo.fAttacherIndex]);
-            shapeCtx->fGeometryEffectStack->pop_back();
-        } break;
-        case ShapeType::kGroup: {
-            AttachShapeContext groupShapeCtx(shapeCtx->fCtx,
-                                             &geos,
-                                             shapeCtx->fGeometryEffectStack,
-                                             shapeCtx->fCommittedAnimators);
-            if (auto subgroup = AttachShape(rec->fJson["it"], &groupShapeCtx)) {
-                draws.push_back(std::move(subgroup));
-                SkASSERT(groupShapeCtx.fCommittedAnimators >= shapeCtx->fCommittedAnimators);
-                shapeCtx->fCommittedAnimators = groupShapeCtx.fCommittedAnimators;
-            }
-        } break;
-        case ShapeType::kPaint: {
-            SkASSERT(rec->fInfo.fAttacherIndex < SK_ARRAY_COUNT(gPaintAttachers));
-            auto paint = gPaintAttachers[rec->fInfo.fAttacherIndex](rec->fJson, shapeCtx->fCtx);
-            if (!paint || geos.empty())
-                break;
-
-            auto drawGeos = geos;
-
-            // Apply all pending effects from the stack.
-            for (auto it = shapeCtx->fGeometryEffectStack->rbegin();
-                 it != shapeCtx->fGeometryEffectStack->rend(); ++it) {
-                drawGeos = it->fAttach(it->fJson, shapeCtx->fCtx, std::move(drawGeos));
-            }
-
-            // If we still have multiple geos, reduce using 'merge'.
-            auto geo = drawGeos.size() > 1
-                ? sksg::Merge::Make(std::move(drawGeos), sksg::Merge::Mode::kMerge)
-                : drawGeos[0];
-
-            SkASSERT(geo);
-            draws.push_back(sksg::Draw::Make(std::move(geo), std::move(paint)));
-            shapeCtx->fCommittedAnimators = shapeCtx->fCtx->fAnimators.size();
-        } break;
-        default:
-            break;
-        }
-    }
-
-    // By now we should have popped all local geometry effects.
-    SkASSERT(shapeCtx->fGeometryEffectStack->size() == initialGeometryEffects);
-
-    // Push transformed local geometries to parent list, for subsequent paints.
-    for (const auto& geo : geos) {
-        shapeCtx->fGeometryStack->push_back(shape_matrix
-            ? sksg::GeometryTransform::Make(std::move(geo), shape_matrix)
-            : std::move(geo));
-    }
-
-    // Emit local draws reversed (bottom->top, per spec).
-    for (auto it = draws.rbegin(); it != draws.rend(); ++it) {
-        shape_group->addChild(std::move(*it));
-    }
-
-    return draws.empty() ? nullptr : shape_wrapper;
-}
-
-sk_sp<sksg::RenderNode> AttachNestedAnimation(const char* path, AttachContext* ctx) {
-    class SkottieSGAdapter final : public sksg::RenderNode {
-    public:
-        explicit SkottieSGAdapter(sk_sp<Animation> animation)
-            : fAnimation(std::move(animation)) {
-            SkASSERT(fAnimation);
-        }
-
-    protected:
-        SkRect onRevalidate(sksg::InvalidationController*, const SkMatrix&) override {
-            return SkRect::MakeSize(fAnimation->size());
-        }
-
-        void onRender(SkCanvas* canvas) const override {
-            fAnimation->render(canvas);
-        }
-
-    private:
-        const sk_sp<Animation> fAnimation;
-    };
-
-    class SkottieAnimatorAdapter final : public sksg::Animator {
-    public:
-        SkottieAnimatorAdapter(sk_sp<Animation> animation, float frameRate)
-            : fAnimation(std::move(animation))
-            , fFrameRate(frameRate) {
-            SkASSERT(fAnimation);
-            SkASSERT(fFrameRate > 0);
-        }
-
-    protected:
-        void onTick(float t) {
-            // map back from frame # to ms.
-            const auto t_ms = t * 1000 / fFrameRate;
-            fAnimation->animationTick(t_ms);
-        }
-
-    private:
-        const sk_sp<Animation> fAnimation;
-        const float            fFrameRate;
-    };
-
-    const auto resStream  = ctx->fResources.openStream(path);
-    if (!resStream || !resStream->hasLength()) {
-        LOG("!! Could not open: %s\n", path);
-        return nullptr;
-    }
-
-    auto animation = Animation::Make(resStream.get(), ctx->fResources);
-    if (!animation) {
-        LOG("!! Could not load nested animation: %s\n", path);
-        return nullptr;
-    }
-
-    ctx->fAnimators.push_back(skstd::make_unique<SkottieAnimatorAdapter>(animation,
-                                                                         ctx->fFrameRate));
-
-    return sk_make_sp<SkottieSGAdapter>(std::move(animation));
-}
-
-sk_sp<sksg::RenderNode> AttachAssetRef(const json::ValueRef& jlayer, AttachContext* ctx,
-    sk_sp<sksg::RenderNode>(*attach_proc)(const json::ValueRef& comp, AttachContext* ctx)) {
-
-    const auto refId = jlayer["refId"].toDefault(SkString());
-    if (refId.isEmpty()) {
-        LOG("!! Layer missing refId\n");
-        return nullptr;
-    }
-
-    if (refId.startsWith("$")) {
-        return AttachNestedAnimation(refId.c_str() + 1, ctx);
-    }
-
-    const auto* asset_info = ctx->fAssets.find(refId);
-    if (!asset_info) {
-        LOG("!! Asset not found: '%s'\n", refId.c_str());
-        return nullptr;
-    }
-
-    if (asset_info->fIsAttaching) {
-        LOG("!! Asset cycle detected for: '%s'\n", refId.c_str());
-        return nullptr;
-    }
-
-    asset_info->fIsAttaching = true;
-    auto asset = attach_proc(asset_info->fAsset, ctx);
-    asset_info->fIsAttaching = false;
-
-    return asset;
-}
-
-sk_sp<sksg::RenderNode> AttachCompLayer(const json::ValueRef& jlayer, AttachContext* ctx,
-                                        float* time_bias, float* time_scale) {
-    SkASSERT(jlayer.isObject());
-
-    const auto start_time = jlayer["st"].toDefault(0.0f),
-             stretch_time = jlayer["sr"].toDefault(1.0f);
-
-    *time_bias = -start_time;
-    *time_scale = sk_ieee_float_divide(1, stretch_time);
-    if (SkScalarIsNaN(*time_scale)) {
-        *time_scale = 1;
-    }
-
-    return AttachAssetRef(jlayer, ctx, AttachComposition);
-}
-
-sk_sp<sksg::RenderNode> AttachSolidLayer(const json::ValueRef& jlayer, AttachContext*,
-                                         float*, float*) {
-    SkASSERT(jlayer.isObject());
-
-    const auto size = SkSize::Make(jlayer["sw"].toDefault(0.0f),
-                                   jlayer["sh"].toDefault(0.0f));
-    const auto hex = jlayer["sc"].toDefault(SkString());
-    uint32_t c;
-    if (size.isEmpty() ||
-        !hex.startsWith("#") ||
-        !SkParse::FindHex(hex.c_str() + 1, &c)) {
-        LogFail(jlayer, "Could not parse solid layer");
-        return nullptr;
-    }
-
-    const SkColor color = 0xff000000 | c;
-
-    return sksg::Draw::Make(sksg::Rect::Make(SkRect::MakeSize(size)),
-                            sksg::Color::Make(color));
-}
-
-sk_sp<sksg::RenderNode> AttachImageAsset(const json::ValueRef& jimage, AttachContext* ctx) {
-    SkASSERT(jimage.isObject());
-
-    const auto name = jimage["p"].toDefault(SkString()),
-               path = jimage["u"].toDefault(SkString());
-    if (name.isEmpty())
-        return nullptr;
-
-    // TODO: plumb resource paths explicitly to ResourceProvider?
-    const auto resName    = path.isEmpty() ? name : SkOSPath::Join(path.c_str(), name.c_str());
-    const auto resStream  = ctx->fResources.openStream(resName.c_str());
-    if (!resStream || !resStream->hasLength()) {
-        LOG("!! Could not load image resource: %s\n", resName.c_str());
-        return nullptr;
-    }
-
-    // TODO: non-intrisic image sizing
-    return sksg::Image::Make(
-        SkImage::MakeFromEncoded(SkData::MakeFromStream(resStream.get(), resStream->getLength())));
-}
-
-sk_sp<sksg::RenderNode> AttachImageLayer(const json::ValueRef& jlayer, AttachContext* ctx,
-                                         float*, float*) {
-    SkASSERT(jlayer.isObject());
-
-    return AttachAssetRef(jlayer, ctx, AttachImageAsset);
-}
-
-sk_sp<sksg::RenderNode> AttachNullLayer(const json::ValueRef& layer, AttachContext*, float*, float*) {
-    SkASSERT(layer.isObject());
-
-    // Null layers are used solely to drive dependent transforms,
-    // but we use free-floating sksg::Matrices for that purpose.
-    return nullptr;
-}
-
-sk_sp<sksg::RenderNode> AttachShapeLayer(const json::ValueRef& layer, AttachContext* ctx,
-                                         float*, float*) {
-    SkASSERT(layer.isObject());
-
-    std::vector<sk_sp<sksg::GeometryNode>> geometryStack;
-    std::vector<GeometryEffectRec> geometryEffectStack;
-    AttachShapeContext shapeCtx(ctx, &geometryStack, &geometryEffectStack, ctx->fAnimators.size());
-    auto shapeNode = AttachShape(layer["shapes"], &shapeCtx);
-
-    // Trim uncommitted animators: AttachShape consumes effects on the fly, and greedily attaches
-    // geometries => at the end, we can end up with unused geometries, which are nevertheless alive
-    // due to attached animators.  To avoid this, we track committed animators and discard the
-    // orphans here.
-    SkASSERT(shapeCtx.fCommittedAnimators <= ctx->fAnimators.size());
-    ctx->fAnimators.resize(shapeCtx.fCommittedAnimators);
-
-    return shapeNode;
-}
-
-sk_sp<sksg::RenderNode> AttachTextLayer(const json::ValueRef& layer, AttachContext*, float*, float*) {
-    SkASSERT(layer.isObject());
-
-    LOG("?? Text layer stub\n");
-    return nullptr;
-}
-
-struct AttachLayerContext {
-    AttachLayerContext(const json::ValueRef& jlayers, AttachContext* ctx)
-        : fLayerList(jlayers), fCtx(ctx) {
-        SkASSERT(fLayerList.isArray());
-    }
-
-    const json::ValueRef                 fLayerList;
-    AttachContext*                       fCtx;
-    SkTHashMap<int, sk_sp<sksg::Matrix>> fLayerMatrixMap;
-    sk_sp<sksg::RenderNode>              fCurrentMatte;
-
-    sk_sp<sksg::Matrix> AttachLayerMatrix(const json::ValueRef& jlayer) {
-        SkASSERT(jlayer.isObject());
-
-        const auto layer_index = jlayer["ind"].toDefault<int>(-1);
-        if (layer_index < 0)
-            return nullptr;
-
-        if (auto* m = fLayerMatrixMap.find(layer_index))
-            return *m;
-
-        return this->AttachLayerMatrixImpl(jlayer, layer_index);
-    }
-
-private:
-    sk_sp<sksg::Matrix> AttachParentLayerMatrix(const json::ValueRef& jlayer, int layer_index) {
-        SkASSERT(jlayer.isObject());
-
-        const auto parent_index = jlayer["parent"].toDefault<int>(-1);
-        if (parent_index < 0 || parent_index == layer_index)
-            return nullptr;
-
-        if (auto* m = fLayerMatrixMap.find(parent_index))
-            return *m;
-
-        for (const json::ValueRef l : fLayerList) {
-            if (l["ind"].toDefault<int>(-1) == parent_index) {
-                return this->AttachLayerMatrixImpl(l, parent_index);
-            }
-        }
-
-        return nullptr;
-    }
-
-    sk_sp<sksg::Matrix> AttachLayerMatrixImpl(const json::ValueRef& jlayer, int layer_index) {
-        SkASSERT(!fLayerMatrixMap.find(layer_index));
-
-        // Add a stub entry to break recursion cycles.
-        fLayerMatrixMap.set(layer_index, nullptr);
-
-        auto parent_matrix = this->AttachParentLayerMatrix(jlayer, layer_index);
-
-        return *fLayerMatrixMap.set(layer_index, AttachMatrix(jlayer["ks"], fCtx, parent_matrix));
-    }
-};
-
-SkBlendMode MaskBlendMode(char mode) {
-    switch (mode) {
-    case 'a': return SkBlendMode::kSrcOver;    // Additive
-    case 's': return SkBlendMode::kExclusion;  // Subtract
-    case 'i': return SkBlendMode::kDstIn;      // Intersect
-    case 'l': return SkBlendMode::kLighten;    // Lighten
-    case 'd': return SkBlendMode::kDarken;     // Darken
-    case 'f': return SkBlendMode::kDifference; // Difference
-    default: break;
-    }
-
-    return SkBlendMode::kSrcOver;
-}
-
-sk_sp<sksg::RenderNode> AttachMask(const json::ValueRef& jmask,
-                                   AttachContext* ctx,
-                                   sk_sp<sksg::RenderNode> childNode) {
-    if (!jmask.isArray())
-        return childNode;
-
-    struct MaskRecord {
-        sk_sp<sksg::Path>  mask_path;
-        sk_sp<sksg::Color> mask_paint;
-    };
-
-    SkSTArray<4, MaskRecord, true> mask_stack;
-
-    bool opaque_mask = true;
-
-    for (const json::ValueRef m : jmask) {
-        if (!m.isObject())
-            continue;
-
-        auto mask_path = AttachPath(m["pt"], ctx);
-        if (!mask_path) {
-            LogFail(m, "Could not parse mask path");
-            continue;
-        }
-
-        mask_path->setFillType(m["inv"].toDefault(false)
-            ? SkPath::kInverseWinding_FillType
-            : SkPath::kWinding_FillType);
-
-        SkString mode;
-        if (!m["mode"].to(&mode) ||
-            mode.size() != 1 ||
-            !strcmp(mode.c_str(), "n")) { // "None" masks have no effect.
-            continue;
-        }
-
-        auto mask_paint = sksg::Color::Make(SK_ColorBLACK);
-        mask_paint->setAntiAlias(true);
-        mask_paint->setBlendMode(MaskBlendMode(mode.c_str()[0]));
-
-        const auto animator_count = ctx->fAnimators.size();
-        BindProperty<ScalarValue>(m["o"], &ctx->fAnimators,
-            [mask_paint](const ScalarValue& o) { mask_paint->setOpacity(o * 0.01f); });
-
-        opaque_mask &= (animator_count == ctx->fAnimators.size() && mask_paint->getOpacity() >= 1);
-
-        mask_stack.push_back({mask_path, mask_paint});
-    }
-
-    if (mask_stack.empty())
-        return childNode;
-
-    if (mask_stack.count() == 1 && opaque_mask) {
-        // Single opaque mask => clip path.
-        return sksg::ClipEffect::Make(std::move(childNode),
-                                      std::move(mask_stack.front().mask_path),
-                                      true);
-    }
-
-    auto mask_group = sksg::Group::Make();
-    for (const auto& rec : mask_stack) {
-        mask_group->addChild(sksg::Draw::Make(std::move(rec.mask_path),
-                                              std::move(rec.mask_paint)));
-
-    }
-
-    return sksg::MaskEffect::Make(std::move(childNode), std::move(mask_group));
-}
-
-sk_sp<sksg::RenderNode> AttachLayer(const json::ValueRef& jlayer, AttachLayerContext* layerCtx) {
-    if (!jlayer.isObject())
-        return nullptr;
-
-    using LayerAttacher = sk_sp<sksg::RenderNode> (*)(const json::ValueRef&, AttachContext*,
-                                                      float* time_bias, float* time_scale);
-    static constexpr LayerAttacher gLayerAttachers[] = {
-        AttachCompLayer,  // 'ty': 0
-        AttachSolidLayer, // 'ty': 1
-        AttachImageLayer, // 'ty': 2
-        AttachNullLayer,  // 'ty': 3
-        AttachShapeLayer, // 'ty': 4
-        AttachTextLayer,  // 'ty': 5
-    };
-
-    int type = jlayer["ty"].toDefault<int>(-1);
-    if (type < 0 || type >= SkTo<int>(SK_ARRAY_COUNT(gLayerAttachers))) {
-        return nullptr;
-    }
-
-    sksg::AnimatorList layer_animators;
-    AttachContext local_ctx = { layerCtx->fCtx->fResources,
-                                layerCtx->fCtx->fAssets,
-                                layerCtx->fCtx->fFrameRate,
-                                layer_animators};
-
-    // Layer attachers may adjust these.
-    float time_bias  = 0,
-          time_scale = 1;
-
-    // Layer content.
-    auto layer = gLayerAttachers[type](jlayer, &local_ctx, &time_bias, &time_scale);
-
-    // Clip layers with explicit dimensions.
-    float w = 0, h = 0;
-    if (jlayer["w"].to(&w) && jlayer["h"].to(&h)) {
-        layer = sksg::ClipEffect::Make(std::move(layer),
-                                       sksg::Rect::Make(SkRect::MakeWH(w, h)),
-                                       true);
-    }
-
-    // Optional layer mask.
-    layer = AttachMask(jlayer["masksProperties"], &local_ctx, std::move(layer));
-
-    // Optional layer transform.
-    if (auto layerMatrix = layerCtx->AttachLayerMatrix(jlayer)) {
-        layer = sksg::Transform::Make(std::move(layer), std::move(layerMatrix));
-    }
-
-    // Optional layer opacity.
-    layer = AttachOpacity(jlayer["ks"], &local_ctx, std::move(layer));
-
-    class LayerController final : public sksg::GroupAnimator {
-    public:
-        LayerController(sksg::AnimatorList&& layer_animators,
-                        sk_sp<sksg::OpacityEffect> controlNode,
-                        float in, float out,
-                        float time_bias, float time_scale)
-            : INHERITED(std::move(layer_animators))
-            , fControlNode(std::move(controlNode))
-            , fIn(in)
-            , fOut(out)
-            , fTimeBias(time_bias)
-            , fTimeScale(time_scale) {}
-
-        void onTick(float t) override {
-            const auto active = (t >= fIn && t <= fOut);
-
-            // Keep the layer fully transparent except for its [in..out] lifespan.
-            // (note: opacity == 0 disables rendering, while opacity == 1 is a noop)
-            fControlNode->setOpacity(active ? 1 : 0);
-
-            // Dispatch ticks only while active.
-            if (active)
-                this->INHERITED::onTick((t + fTimeBias) * fTimeScale);
-        }
-
-    private:
-        const sk_sp<sksg::OpacityEffect> fControlNode;
-        const float                      fIn,
-                                         fOut,
-                                         fTimeBias,
-                                         fTimeScale;
-
-        using INHERITED = sksg::GroupAnimator;
-    };
-
-    auto controller_node = sksg::OpacityEffect::Make(std::move(layer));
-    const auto        in = jlayer["ip"].toDefault(0.0f),
-                     out = jlayer["op"].toDefault(in);
-
-    if (!jlayer["tm"].isNull()) {
-        LogFail(jlayer["tm"], "Unsupported time remapping");
-    }
-
-    if (in >= out || !controller_node)
-        return nullptr;
-
-    layerCtx->fCtx->fAnimators.push_back(
-        skstd::make_unique<LayerController>(std::move(layer_animators),
-                                            controller_node,
-                                            in,
-                                            out,
-                                            time_bias,
-                                            time_scale));
-
-    if (jlayer["td"].toDefault(false)) {
-        // This layer is a matte.  We apply it as a mask to the next layer.
-        layerCtx->fCurrentMatte = std::move(controller_node);
-        return nullptr;
-    }
-
-    if (layerCtx->fCurrentMatte) {
-        // There is a pending matte. Apply and reset.
-        static constexpr sksg::MaskEffect::Mode gMaskModes[] = {
-            sksg::MaskEffect::Mode::kNormal, // tt: 1
-            sksg::MaskEffect::Mode::kInvert, // tt: 2
-        };
-        const auto matteType = jlayer["tt"].toDefault<int>(1) - 1;
-
-        if (matteType >= 0 && matteType < SkTo<int>(SK_ARRAY_COUNT(gMaskModes))) {
-            return sksg::MaskEffect::Make(std::move(controller_node),
-                                          std::move(layerCtx->fCurrentMatte),
-                                          gMaskModes[matteType]);
-        }
-        layerCtx->fCurrentMatte.reset();
-    }
-
-    return std::move(controller_node);
-}
-
-sk_sp<sksg::RenderNode> AttachComposition(const json::ValueRef& comp, AttachContext* ctx) {
-    if (!comp.isObject())
-        return nullptr;
-
-    const auto jlayers = comp["layers"];
-    if (!jlayers.isArray())
-        return nullptr;
-
-    SkSTArray<16, sk_sp<sksg::RenderNode>, true> layers;
-    AttachLayerContext                           layerCtx(jlayers, ctx);
-
-    for (const json::ValueRef l : jlayers) {
-        if (auto layer_fragment = AttachLayer(l, &layerCtx)) {
-            layers.push_back(std::move(layer_fragment));
-        }
-    }
-
-    if (layers.empty()) {
-        return nullptr;
-    }
-
-    // Layers are painted in bottom->top order.
-    auto comp_group = sksg::Group::Make();
-    for (int i = layers.count() - 1; i >= 0; --i) {
-        comp_group->addChild(std::move(layers[i]));
-    }
-
-    return std::move(comp_group);
-}
-
-} // namespace
-
-sk_sp<Animation> Animation::Make(SkStream* stream, const ResourceProvider& res, Stats* stats) {
-    Stats stats_storage;
-    if (!stats)
-        stats = &stats_storage;
-    memset(stats, 0, sizeof(struct Stats));
-
-    if (!stream->hasLength()) {
-        // TODO: handle explicit buffering?
-        LOG("!! cannot parse streaming content\n");
-        return nullptr;
-    }
-
-    stats->fJsonSize = stream->getLength();
-    const auto t0 = SkTime::GetMSecs();
-
-    const json::Document doc(stream);
-    const auto json = doc.root();
-    if (!json.isObject())
-        return nullptr;
-
-    const auto t1 = SkTime::GetMSecs();
-    stats->fJsonParseTimeMS = t1 - t0;
-
-    const auto version = json["v"].toDefault(SkString());
-    const auto size    = SkSize::Make(json["w"].toDefault(0.0f),
-                                      json["h"].toDefault(0.0f));
-    const auto fps     = json["fr"].toDefault(-1.0f);
-
-    if (size.isEmpty() || version.isEmpty() || fps <= 0) {
-        LOG("!! invalid animation params (version: %s, size: [%f %f], frame rate: %f)",
-            version.c_str(), size.width(), size.height(), fps);
-        return nullptr;
-    }
-
-    const auto anim =
-        sk_sp<Animation>(new Animation(res, std::move(version), size, fps, json, stats));
-    const auto t2 = SkTime::GetMSecs();
-    stats->fSceneParseTimeMS = t2 - t1;
-    stats->fTotalLoadTimeMS  = t2 - t0;
-
-    return anim;
-}
-
-sk_sp<Animation> Animation::MakeFromFile(const char path[], const ResourceProvider* res,
-                                         Stats* stats) {
-    class DirectoryResourceProvider final : public ResourceProvider {
-    public:
-        explicit DirectoryResourceProvider(SkString dir) : fDir(std::move(dir)) {}
-
-        std::unique_ptr<SkStream> openStream(const char resource[]) const override {
-            const auto resPath = SkOSPath::Join(fDir.c_str(), resource);
-            return SkStream::MakeFromFile(resPath.c_str());
-        }
-
-    private:
-        const SkString fDir;
-    };
-
-    const auto jsonStream =  SkStream::MakeFromFile(path);
-    if (!jsonStream)
-        return nullptr;
-
-    std::unique_ptr<ResourceProvider> defaultProvider;
-    if (!res) {
-        defaultProvider = skstd::make_unique<DirectoryResourceProvider>(SkOSPath::Dirname(path));
-    }
-
-    return Make(jsonStream.get(), res ? *res : *defaultProvider, stats);
-}
-
-Animation::Animation(const ResourceProvider& resources,
-                     SkString version, const SkSize& size, SkScalar fps, const json::ValueRef& json,
-                     Stats* stats)
-    : fVersion(std::move(version))
-    , fSize(size)
-    , fFrameRate(fps)
-    , fInPoint(json["ip"].toDefault(0.0f))
-    , fOutPoint(SkTMax(json["op"].toDefault(SK_ScalarMax), fInPoint)) {
-
-    AssetMap assets;
-    for (const json::ValueRef asset : json["assets"]) {
-        if (asset.isObject()) {
-            assets.set(asset["id"].toDefault(SkString()), { asset, false });
-        }
-    }
-
-    sksg::AnimatorList animators;
-    AttachContext ctx = { resources, assets, fFrameRate, animators };
-    auto root = AttachComposition(json, &ctx);
-
-    stats->fAnimatorCount = animators.size();
-
-    fScene = sksg::Scene::Make(std::move(root), std::move(animators));
-
-    // In case the client calls render before the first tick.
-    this->animationTick(0);
-}
-
-Animation::~Animation() = default;
-
-void Animation::setShowInval(bool show) {
-    if (fScene) {
-        fScene->setShowInval(show);
-    }
-}
-
-void Animation::render(SkCanvas* canvas, const SkRect* dstR) const {
-    if (!fScene)
-        return;
-
-    SkAutoCanvasRestore restore(canvas, true);
-    const SkRect srcR = SkRect::MakeSize(this->size());
-    if (dstR) {
-        canvas->concat(SkMatrix::MakeRectToRect(srcR, *dstR, SkMatrix::kCenter_ScaleToFit));
-    }
-    canvas->clipRect(srcR);
-    fScene->render(canvas);
-}
-
-void Animation::animationTick(SkMSec ms) {
-    if (!fScene)
-        return;
-
-    // 't' in the BM model really means 'frame #'
-    auto t = static_cast<float>(ms) * fFrameRate / 1000;
-
-    t = fInPoint + std::fmod(t, fOutPoint - fInPoint);
-
-    fScene->animate(t);
-}
-
-} // namespace skottie
diff --git a/experimental/skottie/Skottie.h b/experimental/skottie/Skottie.h
deleted file mode 100644
index 0a89ca0438..0000000000
--- a/experimental/skottie/Skottie.h
+++ /dev/null
@@ -1,80 +0,0 @@
-/*
- * Copyright 2017 Google Inc.
- *
- * Use of this source code is governed by a BSD-style license that can be
- * found in the LICENSE file.
- */
-
-#ifndef Skottie_DEFINED
-#define Skottie_DEFINED
-
-#include "SkRefCnt.h"
-#include "SkSize.h"
-#include "SkString.h"
-#include "SkTypes.h"
-
-#include <memory>
-
-class SkCanvas;
-struct SkRect;
-class SkStream;
-
-namespace sksg { class Scene;  }
-
-namespace skottie {
-
-namespace json { class ValueRef; }
-
-class SK_API ResourceProvider : public SkNoncopyable {
-public:
-    virtual ~ResourceProvider() = default;
-
-    virtual std::unique_ptr<SkStream> openStream(const char resource[]) const = 0;
-};
-
-class SK_API Animation : public SkRefCnt {
-public:
-    struct Stats {
-        float  fTotalLoadTimeMS,
-               fJsonParseTimeMS,
-               fSceneParseTimeMS;
-        size_t fJsonSize,
-               fAnimatorCount;
-    };
-
-    static sk_sp<Animation> Make(SkStream*, const ResourceProvider&, Stats* = nullptr);
-    static sk_sp<Animation> MakeFromFile(const char path[], const ResourceProvider* = nullptr,
-                                         Stats* = nullptr);
-
-    ~Animation() override;
-
-    void render(SkCanvas*, const SkRect* dst = nullptr) const;
-
-    void animationTick(SkMSec);
-
-    const SkString& version() const { return fVersion;   }
-    const SkSize&      size() const { return fSize;      }
-         SkScalar frameRate() const { return fFrameRate; }
-         SkScalar   inPoint() const { return fInPoint;   }
-         SkScalar  outPoint() const { return fOutPoint;  }
-
-    void setShowInval(bool show);
-
-private:
-    Animation(const ResourceProvider&, SkString ver, const SkSize& size, SkScalar fps,
-              const json::ValueRef&, Stats*);
-
-    SkString                     fVersion;
-    SkSize                       fSize;
-    SkScalar                     fFrameRate,
-                                 fInPoint,
-                                 fOutPoint;
-
-    std::unique_ptr<sksg::Scene> fScene;
-
-    typedef SkRefCnt INHERITED;
-};
-
-} // namespace skottie
-
-#endif // Skottie_DEFINED
diff --git a/experimental/skottie/SkottieAdapter.cpp b/experimental/skottie/SkottieAdapter.cpp
deleted file mode 100644
index a01599ccf6..0000000000
--- a/experimental/skottie/SkottieAdapter.cpp
+++ /dev/null
@@ -1,166 +0,0 @@
-/*
- * Copyright 2018 Google Inc.
- *
- * Use of this source code is governed by a BSD-style license that can be
- * found in the LICENSE file.
- */
-
-#include "SkottieAdapter.h"
-
-#include "SkMatrix.h"
-#include "SkottieValue.h"
-#include "SkPath.h"
-#include "SkRRect.h"
-#include "SkSGGradient.h"
-#include "SkSGPath.h"
-#include "SkSGRect.h"
-#include "SkSGTransform.h"
-#include "SkSGTrimEffect.h"
-
-#include <cmath>
-
-namespace skottie {
-
-RRectAdapter::RRectAdapter(sk_sp<sksg::RRect> wrapped_node)
-    : fRRectNode(std::move(wrapped_node)) {}
-
-void RRectAdapter::apply() {
-    // BM "position" == "center position"
-    auto rr = SkRRect::MakeRectXY(SkRect::MakeXYWH(fPosition.x() - fSize.width() / 2,
-                                                   fPosition.y() - fSize.height() / 2,
-                                                   fSize.width(), fSize.height()),
-                                  fRadius.width(),
-                                  fRadius.height());
-   fRRectNode->setRRect(rr);
-}
-
-TransformAdapter::TransformAdapter(sk_sp<sksg::Matrix> matrix)
-    : fMatrixNode(std::move(matrix)) {}
-
-void TransformAdapter::apply() {
-    SkMatrix t = SkMatrix::MakeTrans(-fAnchorPoint.x(), -fAnchorPoint.y());
-
-    t.postScale(fScale.x() / 100, fScale.y() / 100); // 100% based
-    t.postRotate(fRotation);
-    t.postTranslate(fPosition.x(), fPosition.y());
-    // TODO: skew
-
-    fMatrixNode->setMatrix(t);
-}
-
-PolyStarAdapter::PolyStarAdapter(sk_sp<sksg::Path> wrapped_node, Type t)
-    : fPathNode(std::move(wrapped_node))
-    , fType(t) {}
-
-void PolyStarAdapter::apply() {
-    static constexpr int kMaxPointCount = 100000;
-    const auto count = SkToUInt(SkTPin(SkScalarRoundToInt(fPointCount), 0, kMaxPointCount));
-    const auto arc   = sk_ieee_float_divide(SK_ScalarPI * 2, count);
-
-    const auto pt_on_circle = [](const SkPoint& c, SkScalar r, SkScalar a) {
-        return SkPoint::Make(c.x() + r * std::cos(a),
-                             c.y() + r * std::sin(a));
-    };
-
-    // TODO: inner/outer "roundness"?
-
-    SkPath poly;
-
-    auto angle = SkDegreesToRadians(fRotation);
-    poly.moveTo(pt_on_circle(fPosition, fOuterRadius, angle));
-    poly.incReserve(fType == Type::kStar ? count * 2 : count);
-
-    for (unsigned i = 0; i < count; ++i) {
-        if (fType == Type::kStar) {
-            poly.lineTo(pt_on_circle(fPosition, fInnerRadius, angle + arc * 0.5f));
-        }
-        angle += arc;
-        poly.lineTo(pt_on_circle(fPosition, fOuterRadius, angle));
-    }
-
-    poly.close();
-    fPathNode->setPath(poly);
-}
-
-GradientAdapter::GradientAdapter(sk_sp<sksg::Gradient> grad, size_t stopCount)
-    : fGradient(std::move(grad))
-    , fStopCount(stopCount) {}
-
-void GradientAdapter::apply() {
-    this->onApply();
-
-    // |fColorStops| holds |fStopCount| x [ pos, r, g, g ] + ? x [ pos, alpha ]
-
-    if (fColorStops.size() < fStopCount * 4 || ((fColorStops.size() - fStopCount * 4) % 2)) {
-        SkDebugf("!! Invalid gradient stop array size: %zu", fColorStops.size());
-        return;
-    }
-
-    std::vector<sksg::Gradient::ColorStop> stops;
-
-    // TODO: merge/lerp opacity stops
-    const auto csEnd = fColorStops.cbegin() + fStopCount * 4;
-    for (auto cs = fColorStops.cbegin(); cs != csEnd; cs += 4) {
-        const auto pos = cs[0];
-        const VectorValue rgb({ cs[1], cs[2], cs[3] });
-
-        stops.push_back({ pos, ValueTraits<VectorValue>::As<SkColor>(rgb) });
-    }
-
-    fGradient->setColorStops(std::move(stops));
-}
-
-LinearGradientAdapter::LinearGradientAdapter(sk_sp<sksg::LinearGradient> grad, size_t stopCount)
-    : INHERITED(std::move(grad), stopCount) {}
-
-void LinearGradientAdapter::onApply() {
-    auto* grad = static_cast<sksg::LinearGradient*>(fGradient.get());
-    grad->setStartPoint(this->startPoint());
-    grad->setEndPoint(this->endPoint());
-}
-
-RadialGradientAdapter::RadialGradientAdapter(sk_sp<sksg::RadialGradient> grad, size_t stopCount)
-    : INHERITED(std::move(grad), stopCount) {}
-
-void RadialGradientAdapter::onApply() {
-    auto* grad = static_cast<sksg::RadialGradient*>(fGradient.get());
-    grad->setStartCenter(this->startPoint());
-    grad->setEndCenter(this->startPoint());
-    grad->setStartRadius(0);
-    grad->setEndRadius(SkPoint::Distance(this->startPoint(), this->endPoint()));
-}
-
-TrimEffectAdapter::TrimEffectAdapter(sk_sp<sksg::TrimEffect> trimEffect)
-    : fTrimEffect(std::move(trimEffect)) {
-    SkASSERT(fTrimEffect);
-}
-
-void TrimEffectAdapter::apply() {
-    // BM semantics: start/end are percentages, offset is "degrees" (?!).
-    const auto  start = fStart  / 100,
-                  end = fEnd    / 100,
-               offset = fOffset / 360;
-
-    auto startT = SkTMin(start, end) + offset,
-          stopT = SkTMax(start, end) + offset;
-    auto   mode = SkTrimPathEffect::Mode::kNormal;
-
-    if (stopT - startT < 1) {
-        startT -= SkScalarFloorToScalar(startT);
-        stopT  -= SkScalarFloorToScalar(stopT);
-
-        if (startT > stopT) {
-            SkTSwap(startT, stopT);
-            mode = SkTrimPathEffect::Mode::kInverted;
-        }
-    } else {
-        startT = 0;
-        stopT  = 1;
-    }
-
-    fTrimEffect->setStart(startT);
-    fTrimEffect->setStop(stopT);
-    fTrimEffect->setMode(mode);
-}
-
-} // namespace skottie
diff --git a/experimental/skottie/SkottieAdapter.h b/experimental/skottie/SkottieAdapter.h
deleted file mode 100644
index e96c616fcf..0000000000
--- a/experimental/skottie/SkottieAdapter.h
+++ /dev/null
@@ -1,164 +0,0 @@
-/*
- * Copyright 2018 Google Inc.
- *
- * Use of this source code is governed by a BSD-style license that can be
- * found in the LICENSE file.
- */
-
-#ifndef SkottieAdapter_DEFINED
-#define SkottieAdapter_DEFINED
-
-#include "SkPoint.h"
-#include "SkRefCnt.h"
-#include "SkSize.h"
-
-#include <vector>
-
-namespace sksg {
-
-class Gradient;
-class LinearGradient;
-class Matrix;
-class Path;
-class RadialGradient;
-class RRect;
-class TrimEffect;
-
-};
-
-namespace skottie {
-
-#define ADAPTER_PROPERTY(p_name, p_type, p_default) \
-    void set##p_name(const p_type& p) {             \
-        if (p == f##p_name) return;                 \
-        f##p_name = p;                              \
-        this->apply();                              \
-    }                                               \
-  private:                                          \
-    p_type f##p_name = p_default;                   \
-  public:
-
-class RRectAdapter final : public SkRefCnt {
-public:
-    explicit RRectAdapter(sk_sp<sksg::RRect>);
-
-    ADAPTER_PROPERTY(Position, SkPoint , SkPoint::Make(0, 0))
-    ADAPTER_PROPERTY(Size    , SkSize  ,  SkSize::Make(0, 0))
-    ADAPTER_PROPERTY(Radius  , SkSize  ,  SkSize::Make(0, 0))
-
-private:
-    void apply();
-
-    sk_sp<sksg::RRect> fRRectNode;
-
-    using INHERITED = SkRefCnt;
-};
-
-class PolyStarAdapter final : public SkRefCnt {
-public:
-    enum class Type {
-        kStar, kPoly,
-    };
-
-    PolyStarAdapter(sk_sp<sksg::Path>, Type);
-
-    ADAPTER_PROPERTY(Position      , SkPoint , SkPoint::Make(0, 0))
-    ADAPTER_PROPERTY(PointCount    , SkScalar, 0)
-    ADAPTER_PROPERTY(InnerRadius   , SkScalar, 0)
-    ADAPTER_PROPERTY(OuterRadius   , SkScalar, 0)
-    ADAPTER_PROPERTY(InnerRoundness, SkScalar, 0)
-    ADAPTER_PROPERTY(OuterRoundness, SkScalar, 0)
-    ADAPTER_PROPERTY(Rotation      , SkScalar, 0)
-
-private:
-    void apply();
-
-    sk_sp<sksg::Path> fPathNode;
-    Type              fType;
-
-    using INHERITED = SkRefCnt;
-};
-
-class TransformAdapter final : public SkRefCnt {
-public:
-    explicit TransformAdapter(sk_sp<sksg::Matrix>);
-
-    ADAPTER_PROPERTY(AnchorPoint, SkPoint , SkPoint::Make(0, 0))
-    ADAPTER_PROPERTY(Position   , SkPoint , SkPoint::Make(0, 0))
-    ADAPTER_PROPERTY(Scale      , SkVector, SkPoint::Make(100, 100))
-    ADAPTER_PROPERTY(Rotation   , SkScalar, 0)
-    ADAPTER_PROPERTY(Skew       , SkScalar, 0)
-    ADAPTER_PROPERTY(SkewAxis   , SkScalar, 0)
-
-private:
-    void apply();
-
-    sk_sp<sksg::Matrix> fMatrixNode;
-
-    using INHERITED = SkRefCnt;
-};
-
-class GradientAdapter : public SkRefCnt {
-public:
-    ADAPTER_PROPERTY(StartPoint, SkPoint              , SkPoint::Make(0, 0)    )
-    ADAPTER_PROPERTY(EndPoint  , SkPoint              , SkPoint::Make(0, 0)    )
-    ADAPTER_PROPERTY(ColorStops, std::vector<SkScalar>, std::vector<SkScalar>())
-
-protected:
-    GradientAdapter(sk_sp<sksg::Gradient>, size_t stopCount);
-
-    const SkPoint& startPoint() const { return fStartPoint; }
-    const SkPoint& endPoint()   const { return fEndPoint;   }
-
-    sk_sp<sksg::Gradient> fGradient;
-    size_t                fStopCount;
-
-    virtual void onApply() = 0;
-
-private:
-    void apply();
-
-    using INHERITED = SkRefCnt;
-};
-
-class LinearGradientAdapter final : public GradientAdapter {
-public:
-    LinearGradientAdapter(sk_sp<sksg::LinearGradient>, size_t stopCount);
-
-private:
-    void onApply() override;
-
-    using INHERITED = GradientAdapter;
-};
-
-class RadialGradientAdapter final : public GradientAdapter {
-public:
-    RadialGradientAdapter(sk_sp<sksg::RadialGradient>, size_t stopCount);
-
-private:
-    void onApply() override;
-
-    using INHERITED = GradientAdapter;
-};
-
-class TrimEffectAdapter final : public SkRefCnt {
-public:
-    explicit TrimEffectAdapter(sk_sp<sksg::TrimEffect>);
-
-    ADAPTER_PROPERTY(Start , SkScalar,   0)
-    ADAPTER_PROPERTY(End   , SkScalar, 100)
-    ADAPTER_PROPERTY(Offset, SkScalar,   0)
-
-private:
-    void apply();
-
-    sk_sp<sksg::TrimEffect> fTrimEffect;
-
-    using INHERITED = SkRefCnt;
-};
-
-#undef ADAPTER_PROPERTY
-
-} // namespace skottie
-
-#endif // SkottieAdapter_DEFINED
diff --git a/experimental/skottie/SkottieAnimator.cpp b/experimental/skottie/SkottieAnimator.cpp
deleted file mode 100644
index 4554409761..0000000000
--- a/experimental/skottie/SkottieAnimator.cpp
+++ /dev/null
@@ -1,374 +0,0 @@
-/*
- * Copyright 2017 Google Inc.
- *
- * Use of this source code is governed by a BSD-style license that can be
- * found in the LICENSE file.
- */
-
-#include "SkottieAnimator.h"
-
-#include "SkCubicMap.h"
-#include "SkottieJson.h"
-#include "SkottieValue.h"
-#include "SkString.h"
-#include "SkTArray.h"
-
-#include <memory>
-
-namespace skottie {
-
-namespace {
-
-#define LOG SkDebugf
-
-bool LogFail(const json::ValueRef& json, const char* msg) {
-    const auto dump = json.toString();
-    LOG("!! %s: %s\n", msg, dump.c_str());
-    return false;
-}
-
-class KeyframeAnimatorBase : public sksg::Animator {
-public:
-    int count() const { return fRecs.count(); }
-
-protected:
-    KeyframeAnimatorBase() = default;
-
-    struct KeyframeRec {
-        float t0, t1;
-        int   vidx0, vidx1, // v0/v1 indices
-              cmidx;        // cubic map index
-
-        bool contains(float t) const { return t0 <= t && t <= t1; }
-        bool isConstant() const { return vidx0 == vidx1; }
-        bool isValid() const {
-            SkASSERT(t0 <= t1);
-            // Constant frames don't need/use t1 and vidx1.
-            return t0 < t1 || this->isConstant();
-        }
-    };
-
-    const KeyframeRec& frame(float t) {
-        if (!fCachedRec || !fCachedRec->contains(t)) {
-            fCachedRec = findFrame(t);
-        }
-        return *fCachedRec;
-    }
-
-    float localT(const KeyframeRec& rec, float t) const {
-        SkASSERT(rec.isValid());
-        SkASSERT(!rec.isConstant());
-        SkASSERT(t > rec.t0 && t < rec.t1);
-
-        auto lt = (t - rec.t0) / (rec.t1 - rec.t0);
-
-        return rec.cmidx < 0
-            ? lt
-            : SkTPin(fCubicMaps[rec.cmidx].computeYFromX(lt), 0.0f, 1.0f);
-    }
-
-    virtual int parseValue(const json::ValueRef&) = 0;
-
-    void parseKeyFrames(const json::ValueRef& jframes) {
-        if (!jframes.isArray())
-            return;
-
-        for (const json::ValueRef jframe : jframes) {
-            float t0;
-            if (!jframe["t"].to(&t0))
-                continue;
-
-            if (!fRecs.empty()) {
-                if (fRecs.back().t1 >= t0) {
-                    LOG("!! Ignoring out-of-order key frame (t:%f < t:%f)\n", t0, fRecs.back().t1);
-                    continue;
-                }
-                // Back-fill t1 in prev interval.  Note: we do this even if we end up discarding
-                // the current interval (to support "t"-only final frames).
-                fRecs.back().t1 = t0;
-            }
-
-            const auto vidx0 = this->parseValue(jframe["s"]);
-            if (vidx0 < 0)
-                continue;
-
-            // Defaults for constant frames.
-            int vidx1 = vidx0, cmidx = -1;
-
-            if (!jframe["h"].toDefault(false)) {
-                // Regular frame, requires an end value.
-                vidx1 = this->parseValue(jframe["e"]);
-                if (vidx1 < 0)
-                    continue;
-
-                // default is linear lerp
-                static constexpr SkPoint kDefaultC0 = { 0, 0 },
-                                         kDefaultC1 = { 1, 1 };
-                const auto c0 = jframe["i"].toDefault(kDefaultC0),
-                           c1 = jframe["o"].toDefault(kDefaultC1);
-
-                if (c0 != kDefaultC0 || c1 != kDefaultC1) {
-                    // TODO: is it worth de-duping these?
-                    cmidx = fCubicMaps.count();
-                    fCubicMaps.emplace_back();
-                    // TODO: why do we have to plug these inverted?
-                    fCubicMaps.back().setPts(c1, c0);
-                }
-            }
-
-            fRecs.push_back({t0, t0, vidx0, vidx1, cmidx });
-        }
-
-        // If we couldn't determine a valid t1 for the last frame, discard it.
-        if (!fRecs.empty() && !fRecs.back().isValid()) {
-            fRecs.pop_back();
-        }
-
-        SkASSERT(fRecs.empty() || fRecs.back().isValid());
-    }
-
-private:
-    const KeyframeRec* findFrame(float t) const {
-        SkASSERT(!fRecs.empty());
-
-        auto f0 = &fRecs.front(),
-             f1 = &fRecs.back();
-
-        SkASSERT(f0->isValid());
-        SkASSERT(f1->isValid());
-
-        if (t < f0->t0) {
-            return f0;
-        }
-
-        if (t > f1->t1) {
-            return f1;
-        }
-
-        while (f0 != f1) {
-            SkASSERT(f0 < f1);
-            SkASSERT(t >= f0->t0 && t <= f1->t1);
-
-            const auto f = f0 + (f1 - f0) / 2;
-            SkASSERT(f->isValid());
-
-            if (t > f->t1) {
-                f0 = f + 1;
-            } else {
-                f1 = f;
-            }
-        }
-
-        SkASSERT(f0 == f1);
-        SkASSERT(f0->contains(t));
-
-        return f0;
-    }
-
-    SkTArray<KeyframeRec> fRecs;
-    SkTArray<SkCubicMap>  fCubicMaps;
-    const KeyframeRec*    fCachedRec = nullptr;
-
-    using INHERITED = sksg::Animator;
-};
-
-template <typename T>
-class KeyframeAnimator final : public KeyframeAnimatorBase {
-public:
-    static std::unique_ptr<KeyframeAnimator> Make(const json::ValueRef& jframes,
-                                                  std::function<void(const T&)>&& apply) {
-        std::unique_ptr<KeyframeAnimator> animator(new KeyframeAnimator(jframes, std::move(apply)));
-        if (!animator->count())
-            return nullptr;
-
-        return animator;
-    }
-
-protected:
-    void onTick(float t) override {
-        T val;
-        this->eval(this->frame(t), t, &val);
-
-        fApplyFunc(val);
-    }
-
-private:
-    KeyframeAnimator(const json::ValueRef& jframes,
-                     std::function<void(const T&)>&& apply)
-        : fApplyFunc(std::move(apply)) {
-        this->parseKeyFrames(jframes);
-    }
-
-    int parseValue(const json::ValueRef& jv) override {
-        T val;
-        if (!jv.to(&val) || (!fVs.empty() &&
-                ValueTraits<T>::Cardinality(val) != ValueTraits<T>::Cardinality(fVs.back()))) {
-            return -1;
-        }
-
-        // TODO: full deduping?
-        if (fVs.empty() || val != fVs.back()) {
-            fVs.push_back(std::move(val));
-        }
-        return fVs.count() - 1;
-    }
-
-    void eval(const KeyframeRec& rec, float t, T* v) const {
-        SkASSERT(rec.isValid());
-        if (rec.isConstant() || t <= rec.t0) {
-            *v = fVs[rec.vidx0];
-        } else if (t >= rec.t1) {
-            *v = fVs[rec.vidx1];
-        } else {
-            const auto lt = this->localT(rec, t);
-            const auto& v0 = fVs[rec.vidx0];
-            const auto& v1 = fVs[rec.vidx1];
-            *v = ValueTraits<T>::Lerp(v0, v1, lt);
-        }
-    }
-
-    const std::function<void(const T&)> fApplyFunc;
-    SkTArray<T>                         fVs;
-
-
-    using INHERITED = KeyframeAnimatorBase;
-};
-
-template <typename T>
-static inline bool BindPropertyImpl(const json::ValueRef& jprop,
-                                    sksg::AnimatorList* animators,
-                                    std::function<void(const T&)>&& apply,
-                                    const T* noop = nullptr) {
-    if (!jprop.isObject())
-        return false;
-
-    const auto jpropA = jprop["a"];
-    const auto jpropK = jprop["k"];
-
-    // Older Json versions don't have an "a" animation marker.
-    // For those, we attempt to parse both ways.
-    if (!jpropA.toDefault(false)) {
-        T val;
-        if (jpropK.to<T>(&val)) {
-            // Static property.
-            if (noop && val == *noop)
-                return false;
-
-            apply(val);
-            return true;
-        }
-
-        if (!jpropA.isNull()) {
-            return LogFail(jprop, "Could not parse (explicit) static property");
-        }
-    }
-
-    // Keyframe property.
-    auto animator = KeyframeAnimator<T>::Make(jpropK, std::move(apply));
-
-    if (!animator) {
-        return LogFail(jprop, "Could not parse keyframed property");
-    }
-
-    animators->push_back(std::move(animator));
-
-    return true;
-}
-
-class SplitPointAnimator final : public sksg::Animator {
-public:
-    static std::unique_ptr<SplitPointAnimator> Make(const json::ValueRef& jprop,
-                                                    std::function<void(const VectorValue&)>&& apply,
-                                                    const VectorValue*) {
-        if (!jprop.isObject())
-            return nullptr;
-
-        std::unique_ptr<SplitPointAnimator> split_animator(
-            new SplitPointAnimator(std::move(apply)));
-
-        // This raw pointer is captured in lambdas below. But the lambdas are owned by
-        // the object itself, so the scope is bound to the life time of the object.
-        auto* split_animator_ptr = split_animator.get();
-
-        if (!BindPropertyImpl<ScalarValue>(jprop["x"], &split_animator->fAnimators,
-                [split_animator_ptr](const ScalarValue& x) { split_animator_ptr->setX(x); }) ||
-            !BindPropertyImpl<ScalarValue>(jprop["y"], &split_animator->fAnimators,
-                [split_animator_ptr](const ScalarValue& y) { split_animator_ptr->setY(y); })) {
-            LogFail(jprop, "Could not parse split property");
-            return nullptr;
-        }
-
-        if (split_animator->fAnimators.empty()) {
-            // Static split property, no need to hold on to the split animator.
-            return nullptr;
-        }
-
-        return split_animator;
-    }
-
-    void onTick(float t) override {
-        for (const auto& animator : fAnimators) {
-            animator->tick(t);
-        }
-
-        const VectorValue vec = { fX, fY };
-        fApplyFunc(vec);
-    }
-
-    void setX(const ScalarValue& x) { fX = x; }
-    void setY(const ScalarValue& y) { fY = y; }
-
-private:
-    explicit SplitPointAnimator(std::function<void(const VectorValue&)>&& apply)
-        : fApplyFunc(std::move(apply)) {}
-
-    const std::function<void(const VectorValue&)> fApplyFunc;
-    sksg::AnimatorList                            fAnimators;
-
-    ScalarValue                                   fX = 0,
-                                                  fY = 0;
-
-    using INHERITED = sksg::Animator;
-};
-
-bool BindSplitPositionProperty(const json::ValueRef& jprop,
-                               sksg::AnimatorList* animators,
-                               std::function<void(const VectorValue&)>&& apply,
-                               const VectorValue* noop) {
-    if (auto split_animator = SplitPointAnimator::Make(jprop, std::move(apply), noop)) {
-        animators->push_back(std::unique_ptr<sksg::Animator>(split_animator.release()));
-        return true;
-    }
-
-    return false;
-}
-
-} // namespace
-
-template <>
-bool BindProperty(const json::ValueRef& jprop,
-                  sksg::AnimatorList* animators,
-                  std::function<void(const ScalarValue&)>&& apply,
-                  const ScalarValue* noop) {
-    return BindPropertyImpl(jprop, animators, std::move(apply), noop);
-}
-
-template <>
-bool BindProperty(const json::ValueRef& jprop,
-                  sksg::AnimatorList* animators,
-                  std::function<void(const VectorValue&)>&& apply,
-                  const VectorValue* noop) {
-    return jprop["s"].toDefault<bool>(false)
-        ? BindSplitPositionProperty(jprop, animators, std::move(apply), noop)
-        : BindPropertyImpl(jprop, animators, std::move(apply), noop);
-}
-
-template <>
-bool BindProperty(const json::ValueRef& jprop,
-                  sksg::AnimatorList* animators,
-                  std::function<void(const ShapeValue&)>&& apply,
-                  const ShapeValue* noop) {
-    return BindPropertyImpl(jprop, animators, std::move(apply), noop);
-}
-
-} // namespace skottie
diff --git a/experimental/skottie/SkottieAnimator.h b/experimental/skottie/SkottieAnimator.h
deleted file mode 100644
index 6dc8f6c759..0000000000
--- a/experimental/skottie/SkottieAnimator.h
+++ /dev/null
@@ -1,29 +0,0 @@
-/*
- * Copyright 2017 Google Inc.
- *
- * Use of this source code is governed by a BSD-style license that can be
- * found in the LICENSE file.
- */
-
-#ifndef SkottieAnimator_DEFINED
-#define SkottieAnimator_DEFINED
-
-#include "SkSGScene.h"
-
-#include <functional>
-
-namespace skottie {
-
-namespace json { class ValueRef; }
-
-// This is the workhorse for property binding: depending on whether the property is animated,
-// it will either apply immediately or instantiate and attach a keyframe animator.
-template <typename T>
-bool BindProperty(const json::ValueRef&,
-                  sksg::AnimatorList*,
-                  std::function<void(const T&)>&&,
-                  const T* noop = nullptr);
-
-} // namespace skottie
-
-#endif // SkottieAnimator_DEFINED
diff --git a/experimental/skottie/SkottieJson.cpp b/experimental/skottie/SkottieJson.cpp
deleted file mode 100644
index 23e616d1ea..0000000000
--- a/experimental/skottie/SkottieJson.cpp
+++ /dev/null
@@ -1,243 +0,0 @@
-/*
- * Copyright 2018 Google Inc.
- *
- * Use of this source code is governed by a BSD-style license that can be
- * found in the LICENSE file.
- */
-
-#include "SkottieJson.h"
-
-#include "SkData.h"
-#include "SkScalar.h"
-#include "SkPath.h"
-#include "SkPoint.h"
-#include "SkStream.h"
-#include "SkString.h"
-#include "SkottieValue.h"
-
-#include "rapidjson/error/en.h"
-#include "rapidjson/prettywriter.h"
-#include "rapidjson/stringbuffer.h"
-
-#include <vector>
-
-namespace skottie {
-
-namespace json {
-
-template <>
-bool ValueRef::to<SkScalar>(SkScalar* v) const {
-    if (!fValue) return false;
-
-    // Some versions wrap values as single-element arrays.
-    if (fValue->IsArray() && fValue->Size() == 1) {
-        return ValueRef(fValue->operator[](0)).to(v);
-    }
-
-    if (!fValue->IsNumber())
-        return false;
-
-    *v = static_cast<SkScalar>(fValue->GetDouble());
-
-    return true;
-}
-
-template <>
-bool ValueRef::to<bool>(bool* v) const {
-    if (!fValue) return false;
-
-    switch(fValue->GetType()) {
-    case rapidjson::kNumberType:
-        *v = SkToBool(fValue->GetDouble());
-        return true;
-    case rapidjson::kFalseType:
-    case rapidjson::kTrueType:
-        *v = fValue->GetBool();
-        return true;
-    default:
-        break;
-    }
-
-    return false;
-}
-
-template <>
-bool ValueRef::to<int>(int* v) const {
-    if (!fValue || !fValue->IsInt())
-        return false;
-
-    *v = fValue->GetInt();
-
-    return true;
-}
-
-template <>
-bool ValueRef::to<SkString>(SkString* v) const {
-    if (!fValue || !fValue->IsString())
-        return false;
-
-    v->set(fValue->GetString());
-
-    return true;
-}
-
-template <>
-bool ValueRef::to<SkPoint>(SkPoint* v) const {
-    if (!fValue || !fValue->IsObject())
-        return false;
-
-    const auto jvx = ValueRef(this->operator[]("x")),
-               jvy = ValueRef(this->operator[]("y"));
-
-    // Some BM versions seem to store x/y as single-element arrays.
-    return ValueRef(jvx.isArray() ? jvx.operator[](size_t(0)) : jvx).to(&v->fX)
-        && ValueRef(jvy.isArray() ? jvy.operator[](size_t(0)) : jvy).to(&v->fY);
-}
-
-template <>
-bool ValueRef::to<std::vector<float>>(std::vector<float>* v) const {
-    if (!fValue || !fValue->IsArray())
-        return false;
-
-    v->resize(fValue->Size());
-    for (size_t i = 0; i < fValue->Size(); ++i) {
-        if (!ValueRef(fValue->operator[](i)).to(v->data() + i)) {
-            return false;
-        }
-    }
-
-    return true;
-}
-
-namespace {
-
-bool ParsePointVec(const ValueRef& jv, std::vector<SkPoint>* pts) {
-    if (!jv.isArray())
-        return false;
-
-    pts->clear();
-    pts->reserve(jv.size());
-
-    std::vector<float> vec;
-    for (size_t i = 0; i < jv.size(); ++i) {
-        if (!jv[i].to(&vec) || vec.size() != 2)
-            return false;
-        pts->push_back(SkPoint::Make(vec[0], vec[1]));
-    }
-
-    return true;
-}
-
-} // namespace
-
-template <>
-bool ValueRef::to<ShapeValue>(ShapeValue* v) const {
-    SkASSERT(v->fVertices.empty());
-
-    if (!fValue)
-        return false;
-
-    // Some versions wrap values as single-element arrays.
-    if (fValue->IsArray() && fValue->Size() == 1) {
-        return ValueRef(fValue->operator[](0)).to(v);
-    }
-
-    std::vector<SkPoint> inPts,  // Cubic Bezier "in" control points, relative to vertices.
-                         outPts, // Cubic Bezier "out" control points, relative to vertices.
-                         verts;  // Cubic Bezier vertices.
-
-    if (!fValue->IsObject() ||
-        !ParsePointVec(this->operator[]("i"), &inPts) ||
-        !ParsePointVec(this->operator[]("o"), &outPts) ||
-        !ParsePointVec(this->operator[]("v"), &verts) ||
-        inPts.size() != outPts.size() ||
-        inPts.size() != verts.size()) {
-
-        return false;
-    }
-
-    v->fVertices.reserve(inPts.size());
-    for (size_t i = 0; i < inPts.size(); ++i) {
-        v->fVertices.push_back(BezierVertex({inPts[i], outPts[i], verts[i]}));
-    }
-    v->fClosed = this->operator[]("c").toDefault<bool>(false);
-
-    return true;
-}
-
-size_t ValueRef::size() const {
-    return this->isArray() ? fValue->Size() : 0;
-}
-
-ValueRef ValueRef::operator[](size_t i) const {
-    return i < this->size() ? ValueRef(fValue->operator[](i)) : ValueRef();
-}
-
-ValueRef ValueRef::operator[](const char* key) const {
-    if (!this->isObject())
-        return ValueRef();
-
-    const auto m = fValue->FindMember(key);
-    return m == fValue->MemberEnd() ? ValueRef() : ValueRef(m->value);
-}
-
-const rapidjson::Value* ValueRef::begin() const {
-    return this->isArray() ? fValue->Begin() : nullptr;
-}
-
-const rapidjson::Value* ValueRef::end() const {
-    return this->isArray() ? fValue->End() : nullptr;
-}
-
-SkString ValueRef::toString() const {
-#ifdef SK_DEBUG
-    rapidjson::StringBuffer buf;
-    if (fValue) {
-        rapidjson::PrettyWriter<rapidjson::StringBuffer> writer(buf);
-        fValue->Accept(writer);
-    }
-
-    return SkString(buf.GetString());
-#else
-    return SkString();
-#endif // SK_DEBUG
-}
-
-Document::Document(SkStream* stream) {
-    if (!stream->hasLength()) {
-        SkDebugf("!! unsupported unseekable json stream\n");
-        return;
-    }
-
-    // RapidJSON provides three DOM-builder approaches:
-    //
-    //   1) in-place   : all data buffered, constructs the DOM in-place -- this is the fastest
-    //   2) from buffer: all data buffered, copies to DOM -- this is slightly slower
-    //   3) from stream: streamed data, reads/copies to DOM -- this is *significantly* slower
-    //
-    // We like fast, so #1 it is.
-
-    // The buffer needs to be C-string.
-    const auto size = stream->getLength();
-    fData = SkData::MakeUninitialized(size + 1);
-    if (stream->read(fData->writable_data(), size) < size) {
-        SkDebugf("!! could not read JSON stream\n");
-        return;
-    }
-
-    auto data = static_cast<char*>(fData->writable_data());
-    data[size] = '\0';
-
-    fDocument.ParseInsitu(data);
-
-#ifdef SK_DEBUG
-        if (fDocument.HasParseError()) {
-            SkDebugf("!! failed to parse json: %s\n",
-                     rapidjson::GetParseError_En(fDocument.GetParseError()));
-        }
-#endif
-}
-
-} // namespace json
-
-} // namespace skottie
diff --git a/experimental/skottie/SkottieJson.h b/experimental/skottie/SkottieJson.h
deleted file mode 100644
index 76e17c610e..0000000000
--- a/experimental/skottie/SkottieJson.h
+++ /dev/null
@@ -1,76 +0,0 @@
-/*
- * Copyright 2018 Google Inc.
- *
- * Use of this source code is governed by a BSD-style license that can be
- * found in the LICENSE file.
- */
-
-#ifndef SkottieJson_DEFINED
-#define SkottieJson_DEFINED
-
-#include "SkRefCnt.h"
-
-#include "rapidjson/document.h"
-
-class SkData;
-class SkStream;
-class SkString;
-
-namespace skottie {
-
-namespace json {
-
-class ValueRef {
-public:
-    ValueRef() : fValue(nullptr) {}
-    ValueRef(const rapidjson::Value& v) : fValue(v.IsNull() ? nullptr : &v) {}
-
-    bool isNull()   const { return !fValue;   }
-    bool isObject() const { return fValue && fValue->IsObject(); }
-    bool isArray()  const { return fValue && fValue->IsArray();  }
-
-    template <typename T>
-    bool to(T*) const;
-
-    template <typename T>
-    T toDefault(const T& defaultValue) const {
-        T v;
-        if (!this->to<T>(&v)) {
-            v = defaultValue;
-        }
-        return v;
-    }
-
-    size_t size() const;
-    ValueRef operator[](size_t i) const;
-    ValueRef operator[](const char* key) const;
-
-    bool operator==(const ValueRef& other) const { return fValue == other.fValue; }
-    bool operator!=(const ValueRef& other) const { return !(*this == other); }
-
-    const rapidjson::Value* begin() const;
-    const rapidjson::Value* end() const;
-
-    SkString toString() const;
-
-private:
-    const rapidjson::Value*       fValue;
-};
-
-// Container for the json DOM
-class Document {
-public:
-    explicit Document(SkStream*);
-
-    ValueRef root() const { return fDocument; }
-
-private:
-    sk_sp<SkData>       fData;     // raw data
-    rapidjson::Document fDocument; // in-place json DOM
-};
-
-} // namespace json
-
-} // namespace skottie
-
-#endif // SkottieJson_DEFINED
diff --git a/experimental/skottie/SkottieValue.cpp b/experimental/skottie/SkottieValue.cpp
deleted file mode 100644
index edfa891aa1..0000000000
--- a/experimental/skottie/SkottieValue.cpp
+++ /dev/null
@@ -1,161 +0,0 @@
-/*
- * Copyright 2017 Google Inc.
- *
- * Use of this source code is governed by a BSD-style license that can be
- * found in the LICENSE file.
- */
-
-#include "SkottieValue.h"
-
-#include "SkColor.h"
-#include "SkNx.h"
-#include "SkPoint.h"
-#include "SkSize.h"
-
-namespace  skottie {
-
-template <>
-size_t ValueTraits<ScalarValue>::Cardinality(const ScalarValue&) {
-    return 1;
-}
-
-template <>
-ScalarValue ValueTraits<ScalarValue>::Lerp(const ScalarValue& v0, const ScalarValue& v1, float t) {
-    SkASSERT(t >= 0 && t <= 1);
-    return v0 + (v1 - v0) * t;
-}
-
-template <>
-template <>
-SkScalar ValueTraits<ScalarValue>::As<SkScalar>(const ScalarValue& v) {
-    return v;
-}
-
-template <>
-size_t ValueTraits<VectorValue>::Cardinality(const VectorValue& vec) {
-    return vec.size();
-}
-
-template <>
-VectorValue ValueTraits<VectorValue>::Lerp(const VectorValue& v0, const VectorValue& v1, float t) {
-    SkASSERT(v0.size() == v1.size());
-
-    VectorValue v;
-    v.reserve(v0.size());
-
-    for (size_t i = 0; i < v0.size(); ++i) {
-        v.push_back(ValueTraits<ScalarValue>::Lerp(v0[i], v1[i], t));
-    }
-
-    return v;
-}
-
-template <>
-template <>
-SkColor ValueTraits<VectorValue>::As<SkColor>(const VectorValue& v) {
-    // best effort to turn this into a color
-    const auto r = v.size() > 0 ? v[0] : 0,
-               g = v.size() > 1 ? v[1] : 0,
-               b = v.size() > 2 ? v[2] : 0,
-               a = v.size() > 3 ? v[3] : 1;
-
-    return SkColorSetARGB(SkTPin<SkScalar>(a, 0, 1) * 255,
-                          SkTPin<SkScalar>(r, 0, 1) * 255,
-                          SkTPin<SkScalar>(g, 0, 1) * 255,
-                          SkTPin<SkScalar>(b, 0, 1) * 255);
-}
-
-template <>
-template <>
-SkPoint ValueTraits<VectorValue>::As<SkPoint>(const VectorValue& vec) {
-    // best effort to turn this into a point
-    const auto x = vec.size() > 0 ? vec[0] : 0,
-               y = vec.size() > 1 ? vec[1] : 0;
-    return SkPoint::Make(x, y);
-}
-
-template <>
-template <>
-SkSize ValueTraits<VectorValue>::As<SkSize>(const VectorValue& vec) {
-    const auto pt = ValueTraits::As<SkPoint>(vec);
-    return SkSize::Make(pt.x(), pt.y());
-}
-
-template <>
-size_t ValueTraits<ShapeValue>::Cardinality(const ShapeValue& shape) {
-    return shape.fVertices.size();
-}
-
-static SkPoint lerp_point(const SkPoint& v0, const SkPoint& v1, const Sk2f& t) {
-    const auto v2f0 = Sk2f::Load(&v0),
-               v2f1 = Sk2f::Load(&v1);
-
-    SkPoint v;
-    (v2f0 + (v2f1 - v2f0) * t).store(&v);
-
-    return v;
-}
-
-template <>
-ShapeValue ValueTraits<ShapeValue>::Lerp(const ShapeValue& v0, const ShapeValue& v1, float t) {
-    SkASSERT(t >= 0 && t <= 1);
-    SkASSERT(v0.fVertices.size() == v1.fVertices.size());
-    SkASSERT(v0.fClosed == v1.fClosed);
-
-    ShapeValue v;
-    v.fClosed = v0.fClosed;
-    v.fVolatile = true; // interpolated values are volatile
-
-    const auto t2f = Sk2f(t);
-    v.fVertices.reserve(v0.fVertices.size());
-
-    for (size_t i = 0; i < v0.fVertices.size(); ++i) {
-        v.fVertices.emplace_back(BezierVertex({
-            lerp_point(v0.fVertices[i].fInPoint , v1.fVertices[i].fInPoint , t2f),
-            lerp_point(v0.fVertices[i].fOutPoint, v1.fVertices[i].fOutPoint, t2f),
-            lerp_point(v0.fVertices[i].fVertex  , v1.fVertices[i].fVertex  , t2f)
-        }));
-    }
-
-    return v;
-}
-
-template <>
-template <>
-SkPath ValueTraits<ShapeValue>::As<SkPath>(const ShapeValue& shape) {
-    SkPath path;
-
-    if (!shape.fVertices.empty()) {
-        path.moveTo(shape.fVertices.front().fVertex);
-    }
-
-    const auto& addCubic = [&](size_t from, size_t to) {
-        const auto c0 = shape.fVertices[from].fVertex + shape.fVertices[from].fOutPoint,
-                   c1 = shape.fVertices[to].fVertex   + shape.fVertices[to].fInPoint;
-
-        if (c0 == shape.fVertices[from].fVertex &&
-            c1 == shape.fVertices[to].fVertex) {
-            // If the control points are coincident, we can power-reduce to a straight line.
-            // TODO: we could also do that when the controls are on the same line as the
-            //       vertices, but it's unclear how common that case is.
-            path.lineTo(shape.fVertices[to].fVertex);
-        } else {
-            path.cubicTo(c0, c1, shape.fVertices[to].fVertex);
-        }
-    };
-
-    for (size_t i = 1; i < shape.fVertices.size(); ++i) {
-        addCubic(i - 1, i);
-    }
-
-    if (!shape.fVertices.empty() && shape.fClosed) {
-        addCubic(shape.fVertices.size() - 1, 0);
-        path.close();
-    }
-
-    path.setIsVolatile(shape.fVolatile);
-
-    return path;
-}
-
-} // namespace skottie
diff --git a/experimental/skottie/SkottieValue.h b/experimental/skottie/SkottieValue.h
deleted file mode 100644
index cfdbd7aba7..0000000000
--- a/experimental/skottie/SkottieValue.h
+++ /dev/null
@@ -1,64 +0,0 @@
-/*
- * Copyright 2017 Google Inc.
- *
- * Use of this source code is governed by a BSD-style license that can be
- * found in the LICENSE file.
- */
-
-#ifndef SkottieValue_DEFINED
-#define SkottieValue_DEFINED
-
-#include "SkPath.h"
-#include "SkScalar.h"
-
-#include <vector>
-
-namespace  skottie {
-
-template <typename T>
-struct ValueTraits {
-    static size_t Cardinality(const T&);
-
-    template <typename U>
-    static U As(const T&);
-
-    static T Lerp(const T&, const T&, float);
-};
-
-using ScalarValue = SkScalar;
-using VectorValue = std::vector<ScalarValue>;
-
-struct BezierVertex {
-    SkPoint fInPoint,  // "in" control point, relative to the vertex
-            fOutPoint, // "out" control point, relative to the vertex
-            fVertex;
-
-    bool operator==(const BezierVertex& other) const {
-        return fInPoint  == other.fInPoint
-            && fOutPoint == other.fOutPoint
-            && fVertex   == other.fVertex;
-    }
-
-    bool operator!=(const BezierVertex& other) const { return !(*this == other); }
-};
-
-struct ShapeValue {
-    std::vector<BezierVertex> fVertices;
-    bool                      fClosed   : 1,
-                              fVolatile : 1;
-
-    ShapeValue() : fClosed(false), fVolatile(false) {}
-    ShapeValue(const ShapeValue&)            = default;
-    ShapeValue(ShapeValue&&)                 = default;
-    ShapeValue& operator=(const ShapeValue&) = default;
-
-    bool operator==(const ShapeValue& other) const {
-        return fVertices == other.fVertices && fClosed == other.fClosed;
-    }
-
-    bool operator!=(const ShapeValue& other) const { return !(*this == other); }
-};
-
-} // namespace skottie
-
-#endif // SkottieValue_DEFINED