CC Animation: Move files from cc_blink to Source/platform/animation

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 25 matching lines @@
 #include "core/animation/ElementAnimations.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/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"
+#include "platform/graphics/CompositorFactory.h"
 #include "public/platform/Platform.h"
-#include "public/platform/WebCompositorAnimation.h"
-#include "public/platform/WebCompositorAnimationPlayer.h"
 #include "public/platform/WebCompositorSupport.h"
-#include "public/platform/WebFilterAnimationCurve.h"
-#include "public/platform/WebFilterKeyframe.h"
-#include "public/platform/WebFloatAnimationCurve.h"
-#include "public/platform/WebFloatKeyframe.h"
-#include "public/platform/WebTransformAnimationCurve.h"
-#include "public/platform/WebTransformKeyframe.h"
 
 #include <algorithm>
 #include <cmath>
 
 namespace blink {
 
 namespace {
 
 void getKeyframeValuesForProperty(const KeyframeEffectModelBase* effect, PropertyHandle property, double scale, PropertySpecificKeyframeVector& values)
 {
@@ skipping 275 matching lines @@
 {
     ASSERT(startedAnimationIds.isEmpty());
     ASSERT(isCandidateForAnimationOnCompositor(timing, element, &animation, effect, animationPlaybackRate));
     ASSERT(canStartAnimationOnCompositor(element));
 
     const KeyframeEffectModelBase& keyframeEffect = toKeyframeEffectModelBase(effect);
 
     PaintLayer* layer = toLayoutBoxModelObject(element.layoutObject())->layer();
     ASSERT(layer);
 
-    Vector<OwnPtr<WebCompositorAnimation>> animations;
+    Vector<OwnPtr<CompositorAnimation>> animations;
     CompositorAnimationsImpl::getAnimationOnCompositor(timing, group, startTime, timeOffset, keyframeEffect, animations, animationPlaybackRate);
     ASSERT(!animations.isEmpty());
     for (auto& compositorAnimation : animations) {
         int id = compositorAnimation->id();
         if (RuntimeEnabledFeatures::compositorAnimationTimelinesEnabled()) {
-            WebCompositorAnimationPlayer* compositorPlayer = animation.compositorPlayer();
+            CompositorAnimationPlayer* compositorPlayer = animation.compositorPlayer();
             ASSERT(compositorPlayer);
             compositorPlayer->addAnimation(compositorAnimation.leakPtr());
         } else if (!layer->compositedLayerMapping()->mainGraphicsLayer()->addAnimation(compositorAnimation.release())) {
             // FIXME: We should know ahead of time whether these animations can be started.
             for (int startedAnimationId : startedAnimationIds)
                 cancelAnimationOnCompositor(element, animation, startedAnimationId);
             startedAnimationIds.clear();
             return false;
         }
         startedAnimationIds.append(id);
     }
     ASSERT(!startedAnimationIds.isEmpty());
     return true;
 }
 
 void CompositorAnimations::cancelAnimationOnCompositor(const Element& element, const Animation& animation, int id)
 {
     if (!canStartAnimationOnCompositor(element)) {
         // When an element is being detached, we cancel any associated
         // 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 = animation.compositorPlayer();
+        CompositorAnimationPlayer* compositorPlayer = animation.compositorPlayer();
         if (compositorPlayer)
             compositorPlayer->removeAnimation(id);
     } else {
         toLayoutBoxModelObject(element.layoutObject())->layer()->compositedLayerMapping()->mainGraphicsLayer()->removeAnimation(id);
     }
 }
 
 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 = animation.compositorPlayer();
+        CompositorAnimationPlayer* compositorPlayer = animation.compositorPlayer();
         ASSERT(compositorPlayer);
         compositorPlayer->pauseAnimation(id, pauseTime);
     } else {
         toLayoutBoxModelObject(element.layoutObject())->layer()->compositedLayerMapping()->mainGraphicsLayer()->pauseAnimation(id, pauseTime);
     }
 }
 
 bool CompositorAnimations::canAttachCompositedLayers(const Element& element, const Animation& animation)
 {
     if (!RuntimeEnabledFeatures::compositorAnimationTimelinesEnabled())
@@ skipping 18 matching lines @@
     return true;
 }
 
 void CompositorAnimations::attachCompositedLayers(const Element& element, const Animation& animation)
 {
     ASSERT(element.layoutObject());
 
     PaintLayer* layer = toLayoutBoxModelObject(element.layoutObject())->layer();
     ASSERT(layer);
 
-    WebCompositorAnimationPlayer* compositorPlayer = animation.compositorPlayer();
+    CompositorAnimationPlayer* compositorPlayer = animation.compositorPlayer();
     ASSERT(compositorPlayer);
 
     ASSERT(layer->compositedLayerMapping());
     compositorPlayer->attachLayer(layer->compositedLayerMapping()->mainGraphicsLayer()->platformLayer());
 }
 
 // -----------------------------------------------------------------------
 // CompositorAnimationsImpl
 // -----------------------------------------------------------------------
 
@@ skipping 21 matching lines @@
     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,
+    CompositorAnimationCurve::TimingFunctionType& outEaseSubType,
     double& outX1, double& outY1, double& outX2, double& outY2)
 {
     const CubicBezierTimingFunction& cubic = toCubicBezierTimingFunction(timingFunction);
     outCustom = false;
 
     switch (cubic.subType()) {
     case CubicBezierTimingFunction::Ease:
-        outEaseSubType = WebCompositorAnimationCurve::TimingFunctionTypeEase;
+        outEaseSubType = CompositorAnimationCurve::TimingFunctionTypeEase;
         break;
     case CubicBezierTimingFunction::EaseIn:
-        outEaseSubType = WebCompositorAnimationCurve::TimingFunctionTypeEaseIn;
+        outEaseSubType = CompositorAnimationCurve::TimingFunctionTypeEaseIn;
         break;
     case CubicBezierTimingFunction::EaseOut:
-        outEaseSubType = WebCompositorAnimationCurve::TimingFunctionTypeEaseOut;
+        outEaseSubType = CompositorAnimationCurve::TimingFunctionTypeEaseOut;
         break;
     case CubicBezierTimingFunction::EaseInOut:
-        outEaseSubType = WebCompositorAnimationCurve::TimingFunctionTypeEaseInOut;
+        outEaseSubType = CompositorAnimationCurve::TimingFunctionTypeEaseInOut;
         break;
     case CubicBezierTimingFunction::Custom:
         outCustom = true;
         outX1 = cubic.x1();
         outY1 = cubic.y1();
         outX2 = cubic.x2();
         outY2 = cubic.y2();
         break;
     default:
         ASSERT_NOT_REACHED();
@@ skipping 25 matching lines @@
 template<typename PlatformAnimationCurveType, typename PlatformAnimationKeyframeType>
 void addKeyframeWithTimingFunction(PlatformAnimationCurveType& curve, const PlatformAnimationKeyframeType& keyframe, const TimingFunction* timingFunction)
 {
     if (!timingFunction) {
         curve.add(keyframe);
         return;
     }
 
     switch (timingFunction->type()) {
     case TimingFunction::LinearFunction:
-        curve.add(keyframe, WebCompositorAnimationCurve::TimingFunctionTypeLinear);
+        curve.add(keyframe, CompositorAnimationCurve::TimingFunctionTypeLinear);
         break;
 
     case TimingFunction::CubicBezierFunction: {
         bool custom;
-        WebCompositorAnimationCurve::TimingFunctionType easeSubType;
+        CompositorAnimationCurve::TimingFunctionType easeSubType;
         double x1, y1;
         double x2, y2;
         getCubicBezierTimingFunctionParameters(*timingFunction, custom, easeSubType, x1, y1, x2, y2);
 
         if (custom)
             curve.add(keyframe, x1, y1, x2, y2);
         else
             curve.add(keyframe, easeSubType);
         break;
     }
@@ skipping 20 matching lines @@
         return;
     }
 
     switch (timingFunction->type()) {
     case TimingFunction::LinearFunction:
         curve.setLinearTimingFunction();
         break;
 
     case TimingFunction::CubicBezierFunction: {
         bool custom;
-        WebCompositorAnimationCurve::TimingFunctionType easeSubType;
+        CompositorAnimationCurve::TimingFunctionType easeSubType;
         double x1, y1;
         double x2, y2;
         getCubicBezierTimingFunctionParameters(*timingFunction, custom, easeSubType, x1, y1, x2, y2);
 
         if (custom)
             curve.setCubicBezierTimingFunction(x1, y1, x2, y2);
         else
             curve.setCubicBezierTimingFunction(easeSubType);
         break;
     }
 
     case TimingFunction::StepsFunction: {
         int steps;
         float stepsStartOffset;
         getStepsTimingFunctionParameters(*timingFunction, steps, stepsStartOffset);
 
         curve.setStepsTimingFunction(steps, stepsStartOffset);
         break;
     }
 
     default:
         ASSERT_NOT_REACHED();
     }
 }
 
 } // namespace
 
-void CompositorAnimationsImpl::addKeyframesToCurve(WebCompositorAnimationCurve& curve, const PropertySpecificKeyframeVector& keyframes, const Timing& timing)
+void CompositorAnimationsImpl::addKeyframesToCurve(CompositorAnimationCurve& curve, const PropertySpecificKeyframeVector& keyframes, const Timing& timing)
 {
     auto* lastKeyframe = keyframes.last().get();
     for (const auto& keyframe : keyframes) {
         const TimingFunction* keyframeTimingFunction = 0;
         if (keyframe != lastKeyframe) { // Ignore timing function of last frame.
             keyframeTimingFunction = &keyframe->easing();
         }
 
         // FIXME: This relies on StringKeyframes being eagerly evaluated, which will
         // not happen eventually. Instead we should extract the CSSValue here
         // and convert using another set of toAnimatableXXXOperations functions.
         const AnimatableValue* value = keyframe->getAnimatableValue().get();
 
         switch (curve.type()) {
-        case WebCompositorAnimationCurve::AnimationCurveTypeFilter: {
-            OwnPtr<WebFilterOperations> ops = adoptPtr(Platform::current()->compositorSupport()->createFilterOperations());
-            toWebFilterOperations(toAnimatableFilterOperations(value)->operations(), ops.get());
+        case CompositorAnimationCurve::AnimationCurveTypeFilter: {
+            OwnPtr<CompositorFilterOperations> ops = adoptPtr(CompositorFactory::current().createFilterOperations());
+            toCompositorFilterOperations(toAnimatableFilterOperations(value)->operations(), ops.get());
 
-            WebFilterKeyframe filterKeyframe(keyframe->offset(), ops.release());
-            WebFilterAnimationCurve* filterCurve = static_cast<WebFilterAnimationCurve*>(&curve);
+            CompositorFilterKeyframe filterKeyframe(keyframe->offset(), ops.release());
+            CompositorFilterAnimationCurve* filterCurve = static_cast<CompositorFilterAnimationCurve*>(&curve);
             addKeyframeWithTimingFunction(*filterCurve, filterKeyframe, keyframeTimingFunction);
             break;
         }
-        case WebCompositorAnimationCurve::AnimationCurveTypeFloat: {
-            WebFloatKeyframe floatKeyframe(keyframe->offset(), toAnimatableDouble(value)->toDouble());
-            WebFloatAnimationCurve* floatCurve = static_cast<WebFloatAnimationCurve*>(&curve);
+        case CompositorAnimationCurve::AnimationCurveTypeFloat: {
+            CompositorFloatKeyframe floatKeyframe(keyframe->offset(), toAnimatableDouble(value)->toDouble());
+            CompositorFloatAnimationCurve* floatCurve = static_cast<CompositorFloatAnimationCurve*>(&curve);
             addKeyframeWithTimingFunction(*floatCurve, floatKeyframe, keyframeTimingFunction);
             break;
         }
-        case WebCompositorAnimationCurve::AnimationCurveTypeTransform: {
-            OwnPtr<WebTransformOperations> ops = adoptPtr(Platform::current()->compositorSupport()->createTransformOperations());
-            toWebTransformOperations(toAnimatableTransform(value)->transformOperations(), ops.get());
+        case CompositorAnimationCurve::AnimationCurveTypeTransform: {
+            OwnPtr<CompositorTransformOperations> ops = adoptPtr(CompositorFactory::current().createTransformOperations());
+            toCompositorTransformOperations(toAnimatableTransform(value)->transformOperations(), ops.get());
 
-            WebTransformKeyframe transformKeyframe(keyframe->offset(), ops.release());
-            WebTransformAnimationCurve* transformCurve = static_cast<WebTransformAnimationCurve*>(&curve);
+            CompositorTransformKeyframe transformKeyframe(keyframe->offset(), ops.release());
+            CompositorTransformAnimationCurve* transformCurve = static_cast<CompositorTransformAnimationCurve*>(&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 animationPlaybackRate)
+void CompositorAnimationsImpl::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;
         getKeyframeValuesForProperty(&effect, property, compositorTiming.scaledDuration, values);
 
-        WebCompositorAnimation::TargetProperty targetProperty;
-        OwnPtr<WebCompositorAnimationCurve> curve;
+        CompositorAnimation::TargetProperty targetProperty;
+        OwnPtr<CompositorAnimationCurve> curve;
         switch (property.cssProperty()) {
         case CSSPropertyOpacity: {
-            targetProperty = WebCompositorAnimation::TargetPropertyOpacity;
+            targetProperty = CompositorAnimation::TargetPropertyOpacity;
 
-            WebFloatAnimationCurve* floatCurve = Platform::current()->compositorSupport()->createFloatAnimationCurve();
+            CompositorFloatAnimationCurve* floatCurve = CompositorFactory::current().createFloatAnimationCurve();
             addKeyframesToCurve(*floatCurve, values, timing);
             setTimingFunctionOnCurve(*floatCurve, timing.timingFunction.get());
             curve = adoptPtr(floatCurve);
             break;
         }
         case CSSPropertyWebkitFilter:
         case CSSPropertyBackdropFilter: {
-            targetProperty = WebCompositorAnimation::TargetPropertyFilter;
-            WebFilterAnimationCurve* filterCurve = Platform::current()->compositorSupport()->createFilterAnimationCurve();
+            targetProperty = CompositorAnimation::TargetPropertyFilter;
+            CompositorFilterAnimationCurve* filterCurve = CompositorFactory::current().createFilterAnimationCurve();
             addKeyframesToCurve(*filterCurve, values, timing);
             setTimingFunctionOnCurve(*filterCurve, timing.timingFunction.get());
             curve = adoptPtr(filterCurve);
             break;
         }
         case CSSPropertyRotate:
         case CSSPropertyScale:
         case CSSPropertyTranslate:
         case CSSPropertyTransform: {
-            targetProperty = WebCompositorAnimation::TargetPropertyTransform;
-            WebTransformAnimationCurve* transformCurve = Platform::current()->compositorSupport()->createTransformAnimationCurve();
+            targetProperty = CompositorAnimation::TargetPropertyTransform;
+            CompositorTransformAnimationCurve* transformCurve = CompositorFactory::current().createTransformAnimationCurve();
             addKeyframesToCurve(*transformCurve, values, timing);
             setTimingFunctionOnCurve(*transformCurve, timing.timingFunction.get());
             curve = adoptPtr(transformCurve);
             break;
         }
         default:
             ASSERT_NOT_REACHED();
             continue;
         }
         ASSERT(curve.get());
 
-        OwnPtr<WebCompositorAnimation> animation = adoptPtr(Platform::current()->compositorSupport()->createAnimation(*curve, targetProperty, group, 0));
+        OwnPtr<CompositorAnimation> animation = adoptPtr(CompositorFactory::current().createAnimation(*curve, targetProperty, group, 0));
 
         if (!std::isnan(startTime))
             animation->setStartTime(startTime);
 
         animation->setIterations(compositorTiming.adjustedIterationCount);
         animation->setIterationStart(compositorTiming.iterationStart);
         animation->setTimeOffset(compositorTiming.scaledTimeOffset);
 
         switch (compositorTiming.direction) {
         case Timing::PlaybackDirectionNormal:
-            animation->setDirection(WebCompositorAnimation::DirectionNormal);
+            animation->setDirection(CompositorAnimation::DirectionNormal);
             break;
         case Timing::PlaybackDirectionReverse:
-            animation->setDirection(WebCompositorAnimation::DirectionReverse);
+            animation->setDirection(CompositorAnimation::DirectionReverse);
             break;
         case Timing::PlaybackDirectionAlternate:
-            animation->setDirection(WebCompositorAnimation::DirectionAlternate);
+            animation->setDirection(CompositorAnimation::DirectionAlternate);
             break;
         case Timing::PlaybackDirectionAlternateReverse:
-            animation->setDirection(WebCompositorAnimation::DirectionAlternateReverse);
+            animation->setDirection(CompositorAnimation::DirectionAlternateReverse);
             break;
         default:
             ASSERT_NOT_REACHED();
         }
         animation->setPlaybackRate(compositorTiming.playbackRate);
 
         switch (compositorTiming.fillMode) {
         case Timing::FillModeNone:
-            animation->setFillMode(WebCompositorAnimation::FillModeNone);
+            animation->setFillMode(CompositorAnimation::FillModeNone);
             break;
         case Timing::FillModeForwards:
-            animation->setFillMode(WebCompositorAnimation::FillModeForwards);
+            animation->setFillMode(CompositorAnimation::FillModeForwards);
             break;
         case Timing::FillModeBackwards:
-            animation->setFillMode(WebCompositorAnimation::FillModeBackwards);
+            animation->setFillMode(CompositorAnimation::FillModeBackwards);
             break;
         case Timing::FillModeBoth:
-            animation->setFillMode(WebCompositorAnimation::FillModeBoth);
+            animation->setFillMode(CompositorAnimation::FillModeBoth);
             break;
         default:
             ASSERT_NOT_REACHED();
         }
         animations.append(animation.release());
     }
     ASSERT(!animations.isEmpty());
 }
 
 } // namespace blink