Blink Compositor Animation: Erase CompositorAnimationsImpl.h

third_party/WebKit/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 "core/animation/CompositorAnimations.h"
 
 #include "core/animation/AnimationEffect.h"
-#include "core/animation/CompositorAnimationsImpl.h"
 #include "core/animation/ElementAnimations.h"
+#include "core/animation/KeyframeEffectModel.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/CompositedLayerMapping.h"
 #include "core/paint/PaintLayer.h"
-#include "platform/RuntimeEnabledFeatures.h"
 #include "platform/animation/AnimationTranslationUtil.h"
 #include "platform/animation/CompositorAnimation.h"
 #include "platform/animation/CompositorAnimationPlayer.h"
 #include "platform/animation/CompositorFilterAnimationCurve.h"
 #include "platform/animation/CompositorFilterKeyframe.h"
 #include "platform/animation/CompositorFloatAnimationCurve.h"
 #include "platform/animation/CompositorFloatKeyframe.h"
 #include "platform/animation/CompositorTransformAnimationCurve.h"
 #include "platform/animation/CompositorTransformKeyframe.h"
 #include "platform/geometry/FloatBox.h"
@@ skipping 79 matching lines @@
             || (affectsFilter && attachedAnimation->affects(targetElement, CSSPropertyWebkitFilter))
             || (affectsBackdropFilter && attachedAnimation->affects(targetElement, CSSPropertyBackdropFilter)))
             return true;
     }
 
     return false;
 }
 
 } // namespace
 
-CompositorAnimations::CompositorAnimations()
-{
-}
-
-CompositorAnimations* CompositorAnimations::instance(CompositorAnimations* newInstance)
-{
-    static CompositorAnimations* instance = new CompositorAnimations();
-    if (newInstance) {
-        instance = newInstance;
-    }
-    return instance;
-}
-
 bool CompositorAnimations::isCompositableProperty(CSSPropertyID property)
 {
     for (CSSPropertyID id : compositableProperties) {
         if (property == id)
             return true;
     }
     return false;
 }
 
 const CSSPropertyID CompositorAnimations::compositableProperties[7] = {
     CSSPropertyOpacity,
     CSSPropertyRotate,
     CSSPropertyScale,
     CSSPropertyTransform,
     CSSPropertyTranslate,
     CSSPropertyWebkitFilter,
     CSSPropertyBackdropFilter
 };
 
-bool CompositorAnimations::getAnimatedBoundingBox(FloatBox& box, const EffectModel& effect, double minValue, double maxValue) const
+bool CompositorAnimations::getAnimatedBoundingBox(FloatBox& box, const EffectModel& effect, double minValue, double maxValue)
 {
     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 105 matching lines @@
         }
     }
 
     // TODO: Support multiple transform property animations on the compositor
     if (transformPropertyCount > 1)
         return false;
 
     if (animationToAdd && hasIncompatibleAnimations(targetElement, *animationToAdd, effect))
         return false;
 
-    CompositorAnimationsImpl::CompositorTiming out;
-    if (!CompositorAnimationsImpl::convertTimingForCompositor(timing, 0, out, animationPlaybackRate))
+    CompositorTiming out;
+    if (!convertTimingForCompositor(timing, 0, out, animationPlaybackRate))
         return false;
 
     return true;
 }
 
 void CompositorAnimations::cancelIncompatibleAnimationsOnCompositor(const Element& targetElement, const Animation& animationToAdd, const EffectModel& effectToAdd)
 {
     const bool affectsOpacity = effectToAdd.affects(PropertyHandle(CSSPropertyOpacity));
     const bool affectsTransform = effectToAdd.isTransformRelatedEffect();
     const bool affectsFilter = effectToAdd.affects(PropertyHandle(CSSPropertyWebkitFilter));
@@ skipping 27 matching lines @@
 
 void 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, &animation, effect, animationPlaybackRate));
     ASSERT(canStartAnimationOnCompositor(element));
 
     const KeyframeEffectModelBase& keyframeEffect = toKeyframeEffectModelBase(effect);
 
     Vector<OwnPtr<CompositorAnimation>> animations;
