Fix 50% flip handling of CSS Animations using CSS wide keywords

Source/core/animation/StringKeyframe.cpp

 // Copyright 2014 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/StringKeyframe.h"
 
 #include "core/animation/AngleSVGInterpolation.h"
 #include "core/animation/CSSValueInterpolationType.h"
 #include "core/animation/ColorStyleInterpolation.h"
@@ skipping 165 matching lines @@
         }
         break;
     }
     applicableTypes->append(new CSSValueInterpolationType(property));
     applicableTypesMap.add(property, applicableTypes);
     return applicableTypes;
 }
 
 } // namespace
 
+PassRefPtrWillBeRawPtr<Interpolation> StringKeyframe::CSSPropertySpecificKeyframe::createLegacyStyleInterpolation(CSSPropertyID property, Keyframe::PropertySpecificKeyframe& end, Element* element, const ComputedStyle* baseStyle) const
+{
+    CSSValue& fromCSSValue = *m_value.get();
+    CSSValue& toCSSValue = *toCSSPropertySpecificKeyframe(end).value();
+    if (DeferredLegacyStyleInterpolation::interpolationRequiresStyleResolve(fromCSSValue) || DeferredLegacyStyleInterpolation::interpolationRequiresStyleResolve(toCSSValue)) {
+        // FIXME: Handle these cases outside of DeferredLegacyStyleInterpolation.
+        return DeferredLegacyStyleInterpolation::create(&fromCSSValue, &toCSSValue, property);
+    }
+
+    // FIXME: Remove the use of AnimatableValues and Elements here.
+    ASSERT(element);
+    populateAnimatableValue(property, *element, baseStyle);
+    end.populateAnimatableValue(property, *element, baseStyle);
+    return LegacyStyleInterpolation::create(getAnimatableValue(), end.getAnimatableValue(), property);
+}
+
 PassRefPtrWillBeRawPtr<Interpolation> StringKeyframe::CSSPropertySpecificKeyframe::maybeCreateInterpolation(PropertyHandle propertyHandle, Keyframe::PropertySpecificKeyframe& end, Element* element, const ComputedStyle* baseStyle) const
 {
     CSSPropertyID property = propertyHandle.cssProperty();
     const Vector<const InterpolationType*>* applicableTypes = applicableTypesForProperty(property);
     if (applicableTypes)
         return InvalidatableStyleInterpolation::create(*applicableTypes, *this, toCSSPropertySpecificKeyframe(end));
 
     // TODO(alancutter): Remove the remainder of this function.
 
     // FIXME: Refactor this into a generic piece that lives in InterpolationEffect, and a template parameter specific converter.
     CSSValue* fromCSSValue = m_value.get();
     CSSValue* toCSSValue = toCSSPropertySpecificKeyframe(end).value();
     InterpolationRange range = RangeAll;
-    bool fallBackToLegacy = false;
 
     // FIXME: Remove this flag once we can rely on legacy's behaviour being correct.
     bool forceDefaultInterpolation = false;
 
     // FIXME: Remove this check once neutral keyframes are implemented in StringKeyframes.
     if (!fromCSSValue || !toCSSValue)
         return DeferredLegacyStyleInterpolation::create(fromCSSValue, toCSSValue, property);
 
     ASSERT(fromCSSValue && toCSSValue);
 
     if (!CSSPropertyMetadata::isInterpolableProperty(property)) {
         if (fromCSSValue == toCSSValue)
             return ConstantStyleInterpolation::create(fromCSSValue, property);
 
         return nullptr;
     }
 
+    if (fromCSSValue->isCSSWideKeyword() || toCSSValue->isCSSWideKeyword())
+        return createLegacyStyleInterpolation(property, end, element, baseStyle);
+
     switch (property) {
     case CSSPropertyLineHeight:
         if (LengthStyleInterpolation::canCreateFrom(*fromCSSValue) && LengthStyleInterpolation::canCreateFrom(*toCSSValue))
             return LengthStyleInterpolation::create(*fromCSSValue, *toCSSValue, property, RangeNonNegative);
 
         if (DoubleStyleInterpolation::canCreateFrom(*fromCSSValue) && DoubleStyleInterpolation::canCreateFrom(*toCSSValue))
             return DoubleStyleInterpolation::create(*fromCSSValue, *toCSSValue, property, true, RangeNonNegative);
 
         break;
     case CSSPropertyBorderBottomWidth:
@@ skipping 48 matching lines @@
     case CSSPropertyWebkitTransformOriginX:
     case CSSPropertyWebkitTransformOriginY:
     case CSSPropertyWebkitTransformOriginZ:
     case CSSPropertyX:
     case CSSPropertyY:
         if (LengthStyleInterpolation::canCreateFrom(*fromCSSValue, property) && LengthStyleInterpolation::canCreateFrom(*toCSSValue, property))
             return LengthStyleInterpolation::create(*fromCSSValue, *toCSSValue, property, range);
 
         // FIXME: Handle keywords e.g. 'smaller', 'larger'.
         if (property == CSSPropertyFontSize)
-            fallBackToLegacy = true;
+            return createLegacyStyleInterpolation(property, end, element, baseStyle);
 
         // FIXME: Handle keywords e.g. 'baseline', 'sub'.
         if (property == CSSPropertyBaselineShift)
-            fallBackToLegacy = true;
+            return createLegacyStyleInterpolation(property, end, element, baseStyle);
 
         break;
     case CSSPropertyOrphans:
     case CSSPropertyWidows:
     case CSSPropertyZIndex:
     case CSSPropertyWebkitColumnCount:
     case CSSPropertyShapeImageThreshold:
     case CSSPropertyFillOpacity:
     case CSSPropertyFloodOpacity:
     case CSSPropertyFontSizeAdjust:
@@ skipping 32 matching lines @@
     case CSSPropertyTextDecorationColor:
     case CSSPropertyWebkitColumnRuleColor:
     case CSSPropertyWebkitTextStrokeColor:
         {
             RefPtrWillBeRawPtr<Interpolation> interpolation = ColorStyleInterpolation::maybeCreateFromColor(*fromCSSValue, *toCSSValue, property);
             if (interpolation)
                 return interpolation.release();
 
             // Current color should use LegacyStyleInterpolation
             if (ColorStyleInterpolation::shouldUseLegacyStyleInterpolation(*fromCSSValue, *toCSSValue))
-                fallBackToLegacy = true;
+                return createLegacyStyleInterpolation(property, end, element, baseStyle);
 
             break;
         }
 
     case CSSPropertyBorderImageSource:
     case CSSPropertyListStyleImage:
     case CSSPropertyWebkitMaskBoxImageSource:
         if (fromCSSValue == toCSSValue)
             return ConstantStyleInterpolation::create(fromCSSValue, property);
 
@@ skipping 13 matching lines @@
             return LengthPairStyleInterpolation::create(*fromCSSValue, *toCSSValue, property, range);
         break;
 
     case CSSPropertyPerspectiveOrigin:
     case CSSPropertyTransformOrigin: {
         RefPtrWillBeRawPtr<Interpolation> interpolation = ListStyleInterpolation<LengthStyleInterpolation>::maybeCreateFromList(*fromCSSValue, *toCSSValue, property, range);
         if (interpolation)
             return interpolation.release();
 
         // FIXME: Handle keywords: top, right, left, center, bottom
-        fallBackToLegacy = true;
-
-        break;
+        return createLegacyStyleInterpolation(property, end, element, baseStyle);
     }
 
     case CSSPropertyBoxShadow:
     case CSSPropertyTextShadow: {
         RefPtrWillBeRawPtr<Interpolation> interpolation = ListStyleInterpolation<ShadowStyleInterpolation>::maybeCreateFromList(*fromCSSValue, *toCSSValue, property);
         if (interpolation)
             return interpolation.release();
 
         // FIXME: AnimatableShadow incorrectly animates between inset and non-inset values so it will never indicate it needs default interpolation
         if (ShadowStyleInterpolation::usesDefaultStyleInterpolation(*fromCSSValue, *toCSSValue)) {
             forceDefaultInterpolation = true;
             break;
         }
 
         // FIXME: Handle interpolation from/to none, unspecified color values
-        fallBackToLegacy = true;
-
-        break;
-
+        return createLegacyStyleInterpolation(property, end, element, baseStyle);
     }
 
     case CSSPropertyClip: {
         if (LengthBoxStyleInterpolation::usesDefaultInterpolation(*fromCSSValue, *toCSSValue)) {
             forceDefaultInterpolation = true;
             break;
         }
         RefPtrWillBeRawPtr<Interpolation> interpolation = LengthBoxStyleInterpolation::maybeCreateFrom(*fromCSSValue, *toCSSValue, property);
         if (interpolation)
             return interpolation.release();
@@ skipping 18 matching lines @@
 
         break;
     }
 
     case CSSPropertyWebkitFilter: {
         RefPtrWillBeRawPtr<Interpolation> interpolation = FilterStyleInterpolation::maybeCreateList(*fromCSSValue, *toCSSValue, property);
         if (interpolation)
             return interpolation.release();
 
         // FIXME: Support drop shadow interpolation.
-        fallBackToLegacy = true;
+        return createLegacyStyleInterpolation(property, end, element, baseStyle);
         break;
     }
 
     case CSSPropertyTranslate: {
         RefPtrWillBeRawPtr<Interpolation> interpolation = ListStyleInterpolation<LengthStyleInterpolation>::maybeCreateFromList(*fromCSSValue, *toCSSValue, property, range);
         if (interpolation)
             return interpolation.release();
 
         // TODO(soonm): Legacy mode is used when from and to cssvaluelist length does not match.
-        fallBackToLegacy = true;
+        return createLegacyStyleInterpolation(property, end, element, baseStyle);
         break;
     }
 
     case CSSPropertyScale: {
         RefPtrWillBeRawPtr<Interpolation> interpolation = ListStyleInterpolation<DoubleStyleInterpolation>::maybeCreateFromList(*fromCSSValue, *toCSSValue, property, range);
         if (interpolation)
             return interpolation.release();
 
         // TODO(soonm): Legacy mode is used when from and to cssvaluelist length does not match.
-        fallBackToLegacy = true;
+        return createLegacyStyleInterpolation(property, end, element, baseStyle);
         break;
     }
 
     default:
         // Fall back to LegacyStyleInterpolation.
-        fallBackToLegacy = true;
+        return createLegacyStyleInterpolation(property, end, element, baseStyle);
         break;
     }
 
     if (fromCSSValue == toCSSValue)
         return ConstantStyleInterpolation::create(fromCSSValue, property);
 
-    if (forceDefaultInterpolation)
-        return nullptr;
-
-    if (fromCSSValue->isCSSWideKeyword() || toCSSValue->isCSSWideKeyword())
-        fallBackToLegacy = true;
-
-    if (fallBackToLegacy) {
-        if (DeferredLegacyStyleInterpolation::interpolationRequiresStyleResolve(*fromCSSValue) || DeferredLegacyStyleInterpolation::interpolationRequiresStyleResolve(*toCSSValue)) {
-            // FIXME: Handle these cases outside of DeferredLegacyStyleInterpolation.
-            return DeferredLegacyStyleInterpolation::create(fromCSSValue, toCSSValue, property);
-        }
-
-        // FIXME: Remove the use of AnimatableValues and Elements here.
-        ASSERT(element);
-        populateAnimatableValue(property, *element, baseStyle);
-        end.populateAnimatableValue(property, *element, baseStyle);
-        return LegacyStyleInterpolation::create(getAnimatableValue(), end.getAnimatableValue(), property);
+    if (!forceDefaultInterpolation) {
+        ASSERT(AnimatableValue::usesDefaultInterpolation(
+            StyleResolver::createAnimatableValueSnapshot(*element, baseStyle, property, fromCSSValue).get(),
+            StyleResolver::createAnimatableValueSnapshot(*element, baseStyle, property, toCSSValue).get()));
     }
 
-    ASSERT(AnimatableValue::usesDefaultInterpolation(
-        StyleResolver::createAnimatableValueSnapshot(*element, baseStyle, property, fromCSSValue).get(),
-        StyleResolver::createAnimatableValueSnapshot(*element, baseStyle, property, toCSSValue).get()));
-
     return nullptr;
 
 }
 
 PassOwnPtrWillBeRawPtr<Keyframe::PropertySpecificKeyframe> StringKeyframe::CSSPropertySpecificKeyframe::neutralKeyframe(double offset, PassRefPtr<TimingFunction> easing) const
 {
     return adoptPtrWillBeNoop(new CSSPropertySpecificKeyframe(offset, easing, static_cast<CSSValue*>(0), EffectModel::CompositeAdd));
 }
 
 PassOwnPtrWillBeRawPtr<Keyframe::PropertySpecificKeyframe> StringKeyframe::CSSPropertySpecificKeyframe::cloneWithOffset(double offset) const
@@ skipping 102 matching lines @@
     RefPtrWillBeRawPtr<SVGPropertyBase> fromValue = attribute->currentValueBase()->cloneForAnimation(m_value);
     RefPtrWillBeRawPtr<SVGPropertyBase> toValue = attribute->currentValueBase()->cloneForAnimation(toSVGPropertySpecificKeyframe(end).value());
 
     if (!fromValue || !toValue)
         return nullptr;
 
     return createSVGInterpolation(fromValue.get(), toValue.get(), attribute.get());
 }
 
 } // namespace blink