Revert of Rename WebAnimation to WebCompositorAnimation

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/animatable/AnimatableDouble.h"
 #include "core/animation/animatable/AnimatableFilterOperations.h"
 #include "core/animation/animatable/AnimatableTransform.h"
 #include "core/animation/animatable/AnimatableValue.h"
 #include "core/rendering/RenderBoxModelObject.h"
 #include "core/rendering/RenderLayer.h"
 #include "core/rendering/RenderObject.h"
 #include "core/rendering/compositing/CompositedLayerMapping.h"
 #include "platform/geometry/FloatBox.h"
 #include "public/platform/Platform.h"
-#include "public/platform/WebCompositorAnimation.h"
+#include "public/platform/WebAnimation.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>
@@ skipping 193 matching lines @@
 {
     ASSERT(startedAnimationIds.isEmpty());
     ASSERT(isCandidateForAnimationOnCompositor(timing, effect));
     ASSERT(canStartAnimationOnCompositor(element));
 
     const KeyframeEffectModelBase& keyframeEffect = toKeyframeEffectModelBase(effect);
 
     RenderLayer* layer = toRenderBoxModelObject(element.renderer())->layer();
     ASSERT(layer);
 
-    Vector<OwnPtr<WebCompositorAnimation> > animations;
+    Vector<OwnPtr<blink::WebAnimation> > animations;
     CompositorAnimationsImpl::getAnimationOnCompositor(timing, startTime, keyframeEffect, animations);
     ASSERT(!animations.isEmpty());
     for (size_t i = 0; i < animations.size(); ++i) {
         int id = animations[i]->id();
         if (!layer->compositedLayerMapping()->mainGraphicsLayer()->addAnimation(animations[i].release())) {
             // FIXME: We should know ahead of time whether these animations can be started.
             for (size_t j = 0; j < startedAnimationIds.size(); ++j)
                 cancelAnimationOnCompositor(element, startedAnimationIds[j]);
             startedAnimationIds.clear();
             return false;
@@ skipping 88 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, blink::WebAnimationCurve::TimingFunctionTypeLinear);
         return;
 
     case TimingFunction::CubicBezierFunction: {
         const CubicBezierTimingFunction* cubic = toCubicBezierTimingFunction(timingFunction);
 
         if (cubic->subType() == CubicBezierTimingFunction::Custom) {
             curve.add(keyframe, cubic->x1(), cubic->y1(), cubic->x2(), cubic->y2());
         } else {
 
-            WebCompositorAnimationCurve::TimingFunctionType easeType;
+            blink::WebAnimationCurve::TimingFunctionType easeType;
             switch (cubic->subType()) {
             case CubicBezierTimingFunction::Ease:
-                easeType = WebCompositorAnimationCurve::TimingFunctionTypeEase;
+                easeType = blink::WebAnimationCurve::TimingFunctionTypeEase;
                 break;
             case CubicBezierTimingFunction::EaseIn:
-                easeType = WebCompositorAnimationCurve::TimingFunctionTypeEaseIn;
+                easeType = blink::WebAnimationCurve::TimingFunctionTypeEaseIn;
                 break;
             case CubicBezierTimingFunction::EaseOut:
-                easeType = WebCompositorAnimationCurve::TimingFunctionTypeEaseOut;
+                easeType = blink::WebAnimationCurve::TimingFunctionTypeEaseOut;
                 break;
             case CubicBezierTimingFunction::EaseInOut:
-                easeType = WebCompositorAnimationCurve::TimingFunctionTypeEaseInOut;
+                easeType = blink::WebAnimationCurve::TimingFunctionTypeEaseInOut;
                 break;
 
             // Custom Bezier are handled seperately.
             case CubicBezierTimingFunction::Custom:
             default:
                 ASSERT_NOT_REACHED();
                 return;
             }
 
             curve.add(keyframe, easeType);
         }
         return;
     }
 
     case TimingFunction::StepsFunction:
     default:
         ASSERT_NOT_REACHED();
         return;
     }
 }
 
 } // namespace anoymous
 
