Web Animations CSS: Start running animations on the compositor

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 105 matching lines @@
     default:
         ASSERT_NOT_REACHED();
         return PassRefPtr<TimingFunction>();
     }
 }
 
 // -----------------------------------------------------------------------
 // CompositorAnimations public API
 // -----------------------------------------------------------------------
 
-bool CompositorAnimations::isCandidateForCompositorAnimation(const Timing& timing, const AnimationEffect& effect)
+bool CompositorAnimations::isCandidateForAnimationOnCompositor(const Timing& timing, const AnimationEffect& effect)
 {
     const KeyframeAnimationEffect& keyframeEffect = *toKeyframeAnimationEffect(&effect);
 
     return CompositorAnimationsImpl::isCandidateForCompositor(keyframeEffect)
         && CompositorAnimationsImpl::isCandidateForCompositor(timing, keyframeEffect.getFrames());
 }
 
-bool CompositorAnimations::canStartCompositorAnimation(const Element& element)
+bool CompositorAnimations::canStartAnimationOnCompositor(const Element& element)
 {
     return element.renderer() && element.renderer()->compositingState() == PaintsIntoOwnBacking;
 }
 
-void CompositorAnimations::startCompositorAnimation(const Element& element, const Timing& timing, const AnimationEffect& effect, Vector<int>& startedAnimationIds)
+bool CompositorAnimations::startAnimationOnCompositor(const Element& element, const Timing& timing, const AnimationEffect& effect, Vector<int>& startedAnimationIds)
 {
-    ASSERT(isCandidateForCompositorAnimation(timing, effect));
-    ASSERT(canStartCompositorAnimation(element));
+    ASSERT(startedAnimationIds.isEmpty());
+    ASSERT(isCandidateForAnimationOnCompositor(timing, effect));
+    ASSERT(canStartAnimationOnCompositor(element));
 
     const KeyframeAnimationEffect& keyframeEffect = *toKeyframeAnimationEffect(&effect);
 
     RenderLayer* layer = toRenderBoxModelObject(element.renderer())->layer();
     ASSERT(layer);
     ASSERT(layer->renderBox());
 
-    // FIXME: Should we check in some way if there is an animation already created?
     Vector<OwnPtr<blink::WebAnimation> > animations;
-    CompositorAnimationsImpl::getCompositorAnimations(timing, keyframeEffect, animations, layer->renderBox()->pixelSnappedBorderBoxRect().size());
+    CompositorAnimationsImpl::getAnimationOnCompositor(timing, keyframeEffect, animations, layer->renderBox()->pixelSnappedBorderBoxRect().size());
     for (size_t i = 0; i < animations.size(); ++i) {
-        startedAnimationIds.append(animations[i]->id());
-        layer->compositedLayerMapping()->mainGraphicsLayer()->addAnimation(animations[i].release());
+        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;
+        }
+        startedAnimationIds.append(id);
     }
+    return true;
 }
 
-void CompositorAnimations::cancelCompositorAnimation(const Element& element, int id)
+void CompositorAnimations::cancelAnimationOnCompositor(const Element& element, int id)
 {
-    // FIXME: Implement.
-    ASSERT_NOT_REACHED();
+    if (!element.renderer() || element.renderer()->compositingState() != PaintsIntoOwnBacking)
+        return;
+    toRenderBoxModelObject(element.renderer())->layer()->compositedLayerMapping()->mainGraphicsLayer()->removeAnimation(id);
 }
 
 // -----------------------------------------------------------------------
 // CompositorAnimationsKeyframeEffectHelper
 // -----------------------------------------------------------------------
 
 PassOwnPtr<Vector<CSSPropertyID> > CompositorAnimationsKeyframeEffectHelper::getProperties(
     const KeyframeAnimationEffect* effect)
 {
     const_cast<KeyframeAnimationEffect*>(effect)->ensureKeyframeGroups();
@@ skipping 66 matching lines @@
     const KeyframeAnimationEffect::KeyframeVector frames = effect.getFrames();
     for (size_t i = 0; i < frames.size(); ++i) {
         if (!isCandidateForCompositor(*frames[i].get()))
             return false;
     }
     return true;
 }
 
 bool CompositorAnimationsImpl::isCandidateForCompositor(const Timing& timing, const KeyframeAnimationEffect::KeyframeVector& frames)
 {
-
     CompositorTiming out;
     if (!convertTimingForCompositor(timing, out))
         return false;
 
     return isCandidateForCompositor(*timing.timingFunction.get(), &frames);
 }
 
 bool CompositorAnimationsImpl::isCandidateForCompositor(const TimingFunction& timingFunction, const KeyframeAnimationEffect::KeyframeVector* frames, bool isNestedCall)
 {
     switch (timingFunction.type()) {
@@ skipping 226 matching lines @@
             }
         }
 
         ASSERT(!values[i].second->dependsOnUnderlyingValue());
         RefPtr<AnimatableValue> value = values[i].second->compositeOnto(0);
         OwnPtr<PlatformAnimationKeyframeType> keyframe = createPlatformKeyframe<PlatformAnimationKeyframeType>(values[i].first, *value.get(), elementSize);
         addKeyframeWithTimingFunction(curve, *keyframe.get(), keyframeTimingFunction);
     }
 }
 
-void CompositorAnimationsImpl::getCompositorAnimations(
+void CompositorAnimationsImpl::getAnimationOnCompositor(
     const Timing& timing, const KeyframeAnimationEffect& effect, Vector<OwnPtr<blink::WebAnimation> >& animations, const IntSize& elementSize)
 {
     CompositorTiming compositorTiming;
     bool timingValid = convertTimingForCompositor(timing, compositorTiming);
     ASSERT_UNUSED(timingValid, timingValid);
 
     RefPtr<TimingFunction> timingFunction = timing.timingFunction;
     if (compositorTiming.reverse)
         timingFunction = CompositorAnimationsTimingFunctionReverser::reverse(timingFunction.get());
 
@@ skipping 37 matching lines @@
 
         animation->setIterations(compositorTiming.adjustedIterationCount);
         animation->setTimeOffset(compositorTiming.scaledTimeOffset);
         animation->setAlternatesDirection(compositorTiming.alternate);
 
         animations.append(animation.release());
     }
 }
 
 } // namespace WebCore