Don't use pairwise keyframe interpolation at fractions 0 and 1.

third_party/WebKit/Source/core/animation/InvalidatableStyleInterpolation.cpp

 // Copyright 2015 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "config.h"
 #include "core/animation/InvalidatableStyleInterpolation.h"
 
 #include "core/animation/StringKeyframe.h"
 #include "core/css/resolver/StyleResolverState.h"
 
 namespace blink {
 
-InvalidatableStyleInterpolation::InvalidatableStyleInterpolation(
-    const Vector<const InterpolationType*>& interpolationTypes,
-    const CSSPropertySpecificKeyframe& startKeyframe,
-    const CSSPropertySpecificKeyframe& endKeyframe)
-    : StyleInterpolation(nullptr, nullptr, interpolationTypes.first()->property())
-    , m_interpolationTypes(interpolationTypes)
-    , m_startKeyframe(&startKeyframe)
-    , m_endKeyframe(&endKeyframe)
+void InvalidatableStyleInterpolation::interpolate(int, double fraction)
 {
-    maybeCachePairwiseConversion(nullptr, UnderlyingValue());
-    interpolate(0, 0);
+    if (fraction == m_currentFraction)
+        return;
+
+    if (m_currentFraction == 0 || m_currentFraction == 1 || fraction == 0 || fraction == 1)
+        clearCache();
+
+    m_currentFraction = fraction;
+    if (!m_isCachePending && m_cachedPairConversion)
+        m_cachedPairConversion->interpolateValue(fraction, m_cachedValue);
+    // We defer the interpolation to ensureValidInterpolation() if m_cachedPairConversion is null.
 }
 
-bool InvalidatableStyleInterpolation::maybeCachePairwiseConversion(const StyleResolverState* state, const UnderlyingValue& underlyingValue) const
+PassOwnPtr<PairwisePrimitiveInterpolation> InvalidatableStyleInterpolation::maybeConvertPairwise(const StyleResolverState* state, const UnderlyingValue& underlyingValue) const
 {
+    ASSERT(m_currentFraction != 0 && m_currentFraction != 1);
     for (const auto& interpolationType : m_interpolationTypes) {
         if ((m_startKeyframe->isNeutral() || m_endKeyframe->isNeutral()) && (!underlyingValue || underlyingValue->type() != *interpolationType))
             continue;
         OwnPtr<PairwisePrimitiveInterpolation> pairwiseConversion = interpolationType->maybeConvertPairwise(*m_startKeyframe, *m_endKeyframe, state, underlyingValue, m_conversionCheckers);
-        if (pairwiseConversion) {
-            m_cachedValue = pairwiseConversion->initialValue();
-            m_cachedConversion = pairwiseConversion.release();
-            return true;
-        }
+        if (pairwiseConversion)
+            return pairwiseConversion.release();
     }
-    return false;
-}
-
-void InvalidatableStyleInterpolation::interpolate(int, double fraction)
-{
-    m_currentFraction = fraction;
-    if (m_cachedConversion)
-        m_cachedConversion->interpolateValue(fraction, m_cachedValue);
-    // We defer the interpolation to ensureValidInterpolation() if m_cachedConversion is null.
+    return nullptr;
 }
 
 PassOwnPtr<InterpolationValue> InvalidatableStyleInterpolation::convertSingleKeyframe(const CSSPropertySpecificKeyframe& keyframe, const StyleResolverState& state, const UnderlyingValue& underlyingValue) const
 {
     if (keyframe.isNeutral() && !underlyingValue)
         return nullptr;
     for (const auto& interpolationType : m_interpolationTypes) {
         UnderlyingValue conversionUnderlyingValue;
         if (underlyingValue && underlyingValue->type() == *interpolationType)
             conversionUnderlyingValue.set(underlyingValue.get());
@@ skipping 20 matching lines @@
 bool InvalidatableStyleInterpolation::dependsOnUnderlyingValue() const
 {
     return (m_startKeyframe->underlyingFraction() != 0 && m_currentFraction != 1) || (m_endKeyframe->underlyingFraction() != 0 && m_currentFraction != 0);
 }
 
 bool InvalidatableStyleInterpolation::isNeutralKeyframeActive() const
 {
     return (m_startKeyframe->isNeutral() && m_currentFraction != 1) || (m_endKeyframe->isNeutral() && m_currentFraction != 0);
 }
 
+void InvalidatableStyleInterpolation::clearCache() const
+{
+    m_isCachePending = true;
+    m_cachedPairConversion.clear();
+    m_conversionCheckers.clear();
+    m_cachedValue.clear();
+}
+
 bool InvalidatableStyleInterpolation::isCacheValid(const StyleResolverState& state, const UnderlyingValue& underlyingValue) const
 {
+    if (m_isCachePending)
+        return false;
     if (isNeutralKeyframeActive()) {
-        if (m_cachedConversion->isFlip())
+        if (m_cachedPairConversion && m_cachedPairConversion->isFlip())
             return false;
         // Pairwise interpolation can never happen between different InterpolationTypes, neutral values always represent the underlying value.
         if (!underlyingValue || !m_cachedValue || m_cachedValue->type() != underlyingValue->type())
             return false;
     }
     for (const auto& checker : m_conversionCheckers) {
         UnderlyingValue checkedUnderlyingValue;
         if (underlyingValue && underlyingValue->type() == checker->type())
             checkedUnderlyingValue.set(underlyingValue.get());
         if (!checker->isValid(state, checkedUnderlyingValue))
             return false;
     }
     return true;
 }
 
 const InterpolationValue* InvalidatableStyleInterpolation::ensureValidInterpolation(const StyleResolverState& state, const UnderlyingValue& underlyingValue) const
 {
-    if (m_cachedConversion && isCacheValid(state, underlyingValue))
+    if (isCacheValid(state, underlyingValue))
         return m_cachedValue.get();
-    m_conversionCheckers.clear();
-    if (!maybeCachePairwiseConversion(&state, underlyingValue)) {
-        m_cachedConversion = FlipPrimitiveInterpolation::create(
-            convertSingleKeyframe(*m_startKeyframe, state, underlyingValue),
-            convertSingleKeyframe(*m_endKeyframe, state, underlyingValue));
+    clearCache();
+    if (m_currentFraction == 0) {
+        m_cachedValue = convertSingleKeyframe(*m_startKeyframe, state, underlyingValue);
+    } else if (m_currentFraction == 1) {
+        m_cachedValue = convertSingleKeyframe(*m_endKeyframe, state, underlyingValue);
+    } else {
+        OwnPtr<PairwisePrimitiveInterpolation> pairwiseConversion = maybeConvertPairwise(&state, underlyingValue);
+        if (pairwiseConversion) {
+            m_cachedValue = pairwiseConversion->initialValue();
+            m_cachedPairConversion = pairwiseConversion.release();
+        } else {
+            m_cachedPairConversion = FlipPrimitiveInterpolation::create(
+                convertSingleKeyframe(*m_startKeyframe, state, underlyingValue),
+                convertSingleKeyframe(*m_endKeyframe, state, underlyingValue));
+        }
+        m_cachedPairConversion->interpolateValue(m_currentFraction, m_cachedValue);
     }
-    m_cachedConversion->interpolateValue(m_currentFraction, m_cachedValue);
+    m_isCachePending = false;
     return m_cachedValue.get();
 }
 
 void InvalidatableStyleInterpolation::setFlagIfInheritUsed(StyleResolverState& state) const
 {
     if (!state.parentStyle())
         return;
     if ((m_startKeyframe->value() && m_startKeyframe->value()->isInheritedValue())
         || (m_endKeyframe->value() && m_endKeyframe->value()->isInheritedValue())) {
         state.parentStyle()->setHasExplicitlyInheritedProperties();
     }
 }
 
 double InvalidatableStyleInterpolation::underlyingFraction() const
 {
-    return m_cachedConversion->interpolateUnderlyingFraction(m_startKeyframe->underlyingFraction(), m_endKeyframe->underlyingFraction(), m_currentFraction);
+    if (m_currentFraction == 0)
+        return m_startKeyframe->underlyingFraction();
+    if (m_currentFraction == 1)
+        return m_endKeyframe->underlyingFraction();
+    return m_cachedPairConversion->interpolateUnderlyingFraction(m_startKeyframe->underlyingFraction(), m_endKeyframe->underlyingFraction(), m_currentFraction);
 }
 
 void InvalidatableStyleInterpolation::applyStack(const ActiveInterpolations& interpolations, StyleResolverState& state)
 {
     ASSERT(!interpolations.isEmpty());
     size_t startingIndex = 0;
 
     // Compute the underlying value to composite onto.
     UnderlyingValue underlyingValue;
     const InvalidatableStyleInterpolation& firstInterpolation = toInvalidatableStyleInterpolation(*interpolations.at(startingIndex));
@@ skipping 28 matching lines @@
             underlyingValue.set(currentValue);
         else
             currentValue->type().composite(underlyingValue, underlyingFraction, *currentValue);
     }
 
     if (shouldApply && underlyingValue)
         underlyingValue->type().apply(underlyingValue->interpolableValue(), underlyingValue->nonInterpolableValue(), state);
 }
 
 } // namespace blink