[skottie] Make AnimationBuilder available for value parsing

Plumb AnimationBuilder throught a bazillion layers to make it reachable
when parsing animatable values.

This is in preparation of keyframed text, which will require access to
the font set when parsing.

Refactor only, no functional changes.

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

Author: fmalita

modules/skottie/skottie.gni

@@ -14,7 +14,6 @@ skia_skottie_sources = [
   "$_src/SkottieAdapter.cpp",
   "$_src/SkottieAdapter.h",
   "$_src/SkottieAnimator.cpp",
-  "$_src/SkottieAnimator.h",
   "$_src/SkottieJson.cpp",
   "$_src/SkottieJson.h",
   "$_src/SkottieLayer.cpp",

modules/skottie/src/Skottie.cpp

@@ -25,7 +25,6 @@
 #include "SkTime.h"
 #include "SkTo.h"
 #include "SkottieAdapter.h"
-#include "SkottieAnimator.h"
 #include "SkottieJson.h"
 #include "SkottiePriv.h"
 #include "SkottieValue.h"
@@ -43,23 +42,24 @@ void LogJSON(const skjson::Value& json, const char msg[]) {
     LOG("%s: %s\n", msg, dump.c_str());
 }
 
-sk_sp<sksg::Matrix> AttachMatrix(const skjson::ObjectValue& t, AnimatorScope* ascope,
-                                 sk_sp<sksg::Matrix> parentMatrix) {
+sk_sp<sksg::Matrix> AnimationBuilder::attachMatrix(const skjson::ObjectValue& t,
+                                                   AnimatorScope* ascope,
+                                                   sk_sp<sksg::Matrix> parentMatrix) const {
     static const VectorValue g_default_vec_0   = {  0,   0},
                              g_default_vec_100 = {100, 100};
 
     auto matrix = sksg::Matrix::Make(SkMatrix::I(), parentMatrix);
     auto adapter = sk_make_sp<TransformAdapter>(matrix);
 
-    auto bound = BindProperty<VectorValue>(t["a"], ascope,
+    auto bound = this->bindProperty<VectorValue>(t["a"], ascope,
             [adapter](const VectorValue& a) {
                 adapter->setAnchorPoint(ValueTraits<VectorValue>::As<SkPoint>(a));
             }, g_default_vec_0);
-    bound |= BindProperty<VectorValue>(t["p"], ascope,
+    bound |= this->bindProperty<VectorValue>(t["p"], ascope,
             [adapter](const VectorValue& p) {
                 adapter->setPosition(ValueTraits<VectorValue>::As<SkPoint>(p));
             }, g_default_vec_0);
-    bound |= BindProperty<VectorValue>(t["s"], ascope,
+    bound |= this->bindProperty<VectorValue>(t["s"], ascope,
             [adapter](const VectorValue& s) {
                 adapter->setScale(ValueTraits<VectorValue>::As<SkVector>(s));
             }, g_default_vec_100);
@@ -70,30 +70,31 @@ sk_sp<sksg::Matrix> AttachMatrix(const skjson::ObjectValue& t, AnimatorScope* as
         // we can still make use of rz.
         jrotation = &t["rz"];
     }
-    bound |= BindProperty<ScalarValue>(*jrotation, ascope,
+    bound |= this->bindProperty<ScalarValue>(*jrotation, ascope,
             [adapter](const ScalarValue& r) {
                 adapter->setRotation(r);
             }, 0.0f);
-    bound |= BindProperty<ScalarValue>(t["sk"], ascope,
+    bound |= this->bindProperty<ScalarValue>(t["sk"], ascope,
             [adapter](const ScalarValue& sk) {
                 adapter->setSkew(sk);
             }, 0.0f);
-    bound |= BindProperty<ScalarValue>(t["sa"], ascope,
+    bound |= this->bindProperty<ScalarValue>(t["sa"], ascope,
             [adapter](const ScalarValue& sa) {
                 adapter->setSkewAxis(sa);
             }, 0.0f);
 
     return bound ? matrix : parentMatrix;
 }
 
-sk_sp<sksg::RenderNode> AttachOpacity(const skjson::ObjectValue& jtransform, AnimatorScope* ascope,
-                                      sk_sp<sksg::RenderNode> childNode) {
+sk_sp<sksg::RenderNode> AnimationBuilder::attachOpacity(const skjson::ObjectValue& jtransform,
+                                                        AnimatorScope* ascope,
+                                                        sk_sp<sksg::RenderNode> childNode) const {
     if (!childNode)
         return nullptr;
 
     auto opacityNode = sksg::OpacityEffect::Make(childNode);
 
-    if (!BindProperty<ScalarValue>(jtransform["o"], ascope,
+    if (!this->bindProperty<ScalarValue>(jtransform["o"], ascope,
         [opacityNode](const ScalarValue& o) {
             // BM opacity is [0..100]
             opacityNode->setOpacity(o * 0.01f);
@@ -105,9 +106,10 @@ sk_sp<sksg::RenderNode> AttachOpacity(const skjson::ObjectValue& jtransform, Ani
     return std::move(opacityNode);
 }
 
-sk_sp<sksg::Path> AttachPath(const skjson::Value& jpath, AnimatorScope* ascope) {
+sk_sp<sksg::Path> AnimationBuilder::attachPath(const skjson::Value& jpath,
+                                               AnimatorScope* ascope) const {
     auto path_node = sksg::Path::Make();
-    return BindProperty<ShapeValue>(jpath, ascope,
+    return this->bindProperty<ShapeValue>(jpath, ascope,
         [path_node](const ShapeValue& p) {
             // FillType is tracked in the SG node, not in keyframes -- make sure we preserve it.
             auto path = ValueTraits<ShapeValue>::As<SkPath>(p);
@@ -118,10 +120,11 @@ sk_sp<sksg::Path> AttachPath(const skjson::Value& jpath, AnimatorScope* ascope)
         : nullptr;
 }
 
-sk_sp<sksg::Color> AttachColor(const skjson::ObjectValue& jcolor, AnimatorScope* ascope,
-                               const char prop_name[]) {
+sk_sp<sksg::Color> AnimationBuilder::attachColor(const skjson::ObjectValue& jcolor,
+                                                 AnimatorScope* ascope,
+                                                 const char prop_name[]) const {
     auto color_node = sksg::Color::Make(SK_ColorBLACK);
-    BindProperty<VectorValue>(jcolor[prop_name], ascope,
+    this->bindProperty<VectorValue>(jcolor[prop_name], ascope,
         [color_node](const VectorValue& c) {
             color_node->setColor(ValueTraits<VectorValue>::As<SkColor>(c));
         });

modules/skottie/src/SkottieAnimator.cpp

@@ -5,11 +5,11 @@
  * found in the LICENSE file.
  */
 
-#include "SkottieAnimator.h"
-
 #include "SkCubicMap.h"
 #include "SkottieJson.h"
+#include "SkottiePriv.h"
 #include "SkottieValue.h"
+#include "SkSGScene.h"
 #include "SkString.h"
 #include "SkTArray.h"
 
@@ -68,9 +68,9 @@ class KeyframeAnimatorBase : public sksg::Animator {
             : SkTPin(fCubicMaps[rec.cmidx].computeYFromX(lt), 0.0f, 1.0f);
     }
 
-    virtual int parseValue(const skjson::Value&) = 0;
+    virtual int parseValue(const skjson::Value&, const AnimationBuilder* abuilder) = 0;
 
-    void parseKeyFrames(const skjson::ArrayValue& jframes) {
+    void parseKeyFrames(const skjson::ArrayValue& jframes, const AnimationBuilder* abuilder) {
         for (const skjson::ObjectValue* jframe : jframes) {
             if (!jframe) continue;
 
@@ -88,7 +88,7 @@ class KeyframeAnimatorBase : public sksg::Animator {
                 fRecs.back().t1 = t0;
             }
 
-            const auto vidx0 = this->parseValue((*jframe)["s"]);
+            const auto vidx0 = this->parseValue((*jframe)["s"], abuilder);
             if (vidx0 < 0)
                 continue;
 
@@ -97,7 +97,7 @@ class KeyframeAnimatorBase : public sksg::Animator {
 
             if (!ParseDefault<bool>((*jframe)["h"], false)) {
                 // Regular frame, requires an end value.
-                vidx1 = this->parseValue((*jframe)["e"]);
+                vidx1 = this->parseValue((*jframe)["e"], abuilder);
                 if (vidx1 < 0)
                     continue;
 
@@ -176,10 +176,12 @@ template <typename T>
 class KeyframeAnimator final : public KeyframeAnimatorBase {
 public:
     static std::unique_ptr<KeyframeAnimator> Make(const skjson::ArrayValue* jv,
+                                                  const AnimationBuilder* abuilder,
                                                   std::function<void(const T&)>&& apply) {
         if (!jv) return nullptr;
 
-        std::unique_ptr<KeyframeAnimator> animator(new KeyframeAnimator(*jv, std::move(apply)));
+        std::unique_ptr<KeyframeAnimator> animator(
+            new KeyframeAnimator(*jv, abuilder, std::move(apply)));
         if (!animator->count())
             return nullptr;
 
@@ -193,14 +195,16 @@ class KeyframeAnimator final : public KeyframeAnimatorBase {
 
 private:
     KeyframeAnimator(const skjson::ArrayValue& jframes,
+                     const AnimationBuilder* abuilder,
                      std::function<void(const T&)>&& apply)
         : fApplyFunc(std::move(apply)) {
-        this->parseKeyFrames(jframes);
+        this->parseKeyFrames(jframes, abuilder);
     }
 
-    int parseValue(const skjson::Value& jv) override {
+    int parseValue(const skjson::Value& jv, const AnimationBuilder* abuilder) override {
         T val;
-        if (!Parse<T>(jv, &val) || (!fVs.empty() && !ValueTraits<T>::CanLerp(val, fVs.back()))) {
+        if (!ValueTraits<T>::FromJSON(jv, abuilder, &val) ||
+            (!fVs.empty() && !ValueTraits<T>::CanLerp(val, fVs.back()))) {
             return -1;
         }
 
@@ -241,7 +245,8 @@ class KeyframeAnimator final : public KeyframeAnimatorBase {
 
 template <typename T>
 static inline bool BindPropertyImpl(const skjson::ObjectValue* jprop,
-                                    sksg::AnimatorList* animators,
+                                    const AnimationBuilder* abuilder,
+                                    AnimatorScope* ascope,
                                     std::function<void(const T&)>&& apply,
                                     const T* noop = nullptr) {
     if (!jprop) return false;
@@ -257,7 +262,7 @@ static inline bool BindPropertyImpl(const skjson::ObjectValue* jprop,
     // For those, we attempt to parse both ways.
     if (!ParseDefault<bool>(jpropA, false)) {
         T val;
-        if (Parse<T>(jpropK, &val)) {
+        if (ValueTraits<T>::FromJSON(jpropK, abuilder, &val)) {
             // Static property.
             if (noop && val == *noop)
                 return false;
@@ -272,20 +277,21 @@ static inline bool BindPropertyImpl(const skjson::ObjectValue* jprop,
     }
 
     // Keyframe property.
-    auto animator = KeyframeAnimator<T>::Make(jpropK, std::move(apply));
+    auto animator = KeyframeAnimator<T>::Make(jpropK, abuilder, std::move(apply));
 
     if (!animator) {
         return LogFail(*jprop, "Could not parse keyframed property");
     }
 
-    animators->push_back(std::move(animator));
+    ascope->push_back(std::move(animator));
 
     return true;
 }
 
 class SplitPointAnimator final : public sksg::Animator {
 public:
     static std::unique_ptr<SplitPointAnimator> Make(const skjson::ObjectValue* jprop,
+                                                    const AnimationBuilder* abuilder,
                                                     std::function<void(const VectorValue&)>&& apply,
                                                     const VectorValue*) {
         if (!jprop) return nullptr;
@@ -297,9 +303,9 @@ class SplitPointAnimator final : public sksg::Animator {
         // 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,
+        if (!BindPropertyImpl<ScalarValue>((*jprop)["x"], abuilder, &split_animator->fAnimators,
                 [split_animator_ptr](const ScalarValue& x) { split_animator_ptr->setX(x); }) ||
-            !BindPropertyImpl<ScalarValue>((*jprop)["y"], &split_animator->fAnimators,
+            !BindPropertyImpl<ScalarValue>((*jprop)["y"], abuilder, &split_animator->fAnimators,
                 [split_animator_ptr](const ScalarValue& y) { split_animator_ptr->setY(y); })) {
             LogFail(*jprop, "Could not parse split property");
             return nullptr;
@@ -340,11 +346,12 @@ class SplitPointAnimator final : public sksg::Animator {
 };
 
 bool BindSplitPositionProperty(const skjson::Value& jv,
-                               sksg::AnimatorList* animators,
+                               const AnimationBuilder* abuilder,
+                               AnimatorScope* ascope,
                                std::function<void(const VectorValue&)>&& apply,
                                const VectorValue* noop) {
-    if (auto split_animator = SplitPointAnimator::Make(jv, std::move(apply), noop)) {
-        animators->push_back(std::unique_ptr<sksg::Animator>(split_animator.release()));
+    if (auto split_animator = SplitPointAnimator::Make(jv, abuilder, std::move(apply), noop)) {
+        ascope->push_back(std::unique_ptr<sksg::Animator>(split_animator.release()));
         return true;
     }
 
@@ -354,32 +361,32 @@ bool BindSplitPositionProperty(const skjson::Value& jv,
 } // namespace
 
 template <>
-bool BindProperty(const skjson::Value& jv,
+bool AnimationBuilder::bindProperty(const skjson::Value& jv,
                   AnimatorScope* ascope,
                   std::function<void(const ScalarValue&)>&& apply,
-                  const ScalarValue* noop) {
-    return BindPropertyImpl(jv, ascope, std::move(apply), noop);
+                  const ScalarValue* noop) const {
+    return BindPropertyImpl(jv, this, ascope, std::move(apply), noop);
 }
 
 template <>
-bool BindProperty(const skjson::Value& jv,
+bool AnimationBuilder::bindProperty(const skjson::Value& jv,
                   AnimatorScope* ascope,
                   std::function<void(const VectorValue&)>&& apply,
-                  const VectorValue* noop) {
+                  const VectorValue* noop) const {
     if (!jv.is<skjson::ObjectValue>())
         return false;
 
     return ParseDefault<bool>(jv.as<skjson::ObjectValue>()["s"], false)
-        ? BindSplitPositionProperty(jv, ascope, std::move(apply), noop)
-        : BindPropertyImpl(jv, ascope, std::move(apply), noop);
+        ? BindSplitPositionProperty(jv, this, ascope, std::move(apply), noop)
+        : BindPropertyImpl(jv, this, ascope, std::move(apply), noop);
 }
 
 template <>
-bool BindProperty(const skjson::Value& jv,
+bool AnimationBuilder::bindProperty(const skjson::Value& jv,
                   AnimatorScope* ascope,
                   std::function<void(const ShapeValue&)>&& apply,
-                  const ShapeValue* noop) {
-    return BindPropertyImpl(jv, ascope, std::move(apply), noop);
+                  const ShapeValue* noop) const {
+    return BindPropertyImpl(jv, this, ascope, std::move(apply), noop);
 }
 
 } // namespace internal