-void CompositorAnimationsImpl::addKeyframesToCurve(WebCompositorAnimationCurve& curve, const PropertySpecificKeyframeVector& keyframes, bool reverse)
+void CompositorAnimationsImpl::addKeyframesToCurve(blink::WebAnimationCurve& curve, const PropertySpecificKeyframeVector& keyframes, bool reverse)
 {
     for (size_t i = 0; i < keyframes.size(); i++) {
         RefPtr<TimingFunction> reversedTimingFunction;
         const TimingFunction* keyframeTimingFunction = 0;
         if (i < keyframes.size() - 1) { // Ignore timing function of last frame.
             if (reverse) {
                 reversedTimingFunction = CompositorAnimationsTimingFunctionReverser::reverse(keyframes[i + 1]->easing());
                 keyframeTimingFunction = reversedTimingFunction.get();
             } else {
                 keyframeTimingFunction = keyframes[i]->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 = keyframes[i]->getAnimatableValue().get();
 
         switch (curve.type()) {
-        case WebCompositorAnimationCurve::AnimationCurveTypeFilter: {
-            OwnPtr<WebFilterOperations> ops = adoptPtr(Platform::current()->compositorSupport()->createFilterOperations());
+        case blink::WebAnimationCurve::AnimationCurveTypeFilter: {
+            OwnPtr<blink::WebFilterOperations> ops = adoptPtr(blink::Platform::current()->compositorSupport()->createFilterOperations());
             toWebFilterOperations(toAnimatableFilterOperations(value)->operations(), ops.get());
 
-            WebFilterKeyframe filterKeyframe(keyframes[i]->offset(), ops.release());
-            WebFilterAnimationCurve* filterCurve = static_cast<WebFilterAnimationCurve*>(&curve);
+            blink::WebFilterKeyframe filterKeyframe(keyframes[i]->offset(), ops.release());
+            blink::WebFilterAnimationCurve* filterCurve = static_cast<blink::WebFilterAnimationCurve*>(&curve);
             addKeyframeWithTimingFunction(*filterCurve, filterKeyframe, keyframeTimingFunction);
             break;
         }
-        case WebCompositorAnimationCurve::AnimationCurveTypeFloat: {
-            WebFloatKeyframe floatKeyframe(keyframes[i]->offset(), toAnimatableDouble(value)->toDouble());
-            WebFloatAnimationCurve* floatCurve = static_cast<WebFloatAnimationCurve*>(&curve);
+        case blink::WebAnimationCurve::AnimationCurveTypeFloat: {
+            blink::WebFloatKeyframe floatKeyframe(keyframes[i]->offset(), toAnimatableDouble(value)->toDouble());
+            blink::WebFloatAnimationCurve* floatCurve = static_cast<blink::WebFloatAnimationCurve*>(&curve);
             addKeyframeWithTimingFunction(*floatCurve, floatKeyframe, keyframeTimingFunction);
             break;
         }
-        case WebCompositorAnimationCurve::AnimationCurveTypeTransform: {
-            OwnPtr<WebTransformOperations> ops = adoptPtr(Platform::current()->compositorSupport()->createTransformOperations());
+        case blink::WebAnimationCurve::AnimationCurveTypeTransform: {
+            OwnPtr<blink::WebTransformOperations> ops = adoptPtr(blink::Platform::current()->compositorSupport()->createTransformOperations());
             toWebTransformOperations(toAnimatableTransform(value)->transformOperations(), ops.get());
 
-            WebTransformKeyframe transformKeyframe(keyframes[i]->offset(), ops.release());
-            WebTransformAnimationCurve* transformCurve = static_cast<WebTransformAnimationCurve*>(&curve);
+            blink::WebTransformKeyframe transformKeyframe(keyframes[i]->offset(), ops.release());
+            blink::WebTransformAnimationCurve* transformCurve = static_cast<blink::WebTransformAnimationCurve*>(&curve);
             addKeyframeWithTimingFunction(*transformCurve, transformKeyframe, keyframeTimingFunction);
             break;
         }
         default:
             ASSERT_NOT_REACHED();
         }
     }
 }
 
-void CompositorAnimationsImpl::getAnimationOnCompositor(const Timing& timing, double startTime, const KeyframeEffectModelBase& effect, Vector<OwnPtr<WebCompositorAnimation> >& animations)
+void CompositorAnimationsImpl::getAnimationOnCompositor(const Timing& timing, double startTime, const KeyframeEffectModelBase& effect, Vector<OwnPtr<blink::WebAnimation> >& animations)
 {
     ASSERT(animations.isEmpty());
     CompositorTiming compositorTiming;
     bool timingValid = convertTimingForCompositor(timing, compositorTiming);
     ASSERT_UNUSED(timingValid, timingValid);
 
     PropertySet properties = effect.properties();
     ASSERT(!properties.isEmpty());
     for (PropertySet::iterator it = properties.begin(); it != properties.end(); ++it) {
 
         PropertySpecificKeyframeVector values;
         getKeyframeValuesForProperty(&effect, *it, compositorTiming.scaledDuration, compositorTiming.reverse, values);
 
-        WebCompositorAnimation::TargetProperty targetProperty;
-        OwnPtr<WebCompositorAnimationCurve> curve;
+        blink::WebAnimation::TargetProperty targetProperty;
+        OwnPtr<blink::WebAnimationCurve> curve;
         switch (*it) {
         case CSSPropertyOpacity: {
-            targetProperty = WebCompositorAnimation::TargetPropertyOpacity;
+            targetProperty = blink::WebAnimation::TargetPropertyOpacity;
 
-            WebFloatAnimationCurve* floatCurve = Platform::current()->compositorSupport()->createFloatAnimationCurve();
+            blink::WebFloatAnimationCurve* floatCurve = blink::Platform::current()->compositorSupport()->createFloatAnimationCurve();
             addKeyframesToCurve(*floatCurve, values, compositorTiming.reverse);
             curve = adoptPtr(floatCurve);
             break;
         }
         case CSSPropertyWebkitFilter: {
-            targetProperty = WebCompositorAnimation::TargetPropertyFilter;
-            WebFilterAnimationCurve* filterCurve = Platform::current()->compositorSupport()->createFilterAnimationCurve();
+            targetProperty = blink::WebAnimation::TargetPropertyFilter;
+            blink::WebFilterAnimationCurve* filterCurve = blink::Platform::current()->compositorSupport()->createFilterAnimationCurve();
             addKeyframesToCurve(*filterCurve, values, compositorTiming.reverse);
             curve = adoptPtr(filterCurve);
             break;
         }
         case CSSPropertyTransform: {
-            targetProperty = WebCompositorAnimation::TargetPropertyTransform;
-            WebTransformAnimationCurve* transformCurve = Platform::current()->compositorSupport()->createTransformAnimationCurve();
+            targetProperty = blink::WebAnimation::TargetPropertyTransform;
+            blink::WebTransformAnimationCurve* transformCurve = blink::Platform::current()->compositorSupport()->createTransformAnimationCurve();
             addKeyframesToCurve(*transformCurve, values, compositorTiming.reverse);
             curve = adoptPtr(transformCurve);
             break;
         }
         default:
             ASSERT_NOT_REACHED();
             continue;
         }
         ASSERT(curve.get());
 
-        OwnPtr<WebCompositorAnimation> animation = adoptPtr(Platform::current()->compositorSupport()->createAnimation(*curve, targetProperty));
+        OwnPtr<blink::WebAnimation> animation = adoptPtr(blink::Platform::current()->compositorSupport()->createAnimation(*curve, targetProperty));
 
         if (!std::isnan(startTime))
             animation->setStartTime(startTime);
 
         animation->setIterations(compositorTiming.adjustedIterationCount);
         animation->setTimeOffset(compositorTiming.scaledTimeOffset);
         animation->setAlternatesDirection(compositorTiming.alternate);
 
         animations.append(animation.release());
     }
     ASSERT(!animations.isEmpty());
 }
 
 } // namespace blink