-    CompositorAnimationsImpl::getAnimationOnCompositor(timing, group, startTime, timeOffset, keyframeEffect, animations, animationPlaybackRate);
+    getAnimationOnCompositor(timing, group, startTime, timeOffset, keyframeEffect, animations, animationPlaybackRate);
     ASSERT(!animations.isEmpty());
     for (auto& compositorAnimation : animations) {
         int id = compositorAnimation->id();
         CompositorAnimationPlayer* compositorPlayer = animation.compositorPlayer();
         ASSERT(compositorPlayer);
         compositorPlayer->addAnimation(compositorAnimation.leakPtr());
         startedAnimationIds.append(id);
     }
     ASSERT(!startedAnimationIds.isEmpty());
 }
@@ skipping 56 matching lines @@
     PaintLayer* layer = toLayoutBoxModelObject(element.layoutObject())->layer();
     ASSERT(layer);
 
     CompositorAnimationPlayer* compositorPlayer = animation.compositorPlayer();
     ASSERT(compositorPlayer);
 
     ASSERT(layer->compositedLayerMapping());
     compositorPlayer->attachLayer(layer->compositedLayerMapping()->mainGraphicsLayer()->platformLayer());
 }
 
-// -----------------------------------------------------------------------
-// CompositorAnimationsImpl
-// -----------------------------------------------------------------------
-
-bool CompositorAnimationsImpl::convertTimingForCompositor(const Timing& timing, double timeOffset, CompositorTiming& out, double animationPlaybackRate)
+bool CompositorAnimations::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.adjustedIterationCount = std::isfinite(timing.iterationCount) ? timing.iterationCount : -1;
     out.scaledDuration = timing.iterationDuration;
     out.direction = timing.direction;
     // Compositor's time offset is positive for seeking into the animation.
     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();
+
+    DCHECK_GT(out.scaledDuration, 0);
+    DCHECK(std::isfinite(out.scaledTimeOffset));
+    DCHECK(out.adjustedIterationCount > 0 || out.adjustedIterationCount == -1);
+    DCHECK(std::isfinite(out.playbackRate) && out.playbackRate);
+    DCHECK_GE(out.iterationStart, 0);
+
     return true;
 }
 
 namespace {
 
 template<typename PlatformAnimationCurveType, typename PlatformAnimationKeyframeType>
 void addCompositorKeyframeWithTimingFunction(PlatformAnimationCurveType& curve, const PlatformAnimationKeyframeType& keyframe, const TimingFunction* timingFunction)
 {
     if (!timingFunction) {
         curve.addCubicBezierKeyframe(keyframe, CubicBezierTimingFunction::EaseType::EASE);
@@ skipping 99 matching lines @@
         // not happen eventually. Instead we should extract the CSSValue here
         // and convert using another set of toAnimatableXXXOperations functions.
         const AnimatableValue* value = keyframe->getAnimatableValue().get();
 
         addKeyframeToCurve(curve, keyframe.get(), value, keyframeTimingFunction);
     }
 }
 
 } // namespace
 
-void CompositorAnimationsImpl::getAnimationOnCompositor(const Timing& timing, int group, double startTime, double timeOffset, const KeyframeEffectModelBase& effect, Vector<OwnPtr<CompositorAnimation>>& animations, double animationPlaybackRate)
+void CompositorAnimations::getAnimationOnCompositor(const Timing& timing, int group, double startTime, double timeOffset, const KeyframeEffectModelBase& effect, Vector<OwnPtr<CompositorAnimation>>& animations, double animationPlaybackRate)
 {
     ASSERT(animations.isEmpty());
     CompositorTiming compositorTiming;
     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;
@@ skipping 86 matching lines @@
             break;
         default:
             ASSERT_NOT_REACHED();
         }
         animations.append(std::move(animation));
     }
     ASSERT(!animations.isEmpty());
 }
 
 } // namespace blink