Web Animations: Update naming to reflect spec changes

Source/core/animation/CompositorAnimations.cpp

 /*
  * Copyright (C) 2013 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 13 matching lines @@
  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 #include "config.h"
 #include "core/animation/CompositorAnimations.h"
 
-#include "core/animation/AnimationNode.h"
+#include "core/animation/AnimationEffect.h"
 #include "core/animation/AnimationTranslationUtil.h"
 #include "core/animation/ElementAnimations.h"
 #include "core/animation/CompositorAnimationsImpl.h"
 #include "core/animation/animatable/AnimatableDouble.h"
 #include "core/animation/animatable/AnimatableFilterOperations.h"
 #include "core/animation/animatable/AnimatableTransform.h"
 #include "core/animation/animatable/AnimatableValue.h"
 #include "core/layout/LayoutBoxModelObject.h"
 #include "core/layout/LayoutObject.h"
 #include "core/layout/compositing/CompositedDeprecatedPaintLayerMapping.h"
@@ skipping 21 matching lines @@
 void getKeyframeValuesForProperty(const KeyframeEffectModelBase* effect, PropertyHandle property, double scale, PropertySpecificKeyframeVector& values)
 {
     ASSERT(values.isEmpty());
 
     for (const auto& keyframe : effect->getPropertySpecificKeyframes(property)) {
         double offset = keyframe->offset() * scale;
         values.append(keyframe->cloneWithOffset(offset));
     }
 }
 
-bool considerPlayerAsIncompatible(const AnimationPlayer& player, const AnimationPlayer& playerToAdd)
+bool considerAnimationAsIncompatible(const Animation& animation, const Animation& animationToAdd)
 {
-    if (&player == &playerToAdd)
+    if (&animation == &animationToAdd)
         return false;
 
-    switch (player.playStateInternal()) {
-    case AnimationPlayer::Idle:
+    switch (animation.playStateInternal()) {
+    case Animation::Idle:
         return false;
-    case AnimationPlayer::Pending:
-    case AnimationPlayer::Running:
+    case Animation::Pending:
+    case Animation::Running:
         return true;
-    case AnimationPlayer::Paused:
-    case AnimationPlayer::Finished:
-        return AnimationPlayer::hasLowerPriority(&playerToAdd, &player);
+    case Animation::Paused:
+    case Animation::Finished:
+        return Animation::hasLowerPriority(&animationToAdd, &animation);
     default:
         ASSERT_NOT_REACHED();
         return true;
     }
 }
 
-bool hasIncompatibleAnimations(const Element& targetElement, const AnimationPlayer& playerToAdd, const AnimationEffect& effectToAdd)
+bool hasIncompatibleAnimations(const Element& targetElement, const Animation& animationToAdd, const EffectModel& effectToAdd)
 {
     const bool affectsOpacity = effectToAdd.affects(PropertyHandle(CSSPropertyOpacity));
     const bool affectsTransform = effectToAdd.affects(PropertyHandle(CSSPropertyTransform));
     const bool affectsFilter = effectToAdd.affects(PropertyHandle(CSSPropertyWebkitFilter));
 
     if (!targetElement.hasAnimations())
         return false;
 
     ElementAnimations* elementAnimations = targetElement.elementAnimations();
     ASSERT(elementAnimations);
 
-    for (const auto& entry : elementAnimations->players()) {
-        const AnimationPlayer* attachedPlayer = entry.key;
-        if (!considerPlayerAsIncompatible(*attachedPlayer, playerToAdd))
+    for (const auto& entry : elementAnimations->animations()) {
+        const Animation* attachedAnimation = entry.key;
+        if (!considerAnimationAsIncompatible(*attachedAnimation, animationToAdd))
             continue;
 
-        if ((affectsOpacity && attachedPlayer->affects(targetElement, CSSPropertyOpacity))
-            || (affectsTransform && attachedPlayer->affects(targetElement, CSSPropertyTransform))
-            || (affectsFilter && attachedPlayer->affects(targetElement, CSSPropertyWebkitFilter)))
+        if ((affectsOpacity && attachedAnimation->affects(targetElement, CSSPropertyOpacity))
+            || (affectsTransform && attachedAnimation->affects(targetElement, CSSPropertyTransform))
+            || (affectsFilter && attachedAnimation->affects(targetElement, CSSPropertyWebkitFilter)))
             return true;
     }
 
     return false;
 }
 
 }
 
 CSSPropertyID CompositorAnimations::CompositableProperties[3] = {
     CSSPropertyOpacity, CSSPropertyTransform, CSSPropertyWebkitFilter
 };
 
-bool CompositorAnimations::getAnimatedBoundingBox(FloatBox& box, const AnimationEffect& effect, double minValue, double maxValue) const
+bool CompositorAnimations::getAnimatedBoundingBox(FloatBox& box, const EffectModel& effect, double minValue, double maxValue) const
 {
     const KeyframeEffectModelBase& keyframeEffect = toKeyframeEffectModelBase(effect);
 
     PropertyHandleSet properties = keyframeEffect.properties();
 
     if (properties.isEmpty())
         return true;
 
     minValue = std::min(minValue, 0.0);
     maxValue = std::max(maxValue, 1.0);
@@ skipping 12 matching lines @@
 
         FloatBox originalBox(box);
 
         for (size_t j = 0; j < frames.size() - 1; ++j) {
             const AnimatableTransform* startTransform = toAnimatableTransform(frames[j]->getAnimatableValue().get());
             const AnimatableTransform* endTransform = toAnimatableTransform(frames[j+1]->getAnimatableValue().get());
             if (!startTransform || !endTransform)
                 return false;
 
             // TODO: Add support for inflating modes other than Replace.
-            if (frames[j]->composite() != AnimationEffect::CompositeReplace)
+            if (frames[j]->composite() != EffectModel::CompositeReplace)
                 return false;
 
             const TimingFunction& timing = frames[j]->easing();
             double min = 0;
             double max = 1;
             if (j == 0) {
                 float frameLength = frames[j+1]->offset();
                 if (frameLength > 0) {
                     min = minValue / frameLength;
                 }
@@ skipping 13 matching lines @@
             box.expandTo(bounds);
         }
     }
     return true;
 }
 
 // -----------------------------------------------------------------------
 // CompositorAnimations public API
 // -----------------------------------------------------------------------
 
-bool CompositorAnimations::isCandidateForAnimationOnCompositor(const Timing& timing, const Element& targetElement, const AnimationPlayer* playerToAdd, const AnimationEffect& effect, double playerPlaybackRate)
+bool CompositorAnimations::isCandidateForAnimationOnCompositor(const Timing& timing, const Element& targetElement, const Animation* animationToAdd, const EffectModel& effect, double animationPlaybackRate)
 {
     const KeyframeEffectModelBase& keyframeEffect = toKeyframeEffectModelBase(effect);
 
     PropertyHandleSet properties = keyframeEffect.properties();
     if (properties.isEmpty())
         return false;
 
     for (const auto& property : properties) {
         if (!property.isCSSProperty())
             return false;
 
         const PropertySpecificKeyframeVector& keyframes = keyframeEffect.getPropertySpecificKeyframes(property);
         ASSERT(keyframes.size() >= 2);
         for (const auto& keyframe : keyframes) {
             // FIXME: Determine candidacy based on the CSSValue instead of a snapshot AnimatableValue.
-            bool isNeutralKeyframe = keyframe->isCSSPropertySpecificKeyframe() && !toCSSPropertySpecificKeyframe(keyframe.get())->value() && keyframe->composite() == AnimationEffect::CompositeAdd;
-            if ((keyframe->composite() != AnimationEffect::CompositeReplace && !isNeutralKeyframe) || !keyframe->getAnimatableValue())
+            bool isNeutralKeyframe = keyframe->isCSSPropertySpecificKeyframe() && !toCSSPropertySpecificKeyframe(keyframe.get())->value() && keyframe->composite() == EffectModel::CompositeAdd;
+            if ((keyframe->composite() != EffectModel::CompositeReplace && !isNeutralKeyframe) || !keyframe->getAnimatableValue())
                 return false;
 
             switch (property.cssProperty()) {
             case CSSPropertyOpacity:
                 break;
             case CSSPropertyTransform:
                 if (toAnimatableTransform(keyframe->getAnimatableValue().get())->transformOperations().dependsOnBoxSize())
                     return false;
                 break;
             case CSSPropertyWebkitFilter: {
                 const FilterOperations& operations = toAnimatableFilterOperations(keyframe->getAnimatableValue().get())->operations();
                 if (operations.hasFilterThatMovesPixels())
                     return false;
                 break;
             }
             default:
                 // any other types are not allowed to run on compositor.
                 return false;
             }
         }
     }
 
-    if (playerToAdd && hasIncompatibleAnimations(targetElement, *playerToAdd, effect))
+    if (animationToAdd && hasIncompatibleAnimations(targetElement, *animationToAdd, effect))
         return false;
 
     CompositorAnimationsImpl::CompositorTiming out;
-    if (!CompositorAnimationsImpl::convertTimingForCompositor(timing, 0, out, playerPlaybackRate))
+    if (!CompositorAnimationsImpl::convertTimingForCompositor(timing, 0, out, animationPlaybackRate))
         return false;
 
     return true;
 }
 
-void CompositorAnimations::cancelIncompatibleAnimationsOnCompositor(const Element& targetElement, const AnimationPlayer& playerToAdd, const AnimationEffect& effectToAdd)
+void CompositorAnimations::cancelIncompatibleAnimationsOnCompositor(const Element& targetElement, const Animation& animationToAdd, const EffectModel& effectToAdd)
 {
     const bool affectsOpacity = effectToAdd.affects(PropertyHandle(CSSPropertyOpacity));
     const bool affectsTransform = effectToAdd.affects(PropertyHandle(CSSPropertyTransform));
     const bool affectsFilter = effectToAdd.affects(PropertyHandle(CSSPropertyWebkitFilter));
 
     if (!targetElement.hasAnimations())
         return;
 
     ElementAnimations* elementAnimations = targetElement.elementAnimations();
     ASSERT(elementAnimations);
 
-    for (const auto& entry : elementAnimations->players()) {
-        AnimationPlayer* attachedPlayer = entry.key;
-        if (!considerPlayerAsIncompatible(*attachedPlayer, playerToAdd))
+    for (const auto& entry : elementAnimations->animations()) {
+        Animation* attachedAnimation = entry.key;
+        if (!considerAnimationAsIncompatible(*attachedAnimation, animationToAdd))
             continue;
 
-        if ((affectsOpacity && attachedPlayer->affects(targetElement, CSSPropertyOpacity))
-            || (affectsTransform && attachedPlayer->affects(targetElement, CSSPropertyTransform))
-            || (affectsFilter && attachedPlayer->affects(targetElement, CSSPropertyWebkitFilter)))
-            attachedPlayer->cancelAnimationOnCompositor();
+        if ((affectsOpacity && attachedAnimation->affects(targetElement, CSSPropertyOpacity))
+            || (affectsTransform && attachedAnimation->affects(targetElement, CSSPropertyTransform))
+            || (affectsFilter && attachedAnimation->affects(targetElement, CSSPropertyWebkitFilter)))
+            attachedAnimation->cancelAnimationOnCompositor();
     }
 }
 
 bool CompositorAnimations::canStartAnimationOnCompositor(const Element& element)
 {
     return element.layoutObject() && element.layoutObject()->compositingState() == PaintsIntoOwnBacking;
 }
 
-bool CompositorAnimations::startAnimationOnCompositor(const Element& element, int group, double startTime, double timeOffset, const Timing& timing, const AnimationPlayer& player, const AnimationEffect& effect, Vector<int>& startedAnimationIds, double playerPlaybackRate)
+bool CompositorAnimations::startAnimationOnCompositor(const Element& element, int group, double startTime, double timeOffset, const Timing& timing, const Animation& animation, const EffectModel& effect, Vector<int>& startedAnimationIds, double animationPlaybackRate)
 {
     ASSERT(startedAnimationIds.isEmpty());
-    ASSERT(isCandidateForAnimationOnCompositor(timing, element, &player, effect, playerPlaybackRate));
+    ASSERT(isCandidateForAnimationOnCompositor(timing, element, &animation, effect, animationPlaybackRate));
     ASSERT(canStartAnimationOnCompositor(element));
 
     const KeyframeEffectModelBase& keyframeEffect = toKeyframeEffectModelBase(effect);
 
     DeprecatedPaintLayer* layer = toLayoutBoxModelObject(element.layoutObject())->layer();
     ASSERT(layer);
 
     Vector<OwnPtr<WebCompositorAnimation>> animations;
-    CompositorAnimationsImpl::getAnimationOnCompositor(timing, group, startTime, timeOffset, keyframeEffect, animations, playerPlaybackRate);
+    CompositorAnimationsImpl::getAnimationOnCompositor(timing, group, startTime, timeOffset, keyframeEffect, animations, animationPlaybackRate);
     ASSERT(!animations.isEmpty());
-    for (auto& animation : animations) {
-        int id = animation->id();
+    for (auto& compositorAnimation : animations) {
+        int id = compositorAnimation->id();
         if (RuntimeEnabledFeatures::compositorAnimationTimelinesEnabled()) {
-            WebCompositorAnimationPlayer* compositorPlayer = player.compositorPlayer();
+            WebCompositorAnimationPlayer* compositorPlayer = animation.compositorPlayer();
             ASSERT(compositorPlayer);
-            compositorPlayer->addAnimation(animation.leakPtr());
-        } else if (!layer->compositedDeprecatedPaintLayerMapping()->mainGraphicsLayer()->addAnimation(animation.release())) {
+            compositorPlayer->addAnimation(compositorAnimation.leakPtr());
+        } else if (!layer->compositedDeprecatedPaintLayerMapping()->mainGraphicsLayer()->addAnimation(compositorAnimation.release())) {
             // FIXME: We should know ahead of time whether these animations can be started.
             for (int startedAnimationId : startedAnimationIds)
-                cancelAnimationOnCompositor(element, player, startedAnimationId);
+                cancelAnimationOnCompositor(element, animation, startedAnimationId);
             startedAnimationIds.clear();
             return false;
         }
         startedAnimationIds.append(id);
     }
     ASSERT(!startedAnimationIds.isEmpty());
     return true;
 }
 
-void CompositorAnimations::cancelAnimationOnCompositor(const Element& element, const AnimationPlayer& player, int id)
+void CompositorAnimations::cancelAnimationOnCompositor(const Element& element, const Animation& animation, int id)
 {
     if (!canStartAnimationOnCompositor(element)) {
         // When an element is being detached, we cancel any associated
-        // AnimationPlayers for CSS animations. But by the time we get
+        // Animations for CSS animations. But by the time we get
         // here the mapping will have been removed.
         // FIXME: Defer remove/pause operations until after the
         // compositing update.
         return;
     }
     if (RuntimeEnabledFeatures::compositorAnimationTimelinesEnabled()) {
-        WebCompositorAnimationPlayer* compositorPlayer = player.compositorPlayer();
+        WebCompositorAnimationPlayer* compositorPlayer = animation.compositorPlayer();
         ASSERT(compositorPlayer);
         compositorPlayer->removeAnimation(id);
     } else {
         toLayoutBoxModelObject(element.layoutObject())->layer()->compositedDeprecatedPaintLayerMapping()->mainGraphicsLayer()->removeAnimation(id);
     }
 }
 
-void CompositorAnimations::pauseAnimationForTestingOnCompositor(const Element& element, const AnimationPlayer& player, int id, double pauseTime)
+void CompositorAnimations::pauseAnimationForTestingOnCompositor(const Element& element, const Animation& animation, int id, double pauseTime)
 {
     // FIXME: canStartAnimationOnCompositor queries compositingState, which is not necessarily up to date.
     // https://code.google.com/p/chromium/issues/detail?id=339847
     DisableCompositingQueryAsserts disabler;
 
     if (!canStartAnimationOnCompositor(element)) {
         ASSERT_NOT_REACHED();
         return;
     }
     if (RuntimeEnabledFeatures::compositorAnimationTimelinesEnabled()) {
-        WebCompositorAnimationPlayer* compositorPlayer = player.compositorPlayer();
+        WebCompositorAnimationPlayer* compositorPlayer = animation.compositorPlayer();
         ASSERT(compositorPlayer);
         compositorPlayer->pauseAnimation(id, pauseTime);
     } else {
         toLayoutBoxModelObject(element.layoutObject())->layer()->compositedDeprecatedPaintLayerMapping()->mainGraphicsLayer()->pauseAnimation(id, pauseTime);
     }
 }
 
-bool CompositorAnimations::canAttachCompositedLayers(const Element& element, const AnimationPlayer& player)
+bool CompositorAnimations::canAttachCompositedLayers(const Element& element, const Animation& animation)
 {
     if (!RuntimeEnabledFeatures::compositorAnimationTimelinesEnabled())
         return false;
 
-    if (!player.compositorPlayer())
+    if (!animation.compositorPlayer())
         return false;
 
     if (!element.layoutObject() || !element.layoutObject()->isBoxModelObject())
         return false;
 
     DeprecatedPaintLayer* layer = toLayoutBoxModelObject(element.layoutObject())->layer();
 
     if (!layer || !layer->isAllowedToQueryCompositingState()
         || !layer->compositedDeprecatedPaintLayerMapping()
         || !layer->compositedDeprecatedPaintLayerMapping()->mainGraphicsLayer())
         return false;
 
     if (!layer->compositedDeprecatedPaintLayerMapping()->mainGraphicsLayer()->platformLayer())
         return false;
 
     return true;
 }
 
-void CompositorAnimations::attachCompositedLayers(const Element& element, const AnimationPlayer& player)
+void CompositorAnimations::attachCompositedLayers(const Element& element, const Animation& animation)
 {
     ASSERT(element.layoutObject());
 
     DeprecatedPaintLayer* layer = toLayoutBoxModelObject(element.layoutObject())->layer();
     ASSERT(layer);
 
-    WebCompositorAnimationPlayer* compositorPlayer = player.compositorPlayer();
+    WebCompositorAnimationPlayer* compositorPlayer = animation.compositorPlayer();
     ASSERT(compositorPlayer);
 
     ASSERT(layer->compositedDeprecatedPaintLayerMapping());
     compositorPlayer->attachLayer(layer->compositedDeprecatedPaintLayerMapping()->mainGraphicsLayer()->platformLayer());
 }
 
 // -----------------------------------------------------------------------
 // CompositorAnimationsImpl
 // -----------------------------------------------------------------------
 
-bool CompositorAnimationsImpl::convertTimingForCompositor(const Timing& timing, double timeOffset, CompositorTiming& out, double playerPlaybackRate)
+bool CompositorAnimationsImpl::convertTimingForCompositor(const Timing& timing, double timeOffset, CompositorTiming& out, double animationPlaybackRate)
 {
     timing.assertValid();
 
     // FIXME: Compositor does not know anything about endDelay.
     if (timing.endDelay != 0)
         return false;
 
     if (std::isnan(timing.iterationDuration) || !timing.iterationCount || !timing.iterationDuration)
         return false;
 
     if (!std::isfinite(timing.iterationCount)) {
         out.adjustedIterationCount = -1;
     } else {
         out.adjustedIterationCount = timing.iterationCount;
     }
 
     out.scaledDuration = timing.iterationDuration;
     out.direction = timing.direction;
     // Compositor's time offset is positive for seeking into the animation.
-    out.scaledTimeOffset = -timing.startDelay / playerPlaybackRate + timeOffset;
-    out.playbackRate = timing.playbackRate * playerPlaybackRate;
+    out.scaledTimeOffset = -timing.startDelay / animationPlaybackRate + timeOffset;
+    out.playbackRate = timing.playbackRate * animationPlaybackRate;
     out.fillMode = timing.fillMode == Timing::FillModeAuto ? Timing::FillModeNone : timing.fillMode;
     out.iterationStart = timing.iterationStart;
     out.assertValid();
     return true;
 }
 
 namespace {
 
 void getCubicBezierTimingFunctionParameters(const TimingFunction& timingFunction, bool& outCustom,
     WebCompositorAnimationCurve::TimingFunctionType& outEaseSubType,
@@ skipping 171 matching lines @@
             WebTransformAnimationCurve* transformCurve = static_cast<WebTransformAnimationCurve*>(&curve);
             addKeyframeWithTimingFunction(*transformCurve, transformKeyframe, keyframeTimingFunction);
             break;
         }
         default:
             ASSERT_NOT_REACHED();
         }
     }
 }
 
-void CompositorAnimationsImpl::getAnimationOnCompositor(const Timing& timing, int group, double startTime, double timeOffset, const KeyframeEffectModelBase& effect, Vector<OwnPtr<WebCompositorAnimation>>& animations, double playerPlaybackRate)
+void CompositorAnimationsImpl::getAnimationOnCompositor(const Timing& timing, int group, double startTime, double timeOffset, const KeyframeEffectModelBase& effect, Vector<OwnPtr<WebCompositorAnimation>>& animations, double animationPlaybackRate)
 {
     ASSERT(animations.isEmpty());
     CompositorTiming compositorTiming;
-    bool timingValid = convertTimingForCompositor(timing, timeOffset, compositorTiming, playerPlaybackRate);
+    bool timingValid = convertTimingForCompositor(timing, timeOffset, compositorTiming, animationPlaybackRate);
     ASSERT_UNUSED(timingValid, timingValid);
 
     PropertyHandleSet properties = effect.properties();
     ASSERT(!properties.isEmpty());
     for (const auto& property : properties) {
         PropertySpecificKeyframeVector values;
         getKeyframeValuesForProperty(&effect, property, compositorTiming.scaledDuration, values);
 
         WebCompositorAnimation::TargetProperty targetProperty;
         OwnPtr<WebCompositorAnimationCurve> curve;
@@ skipping 71 matching lines @@
             break;
         default:
             ASSERT_NOT_REACHED();
         }
         animations.append(animation.release());
     }
     ASSERT(!animations.isEmpty());
 }
 
 } // namespace blink