diff --git a/modules/skottie/BUILD.gn b/modules/skottie/BUILD.gn
index 5bda984..12fcb6a 100644
--- a/modules/skottie/BUILD.gn
+++ b/modules/skottie/BUILD.gn
@@ -37,9 +37,7 @@
       public_configs = [ ":utils_config" ]
       configs += [ "../../:skia_private" ]
 
-      sources = [
-        "utils/SkottieUtils.cpp",
-      ]
+      sources = [ "utils/SkottieUtils.cpp" ]
       deps = [
         ":skottie",
         "../..:skia",
@@ -56,6 +54,7 @@
         ]
         sources = [
           "src/SkottieTest.cpp",
+          "tests/Keyframe.cpp",
         ]
 
         deps = [
@@ -89,9 +88,7 @@
           "../..:skia",
         ]
 
-        public_deps = [
-          ":skottie",
-        ]
+        public_deps = [ ":skottie" ]
       }
 
       source_set("tool") {
@@ -99,9 +96,7 @@
         testonly = true
 
         configs += [ "../..:skia_private" ]
-        sources = [
-          "src/SkottieTool.cpp",
-        ]
+        sources = [ "src/SkottieTool.cpp" ]
 
         deps = [
           "../..:flags",
diff --git a/modules/skottie/src/Animator.cpp b/modules/skottie/src/Animator.cpp
index afc2ddc..044bccd 100644
--- a/modules/skottie/src/Animator.cpp
+++ b/modules/skottie/src/Animator.cpp
@@ -15,6 +15,8 @@
 
 #include <vector>
 
+#define DUMP_KF_RECORDS 0
+
 namespace skottie {
 namespace internal {
 
@@ -49,215 +51,265 @@
 protected:
     KeyframeAnimatorBase() = default;
 
-    struct KeyframeRec {
-        float t0, t1;
-        int   vidx0, vidx1, // v0/v1 indices
-              cmidx;        // cubic map index
+    struct LERPInfo {
+        float    weight;       // vidx0..vidx1 weight [0..1]
+        uint32_t vidx0, vidx1; // value indices (values are stored externally)
 
-        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);
+    // Main entry point: |t| -> LERPInfo
+    LERPInfo getLERPInfo(float t) const {
+        SkASSERT(!fKFs.empty());
+
+        if (t <= fKFs.front().t) {
+            // Constant/clamped segment.
+            return { 0, fKFs.front().v_idx, fKFs.front().v_idx };
         }
-        return *fCachedRec;
-    }
+        if (t >= fKFs.back().t) {
+            // Constant/clamped segment.
+            return { 0, fKFs.back().v_idx, fKFs.back().v_idx };
+        }
 
-    bool isEmpty() const { return fRecs.empty(); }
+        // Cache the current segment (most queries have good locality).
+        if (!fCurrentSegment.contains(t)) {
+            fCurrentSegment = this->find_segment(t);
+        }
+        SkASSERT(fCurrentSegment.contains(t));
 
-    float localT(const KeyframeRec& rec, float t) const {
-        SkASSERT(rec.isValid());
-        SkASSERT(!rec.isConstant());
-        SkASSERT(t > rec.t0 && t < rec.t1);
+        if (fCurrentSegment.kf0->mapping == KFRec::kConstantMapping) {
+            // Constant/hold segment.
+            return { 0, fCurrentSegment.kf0->v_idx, fCurrentSegment.kf0->v_idx };
+        }
 
-        auto lt = (t - rec.t0) / (rec.t1 - rec.t0);
-
-        return rec.cmidx < 0
-            ? lt
-            : fCubicMaps[SkToSizeT(rec.cmidx)].computeYFromX(lt);
+        return {
+            this->compute_weight(fCurrentSegment, t),
+            fCurrentSegment.kf0->v_idx,
+            fCurrentSegment.kf1->v_idx,
+        };
     }
 
     virtual int parseValue(const AnimationBuilder&, const skjson::Value&) = 0;
 
-    void parseKeyFrames(const AnimationBuilder& abuilder, const skjson::ArrayValue& jframes) {
-        // Logically, a keyframe is defined as a (t0, t1, v0, v1) tuple: a given value
-        // is interpolated in the [v0..v1] interval over the [t0..t1] time span.
+    bool parseKeyFrames(const AnimationBuilder& abuilder, const skjson::ArrayValue& jkfs) {
+        // Keyframe format:
         //
-        // There are three interestingly-different keyframe formats handled here.
+        // [                        // array of
+        //   {
+        //     "t": <float>         // keyframe time
+        //     "s": <T>             // keyframe value
+        //     "h": <bool>          // optional constant/hold keyframe marker
+        //     "i": [<float,float>] // optional "in" Bezier control point
+        //     "o": [<float,float>] // optional "out" Bezier control point
+        //   },
+        //   ...
+        // ]
         //
-        // 1) Legacy keyframe format
+        // Legacy keyframe format:
         //
-        //      - normal keyframes specify t0 ("t"), v0 ("s") and v1 ("e")
-        //      - last frame only specifies a t0
-        //      - t1[frame] == t0[frame + 1]
-        //      - the last entry (where we cannot determine t1) is ignored
+        // [                        // array of
+        //   {
+        //     "t": <float>         // keyframe time
+        //     "s": <T>             // keyframe start value
+        //     "e": <T>             // keyframe end value
+        //     "h": <bool>          // optional constant/hold keyframe marker (constant mapping)
+        //     "i": [<float,float>] // optional "in" Bezier control point (cubic mapping)
+        //     "o": [<float,float>] // optional "out" Bezier control point (cubic mapping)
+        //   },
+        //   ...
+        //   {
+        //     "t": <float>         // last keyframe only specifies a t
+        //                          // the value is prev. keyframe end value
+        //   }
+        // ]
         //
-        // 2) Regular (new) keyframe format
-        //
-        //      - all keyframes specify t0 ("t") and v0 ("s")
-        //      - t1[frame] == t0[frame + 1]
-        //      - v1[frame] == v0[frame + 1]
-        //      - the last entry (where we cannot determine t1/v1) is ignored
-        //
-        // 3) Text value keyframe format
-        //
-        //      - similar to case #2, all keyframes specify t0 & v0
-        //      - unlike case #2, all keyframes are assumed to be constant (v1 == v0),
-        //        and the last frame is not discarded (its t1 is assumed -> inf)
-        //
+        // Note: the legacy format contains duplicates, as normal frames are contiguous:
+        //       frame(n).e == frame(n+1).s
 
+        // Tracks previous cubic map parameters (for deduping).
         SkPoint prev_c0 = { 0, 0 },
-                prev_c1 = prev_c0;
+                prev_c1 = { 0, 0 };
 
-        fRecs.reserve(std::max<size_t>(jframes.size(), 1) - 1);
+        const auto parse_mapping = [&](const skjson::ObjectValue& jkf) {
+            if (ParseDefault(jkf["h"], false)) {
+                return KFRec::kConstantMapping;
+            }
 
-        for (const skjson::ObjectValue* jframe : jframes) {
-            if (!jframe) continue;
+            SkPoint c0, c1;
+            if (!Parse(jkf["o"], &c0) ||
+                !Parse(jkf["i"], &c1) ||
+                SkCubicMap::IsLinear(c0, c1)) {
+                return KFRec::kLinearMapping;
+            }
 
-            float t0;
-            if (!Parse<float>((*jframe)["t"], &t0))
-                continue;
+            // De-dupe sequential cubic mappers.
+            if (c0 != prev_c0 || c1 != prev_c1 || fCMs.empty()) {
+                fCMs.emplace_back(c0, c1);
+                prev_c0 = c0;
+                prev_c1 = c1;
+            }
 
-            const auto v0_idx = this->parseValue(abuilder, (*jframe)["s"]),
-                       v1_idx = this->parseValue(abuilder, (*jframe)["e"]);
+            SkASSERT(!fCMs.empty());
+            return SkToU32(fCMs.size()) - 1 + KFRec::kCubicIndexOffset;
+        };
 
-            if (!fRecs.empty()) {
-                if (fRecs.back().t1 >= t0) {
-                    abuilder.log(Logger::Level::kWarning, nullptr,
-                                 "Ignoring out-of-order key frame (t:%f < t:%f).",
-                                 t0, fRecs.back().t1);
-                    continue;
+        const auto parse_value = [&](const skjson::ObjectValue& jkf, size_t i) {
+            auto v_idx = this->parseValue(abuilder, jkf["s"]);
+
+            // A missing value is only OK for the last legacy KF
+            // (where it is pulled from prev KF 'end' value).
+            if (v_idx < 0 && i > 0 && i == jkfs.size() - 1) {
+                const skjson::ObjectValue* prev_kf = jkfs[i - 1];
+                SkASSERT(prev_kf);
+                v_idx = this->parseValue(abuilder, (*prev_kf)["e"]);
+            }
+
+            return v_idx;
+        };
+
+        fKFs.reserve(jkfs.size());
+
+        for (size_t i = 0; i < jkfs.size(); ++i) {
+            const skjson::ObjectValue* jkf = jkfs[i];
+            if (!jkf) {
+                return false;
+            }
+
+            float t;
+            if (!Parse<float>((*jkf)["t"], &t)) {
+                return false;
+            }
+
+            auto v_idx = parse_value(*jkf, i);
+            if (v_idx < 0) {
+                return false;
+            }
+
+            if (i > 0) {
+                auto& prev_kf = fKFs.back();
+
+                // Ts must be strictly monotonic.
+                if (t <= prev_kf.t) {
+                    return false;
                 }
 
-                // Back-fill t1 and v1 (if needed).
-                auto& prev = fRecs.back();
-                prev.t1 = t0;
-
-                // Previous keyframe did not specify an end value (case #2, #3).
-                if (prev.vidx1 < 0) {
-                    // If this frame has no v0, we're in case #3 (constant text value),
-                    // otherwise case #2 (v0 for current frame is the same as prev frame v1).
-                    prev.vidx1 = v0_idx < 0 ? prev.vidx0 : v0_idx;
+                // We can power-reduce the mapping of repeated values (implicitly constant).
+                if (SkToU32(v_idx) == prev_kf.v_idx) {
+                    prev_kf.mapping = KFRec::kConstantMapping;
                 }
             }
 
-            // Start value 's' is required.
-            if (v0_idx < 0)
-                continue;
-
-            if ((v1_idx < 0) && ParseDefault((*jframe)["h"], false)) {
-                // Constant keyframe ("h": true).
-                fRecs.push_back({t0, t0, v0_idx, v0_idx, -1 });
-                continue;
-            }
-
-            const auto cubic_mapper_index = [&]() -> int {
-                // Do we have non-linear control points?
-                SkPoint c0, c1;
-                if (!Parse((*jframe)["o"], &c0) ||
-                    !Parse((*jframe)["i"], &c1) ||
-                    SkCubicMap::IsLinear(c0, c1)) {
-                    // No need for a cubic mapper.
-                    return -1;
-                }
-
-                // De-dupe sequential cubic mappers.
-                if (c0 != prev_c0 || c1 != prev_c1) {
-                    fCubicMaps.emplace_back(c0, c1);
-                    prev_c0 = c0;
-                    prev_c1 = c1;
-                }
-
-                SkASSERT(!fCubicMaps.empty());
-                return SkToInt(fCubicMaps.size()) - 1;
-            };
-
-            fRecs.push_back({t0, t0, v0_idx, v1_idx, cubic_mapper_index()});
+            fKFs.push_back({t, SkToU32(v_idx), parse_mapping(*jkf)});
         }
 
-        if (!fRecs.empty()) {
-            auto& last = fRecs.back();
+        SkASSERT(fKFs.size() == jkfs.size());
+        fCMs.shrink_to_fit();
 
-            // If the last entry has only a v0, we're in case #3 - make it a constant frame.
-            if (last.vidx0 >= 0 && last.vidx1 < 0) {
-                last.vidx1 = last.vidx0;
-                last.t1 = last.t0;
-            }
-
-            // If we couldn't determine a valid t1 for the last frame, discard it
-            // (most likely the last frame entry for all 3 cases).
-            if (!last.isValid()) {
-                fRecs.pop_back();
-            }
+#if(DUMP_KF_RECORDS)
+        SkDEBUGF("Animator[%p], values: %lu, KF records: %zu\n",
+                 this, fKFs.back().v_idx + 1, fKFs.size());
+        for (const auto& kf : fKFs) {
+            SkDEBUGF("  { t: %1.3f, v_idx: %lu, mapping: %lu }\n", kf.t, kf.v_idx, kf.mapping);
         }
-
-        fRecs.shrink_to_fit();
-        fCubicMaps.shrink_to_fit();
-
-        SkASSERT(fRecs.empty() || fRecs.back().isValid());
+#endif
+        return true;
     }
 
 private:
-    const KeyframeRec* findFrame(float t) const {
-        SkASSERT(!fRecs.empty());
+    // We store one KFRec for each AE/Lottie keyframe.
+    struct KFRec {
+        float    t;
+        uint32_t v_idx;
+        uint32_t mapping; // Encodes the value interpolation in [KFRec_n .. KFRec_n+1):
+                          //   0 -> constant
+                          //   1 -> linear
+                          //   n -> cubic: fCMs[n-2]
 
-        auto f0 = &fRecs.front(),
-             f1 = &fRecs.back();
+        static constexpr uint32_t kConstantMapping  = 0;
+        static constexpr uint32_t kLinearMapping    = 1;
+        static constexpr uint32_t kCubicIndexOffset = 2;
+    };
 
-        SkASSERT(f0->isValid());
-        SkASSERT(f1->isValid());
+    // Two sequential KFRecs determine how the value varies within [kf0 .. kf1)
+    struct KFSegment {
+        const KFRec* kf0;
+        const KFRec* kf1;
 
-        if (t < f0->t0) {
-            return f0;
+        bool contains(float t) const {
+            SkASSERT(!!kf0 == !!kf1);
+            SkASSERT(!kf0 || kf1 == kf0 + 1);
+
+            return kf0 && kf0->t <= t && t < kf1->t;
         }
+    };
 
-        if (t > f1->t1) {
-            return f1;
-        }
+    // Find the KFSegment containing |t|.
+    KFSegment find_segment(float t) const {
+        SkASSERT(fKFs.size() > 1);
+        SkASSERT(t > fKFs.front().t);
+        SkASSERT(t < fKFs.back().t);
 
-        while (f0 != f1) {
-            SkASSERT(f0 < f1);
-            SkASSERT(t >= f0->t0 && t <= f1->t1);
+        auto kf0 = &fKFs.front(),
+             kf1 = &fKFs.back();
 
-            const auto f = f0 + (f1 - f0) / 2;
-            SkASSERT(f->isValid());
+        // Binary-search, until we reduce to sequential keyframes.
+        while (kf0 + 1 != kf1) {
+            SkASSERT(kf0 < kf1);
+            SkASSERT(kf0->t <= t && t < kf1->t);
 
-            if (t > f->t1) {
-                f0 = f + 1;
+            const auto mid_kf = kf0 + (kf1 - kf0) / 2;
+
+            if (t >= mid_kf->t) {
+                kf0 = mid_kf;
             } else {
-                f1 = f;
+                kf1 = mid_kf;
             }
         }
 
-        SkASSERT(f0 == f1);
-        SkASSERT(f0->contains(t));
-
-        return f0;
+        return {kf0, kf1};
     }
 
-    std::vector<KeyframeRec> fRecs;
-    std::vector<SkCubicMap>  fCubicMaps;
-    const KeyframeRec*       fCachedRec = nullptr;
+    // Given a |t| and a containing KFSegment, compute the local interpolation weight.
+    float compute_weight(const KFSegment& seg, float t) const {
+        SkASSERT(seg.contains(t));
+
+        // Linear weight.
+        auto w = (t - seg.kf0->t) / (seg.kf1->t - seg.kf0->t);
+
+        // Optional cubic mapper.
+        if (seg.kf0->mapping >= KFRec::kCubicIndexOffset) {
+            SkASSERT(seg.kf0->v_idx != seg.kf1->v_idx);
+            const auto mapper_index = SkToSizeT(seg.kf0->mapping - KFRec::kCubicIndexOffset);
+            w = fCMs[mapper_index].computeYFromX(w);
+        }
+
+        return w;
+    }
+
+    std::vector<KFRec>      fKFs; // Keyframe records, one per AE/Lottie keyframe.
+    std::vector<SkCubicMap> fCMs; // Optional cubic mappers (Bezier interpolation).
+    mutable KFSegment       fCurrentSegment = { nullptr, nullptr }; // Cached segment.
 };
 
 template <typename T>
 class KeyframeAnimator final : public KeyframeAnimatorBase {
 public:
     static sk_sp<KeyframeAnimator> Make(const AnimationBuilder& abuilder,
-                                        const skjson::ArrayValue* jv,
+                                        const skjson::ArrayValue* jkfs,
                                         T* target_value) {
-        if (!jv) return nullptr;
+        if (!jkfs || jkfs->size() < 1) {
+            return nullptr;
+        }
 
-        sk_sp<KeyframeAnimator> animator(new KeyframeAnimator(abuilder, *jv, target_value));
+        sk_sp<KeyframeAnimator> animator(new KeyframeAnimator(target_value));
 
-        return animator->isEmpty() ? nullptr : animator;
+        animator->fValues.reserve(jkfs->size());
+        if (!animator->parseKeyFrames(abuilder, *jkfs)) {
+            return nullptr;
+        }
+        animator->fValues.shrink_to_fit();
+
+        return animator;
     }
 
     bool isConstant() const {
@@ -266,18 +318,8 @@
     }
 
 private:
-    KeyframeAnimator(const AnimationBuilder& abuilder,
-                     const skjson::ArrayValue& jframes,
-                     T* target_value)
-        : fTarget(target_value) {
-        // Generally, each keyframe holds two values (start, end) and a cubic mapper. Except
-        // the last frame, which only holds a marker timestamp.  Then, the values series is
-        // contiguous (keyframe[i].end == keyframe[i + 1].start), and we dedupe them.
-        //   => we'll store (keyframes.size) values and (keyframe.size - 1) recs and cubic maps.
-        fValues.reserve(jframes.size());
-        this->parseKeyFrames(abuilder, jframes);
-        fValues.shrink_to_fit();
-    }
+    explicit KeyframeAnimator(T* target_value)
+        : fTarget(target_value) {}
 
     int parseValue(const AnimationBuilder& abuilder, const skjson::Value& jv) override {
         T val;
@@ -294,21 +336,16 @@
     }
 
     void onTick(float t) override {
-        const auto& rec = this->frame(t);
-        SkASSERT(rec.isValid());
+        const auto& lerp_info = this->getLERPInfo(t);
 
-        if (rec.isConstant() || t <= rec.t0) {
-            *fTarget = fValues[SkToSizeT(rec.vidx0)];
-            return;
-        } else if (t >= rec.t1) {
-            *fTarget = fValues[SkToSizeT(rec.vidx1)];
-            return;
+        if (lerp_info.isConstant()) {
+            *fTarget = fValues[SkToSizeT(lerp_info.vidx0)];
+        } else {
+            ValueTraits<T>::Lerp(fValues[lerp_info.vidx0],
+                                 fValues[lerp_info.vidx1],
+                                 lerp_info.weight,
+                                 fTarget);
         }
-
-        ValueTraits<T>::Lerp(fValues[SkToSizeT(rec.vidx0)],
-                             fValues[SkToSizeT(rec.vidx1)],
-                             this->localT(rec, t),
-                             fTarget);
     }
 
     std::vector<T> fValues;
diff --git a/modules/skottie/tests/Keyframe.cpp b/modules/skottie/tests/Keyframe.cpp
new file mode 100644
index 0000000..31ee792
--- /dev/null
+++ b/modules/skottie/tests/Keyframe.cpp
@@ -0,0 +1,136 @@
+/*
+ * Copyright 2020 Google Inc.
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#include "modules/skottie/src/Animator.h"
+#include "modules/skottie/src/SkottiePriv.h"
+#include "modules/skottie/src/SkottieValue.h"
+#include "src/utils/SkJSON.h"
+#include "tests/Test.h"
+
+#include <cmath>
+
+using namespace skottie;
+using namespace skottie::internal;
+
+namespace  {
+
+template <typename T>
+class MockProperty final : public AnimatablePropertyContainer {
+public:
+    explicit MockProperty(const char* jprop) {
+        AnimationBuilder abuilder(nullptr, nullptr, nullptr, nullptr, nullptr, nullptr,
+                                  {100, 100}, 10, 1, 0);
+        skjson::DOM json_dom(jprop, strlen(jprop));
+
+        fDidBind = this->bind(abuilder, json_dom.root(), &fValue);
+    }
+
+    operator bool() const { return fDidBind; }
+
+    const T& operator()(float t) { this->tick(t); return fValue; }
+
+private:
+    void onSync() override {}
+
+    T     fValue = T();
+    bool  fDidBind;
+};
+
+}
+
+DEF_TEST(Skottie_Keyframe, reporter) {
+    {
+        MockProperty<ScalarValue> prop(R"({})");
+        REPORTER_ASSERT(reporter, !prop);
+    }
+    {
+        MockProperty<ScalarValue> prop(R"({ "a": 1, "k": [] })");
+        REPORTER_ASSERT(reporter, !prop);
+    }
+    {
+        // New style
+        MockProperty<ScalarValue> prop(R"({
+                                         "a": 1,
+                                         "k": [
+                                           { "t":  1, "s": 1 },
+                                           { "t":  2, "s": 2 },
+                                           { "t":  3, "s": 4 }
+                                         ]
+                                       })");
+        REPORTER_ASSERT(reporter, prop);
+        REPORTER_ASSERT(reporter, SkScalarNearlyEqual(prop( -1), 1));
+        REPORTER_ASSERT(reporter, SkScalarNearlyEqual(prop(  0), 1));
+        REPORTER_ASSERT(reporter, SkScalarNearlyEqual(prop(  1), 1));
+        REPORTER_ASSERT(reporter, SkScalarNearlyEqual(prop(1.5), 1.5f));
+        REPORTER_ASSERT(reporter, SkScalarNearlyEqual(prop(  2), 2));
+        REPORTER_ASSERT(reporter, SkScalarNearlyEqual(prop(2.5), 3));
+        REPORTER_ASSERT(reporter, SkScalarNearlyEqual(prop(  3), 4));
+        REPORTER_ASSERT(reporter, SkScalarNearlyEqual(prop(  4), 4));
+    }
+    {
+        // New style hold (hard stops)
+        MockProperty<ScalarValue> prop(R"({
+                                         "a": 1,
+                                         "k": [
+                                           { "t":  1, "s": 1, "h": true },
+                                           { "t":  2, "s": 2, "h": true },
+                                           { "t":  3, "s": 4, "h": true }
+                                         ]
+                                       })");
+        REPORTER_ASSERT(reporter, prop);
+        REPORTER_ASSERT(reporter, SkScalarNearlyEqual(prop(0  ), 1));
+        REPORTER_ASSERT(reporter, SkScalarNearlyEqual(prop(1  ), 1));
+        REPORTER_ASSERT(reporter, SkScalarNearlyEqual(prop(1.5), 1));
+        REPORTER_ASSERT(reporter, SkScalarNearlyEqual(prop(std::nextafter(2.f, 0.f)), 1));
+        REPORTER_ASSERT(reporter, SkScalarNearlyEqual(prop(2  ), 2));
+        REPORTER_ASSERT(reporter, SkScalarNearlyEqual(prop(2.5), 2));
+        REPORTER_ASSERT(reporter, SkScalarNearlyEqual(prop(std::nextafter(3.f, 0.f)), 2));
+        REPORTER_ASSERT(reporter, SkScalarNearlyEqual(prop(3  ), 4));
+        REPORTER_ASSERT(reporter, SkScalarNearlyEqual(prop(4  ), 4));
+    }
+    {
+        // Legacy style
+        MockProperty<ScalarValue> prop(R"({
+                                         "a": 1,
+                                         "k": [
+                                           { "t":  1, "s": 1, "e": 2 },
+                                           { "t":  2, "s": 2, "e": 4 },
+                                           { "t":  3 }
+                                         ]
+                                       })");
+        REPORTER_ASSERT(reporter, prop);
+        REPORTER_ASSERT(reporter, SkScalarNearlyEqual(prop(-1), 1));
+        REPORTER_ASSERT(reporter, SkScalarNearlyEqual(prop( 0), 1));
+        REPORTER_ASSERT(reporter, SkScalarNearlyEqual(prop( 1  ), 1));
+        REPORTER_ASSERT(reporter, SkScalarNearlyEqual(prop( 1.5), 1.5f));
+        REPORTER_ASSERT(reporter, SkScalarNearlyEqual(prop( 2  ), 2));
+        REPORTER_ASSERT(reporter, SkScalarNearlyEqual(prop( 2.5), 3));
+        REPORTER_ASSERT(reporter, SkScalarNearlyEqual(prop( 3  ), 4));
+        REPORTER_ASSERT(reporter, SkScalarNearlyEqual(prop( 4  ), 4));
+    }
+    {
+        // Legacy style hold (hard stops)
+        MockProperty<ScalarValue> prop(R"({
+                                         "a": 1,
+                                         "k": [
+                                           { "t":  1, "s": 1, "e": 2, "h": true },
+                                           { "t":  2, "s": 2, "e": 4, "h": true },
+                                           { "t":  3 }
+                                         ]
+                                       })");
+        REPORTER_ASSERT(reporter, prop);
+        REPORTER_ASSERT(reporter, SkScalarNearlyEqual(prop(0  ), 1));
+        REPORTER_ASSERT(reporter, SkScalarNearlyEqual(prop(1  ), 1));
+        REPORTER_ASSERT(reporter, SkScalarNearlyEqual(prop(1.5), 1));
+        REPORTER_ASSERT(reporter, SkScalarNearlyEqual(prop(std::nextafter(2.f, 0.f)), 1));
+        REPORTER_ASSERT(reporter, SkScalarNearlyEqual(prop(2  ), 2));
+        REPORTER_ASSERT(reporter, SkScalarNearlyEqual(prop(2.5), 2));
+        REPORTER_ASSERT(reporter, SkScalarNearlyEqual(prop(std::nextafter(3.f, 0.f)), 2));
+        REPORTER_ASSERT(reporter, SkScalarNearlyEqual(prop(3  ), 4));
+        REPORTER_ASSERT(reporter, SkScalarNearlyEqual(prop(4  ), 4));
+    }
+}