Implemented additive animations for length

Source/core/css/resolver/StyleResolver.cpp

 /*
  * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
  *           (C) 2004-2005 Allan Sandfeld Jensen (kde@carewolf.com)
  * Copyright (C) 2006, 2007 Nicholas Shanks (webkit@nickshanks.com)
  * Copyright (C) 2005, 2006, 2007, 2008, 2009, 2010, 2011, 2012, 2013 Apple Inc. All rights reserved.
  * Copyright (C) 2007 Alexey Proskuryakov <ap@webkit.org>
  * Copyright (C) 2007, 2008 Eric Seidel <eric@webkit.org>
  * Copyright (C) 2008, 2009 Torch Mobile Inc. All rights reserved. (http://www.torchmobile.com/)
  * Copyright (c) 2011, Code Aurora Forum. All rights reserved.
  * Copyright (C) Research In Motion Limited 2011. All rights reserved.
@@ skipping 18 matching lines @@
 #include "config.h"
 #include "core/css/resolver/StyleResolver.h"
 
 #include "core/CSSPropertyNames.h"
 #include "core/HTMLNames.h"
 #include "core/MediaTypeNames.h"
 #include "core/StylePropertyShorthand.h"
 #include "core/animation/ActiveAnimations.h"
 #include "core/animation/Animation.h"
 #include "core/animation/AnimationTimeline.h"
+#include "core/animation/InterpolationFactory.h"
 #include "core/animation/StyleInterpolation.h"
 #include "core/animation/animatable/AnimatableValue.h"
 #include "core/animation/css/CSSAnimatableValueFactory.h"
 #include "core/animation/css/CSSAnimations.h"
 #include "core/css/CSSCalculationValue.h"
 #include "core/css/CSSDefaultStyleSheets.h"
 #include "core/css/CSSFontSelector.h"
 #include "core/css/CSSKeyframeRule.h"
 #include "core/css/CSSKeyframesRule.h"
 #include "core/css/CSSReflectValue.h"
 #include "core/css/CSSRuleList.h"
 #include "core/css/CSSSelector.h"
 #include "core/css/CSSStyleRule.h"
 #include "core/css/CSSValueList.h"
 #include "core/css/CSSValuePool.h"
 #include "core/css/ElementRuleCollector.h"
 #include "core/css/FontFace.h"
+#include "core/css/LayoutStyleCSSValueMapping.h"
 #include "core/css/MediaQueryEvaluator.h"
 #include "core/css/PageRuleCollector.h"
 #include "core/css/StylePropertySet.h"
 #include "core/css/StyleRuleImport.h"
 #include "core/css/StyleSheetContents.h"
 #include "core/css/resolver/AnimatedStyleBuilder.h"
 #include "core/css/resolver/MatchResult.h"
 #include "core/css/resolver/MediaQueryResult.h"
 #include "core/css/resolver/ScopedStyleResolver.h"
 #include "core/css/resolver/SharedStyleFinder.h"
@@ skipping 946 matching lines @@
     ASSERT(animatingElement == element || !animatingElement || animatingElement->parentOrShadowHostElement() == element);
 
     if (!(animatingElement && animatingElement->hasActiveAnimations())
         && !state.style()->transitions() && !state.style()->animations())
         return false;
 
     state.setAnimationUpdate(CSSAnimations::calculateUpdate(animatingElement, *element, *state.style(), state.parentStyle(), this));
     if (!state.animationUpdate())
         return false;
 
-    const WillBeHeapHashMap<CSSPropertyID, RefPtrWillBeMember<Interpolation> >& activeInterpolationsForAnimations = state.animationUpdate()->activeInterpolationsForAnimations();
-    const WillBeHeapHashMap<CSSPropertyID, RefPtrWillBeMember<Interpolation> >& activeInterpolationsForTransitions = state.animationUpdate()->activeInterpolationsForTransitions();
+    const InterpolationPipelineMap& activeInterpolationsForAnimations = state.animationUpdate()->activeInterpolationsForAnimations();
+    const InterpolationPipelineMap& activeInterpolationsForTransitions = state.animationUpdate()->activeInterpolationsForTransitions();
     applyAnimatedProperties<HighPropertyPriority>(state, activeInterpolationsForAnimations);
     applyAnimatedProperties<HighPropertyPriority>(state, activeInterpolationsForTransitions);
 
     updateFont(state);
 
     applyAnimatedProperties<LowPropertyPriority>(state, activeInterpolationsForAnimations);
     applyAnimatedProperties<LowPropertyPriority>(state, activeInterpolationsForTransitions);
 
     // Start loading resources used by animations.
     loadPendingResources(state);
@@ skipping 11 matching lines @@
         resolvers.append(scopedResolver);
 
     for (size_t i = 0; i < resolvers.size(); ++i) {
         if (StyleRuleKeyframes* keyframesRule = resolvers[i]->keyframeStylesForAnimation(animationName.impl()))
             return keyframesRule;
     }
     return nullptr;
 }
 
 template <CSSPropertyPriority priority>
-void StyleResolver::applyAnimatedProperties(StyleResolverState& state, const WillBeHeapHashMap<CSSPropertyID, RefPtrWillBeMember<Interpolation> >& activeInterpolations)
+void StyleResolver::applyAnimatedProperties(StyleResolverState& state, const InterpolationPipelineMap& activeInterpolations)
 {
     for (const auto& interpolationEntry : activeInterpolations) {
         CSSPropertyID property = interpolationEntry.key;
         if (!CSSPropertyPriorityData<priority>::propertyHasPriority(property))
             continue;
-        const StyleInterpolation* interpolation = toStyleInterpolation(interpolationEntry.value.get());
-        interpolation->apply(state);
+
+        const InterpolationPipeline& pipeline = interpolationEntry.value;
+
+        RefPtrWillBeRawPtr<Interpolation> firstInterpolation = pipeline.at(0);
+
+        RefPtrWillBeRawPtr<Interpolation> underlyingInterpolation = nullptr;
+
+        OwnPtrWillBeRawPtr<InterpolableValue> underlyingValue = nullptr;
+        OwnPtrWillBeRawPtr<InterpolableValue> multipliedValue = nullptr;
+
+        if (firstInterpolation->cachedUnderlyingFraction() != 0) {
+            // Pull CSSValue from the LayoutStyle
+            RefPtrWillBeRawPtr<CSSValue> underlyingCSSValue = LayoutStyleCSSValueMapping::get(property, *state.style());
+            ASSERT(underlyingCSSValue);
+
+            // Create interpolation from underlying value
+            underlyingInterpolation = InterpolationFactory::createConstantInterpolation(
+                property,
+                underlyingCSSValue.get(),
+                AnimationEffect::CompositeReplace,
+                AnimationEffect::CompositeReplace
+            );
+
+            multipliedValue = underlyingInterpolation->cachedValue().clone();
+            underlyingValue = underlyingInterpolation->cachedValue().clone();
+
+            if (underlyingInterpolation->cachedValue().typesMatch(firstInterpolation->cachedValue())) {
+                // Multiply by the first interpolation's underlying
+                // fraction
+                underlyingInterpolation->cachedValue().multiply(firstInterpolation->cachedUnderlyingFraction(), *multipliedValue);
+
+                // Add the multiplied underlying value and currentValue
+                // to produce the final underlying value for use in the
+                // additive pipeline
+                multipliedValue->add(firstInterpolation->cachedValue(), *underlyingValue);
+            }

[alancutter (OOO until 2018), 2015/02/17 03:50:56]

Instead of duplicating the loop here just set startingIndex = 0 in this body and
startingIndex = 1 in the else body.

+        } else {
+            underlyingInterpolation = firstInterpolation;
+
+            underlyingValue = underlyingInterpolation->cachedValue().clone();
+            multipliedValue = underlyingInterpolation->cachedValue().clone();

[alancutter (OOO until 2018), 2015/02/17 03:50:56]

We must try to avoid the double IV clone in the common case of a single replace
Interpolation.
Here's my attempt to clone only when necessary, feel free to try making it
nicer:
    // FIXME: Remove these clone OwnPtrs once the Oilpan conversion is complete.
    OwnPtrWillBeRawPtr<InterpolableValue> underlyingValueClone;
    OwnPtrWillBeRawPtr<InterpolableValue> multipliedValueClone;
    InterpolableValue* underlyingValue =
&underlyingInterpolation->cachedValue();
    InterpolableValue* multipliedValue = nullptr;
    if (startIndex < pipeline.size()) {
        underlyingValueClone = underlyingInterpolation->cachedValue().clone();
        underlyingValue = underlyingValueClone.get();
        multipliedValueClone = underlyingInterpolation->cachedValue().clone();
        multipliedValue = multipliedValueClone.get();
    }

[alancutter (OOO until 2018), 2015/02/17 04:08:37]

Actually scratch that. The simpler way to do it is just
    if (startingIndex >= pipeline.size()) {
        toStyleInterpolation(*underlyingInterpolation).apply(state,
underlyingInterpolation->cachedValue());
        continue;
    }
prior to cloning.

+        }
+
+        for (size_t index = 1; index < pipeline.size(); index++) {
+            RefPtrWillBeRawPtr<Interpolation> currentInterpolation = pipeline.at(index);
+
+            if (underlyingValue->typesMatch(currentInterpolation->cachedValue())) {
+                underlyingValue->multiply(currentInterpolation->cachedUnderlyingFraction(), *multipliedValue);
+                multipliedValue->add(currentInterpolation->cachedValue(), *underlyingValue);
+
+                underlyingInterpolation = currentInterpolation;
+            }
+        }
+
+        const StyleInterpolation* interpolation = toStyleInterpolation(underlyingInterpolation.get());
+        interpolation->apply(state, *underlyingValue);
     }
 }
 
 static inline bool isValidCueStyleProperty(CSSPropertyID id)
 {
     switch (id) {
     case CSSPropertyBackground:
     case CSSPropertyBackgroundAttachment:
     case CSSPropertyBackgroundClip:
     case CSSPropertyBackgroundColor:
@@ skipping 474 matching lines @@
     visitor->trace(m_uncommonAttributeRuleSet);
     visitor->trace(m_watchedSelectorsRules);
     visitor->trace(m_treeBoundaryCrossingRules);
     visitor->trace(m_styleSharingLists);
     visitor->trace(m_pendingStyleSheets);
     visitor->trace(m_document);
 #endif
 }
 
 } // namespace blink