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 118 matching lines @@
 
     return CompositorAnimationsImpl::isCandidateForCompositor(keyframeEffect)
         && CompositorAnimationsImpl::isCandidateForCompositor(timing, keyframeEffect.getFrames());
 }
 
 bool CompositorAnimations::canStartCompositorAnimation(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::startCompositorAnimation(const Element& element, const Timing& timing, const AnimationEffect& effect, Vector<int>& startedAnimationIds)
 {
+    ASSERT(startedAnimationIds.isEmpty());
     ASSERT(isCandidateForCompositorAnimation(timing, effect));
     ASSERT(canStartCompositorAnimation(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());
     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)
+                cancelCompositorAnimation(element, startedAnimationIds[j]);
+            startedAnimationIds.clear();
+            return false;
+        }
+        startedAnimationIds.append(id);
     }
+    return true;
 }
 
 void CompositorAnimations::cancelCompositorAnimation(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 50 matching lines @@
     // FIXME: Support positive startDelay
     if (timing.startDelay > 0.0)
         return false;
 
     // All fill modes are supported (the calling code handles them).
 
     // FIXME: Support non-zero iteration start.
     if (timing.iterationStart)
         return false;
 
-    // FIXME: Compositor only supports finite, non-zero, integer iteration
-    // counts.
-    if (!std::isfinite(timing.iterationCount) || (std::floor(timing.iterationCount) != timing.iterationCount) || !timing.iterationCount)
+    // FIXME: Compositor only non-zero, integer iteration counts.
+    if ((std::floor(timing.iterationCount) != timing.iterationCount) || !timing.iterationCount)
         return false;
 
     if (!timing.iterationDuration)
         return false;
 
     // FIXME: Support other playback rates
     if (timing.playbackRate != 1)
         return false;
 
     // All directions are supported.
@@ skipping 11 matching lines @@
         return false;
 
     out.reverse = (timing.direction == Timing::PlaybackDirectionReverse
         || timing.direction == Timing::PlaybackDirectionAlternateReverse);
     out.alternate = (timing.direction == Timing::PlaybackDirectionAlternate
         || timing.direction == Timing::PlaybackDirectionAlternateReverse);
     if (out.alternate && (skippedIterations % 2))
         out.reverse = !out.reverse;
 
     out.adjustedIterationCount = std::floor(timing.iterationCount) - skippedIterations;
-    ASSERT(out.adjustedIterationCount > 0);
+    if (!std::isfinite(timing.iterationCount))
+        out.adjustedIterationCount = -1;
+    // ASSERT(out.adjustedIterationCount > 0);
 
     out.scaledTimeOffset = scaledStartDelay + skippedIterations * out.scaledDuration;
     ASSERT(out.scaledTimeOffset <= 0);
     return true;
 }
 
 namespace {
 
 template<typename PlatformAnimationKeyframeType>
 static PassOwnPtr<PlatformAnimationKeyframeType> createPlatformKeyframe(double offset, const AnimatableValue&, const IntSize&)
@@ skipping 100 matching lines @@
             case TimingFunction::LinearFunction:
             case TimingFunction::CubicBezierFunction:
                 keyframeTimingFunction = &timingFunction;
                 break;
 
             case TimingFunction::ChainedFunction: {
                 const ChainedTimingFunction* chained = static_cast<const ChainedTimingFunction*>(&timingFunction);
                 // ChainedTimingFunction criteria was checked in isCandidate,
                 // assert it is valid.
                 ASSERT(values.size() == chained->m_segments.size() + 1);
-                ASSERT(values[i].first == chained->m_segments[i].m_min);
+                // FIXME: first has been scaled, this assertion is not valid
+                // ASSERT(values[i].first == chained->m_segments[i].m_min);
 
                 keyframeTimingFunction = chained->m_segments[i].m_timingFunction.get();
                 break;
             }
             case TimingFunction::StepsFunction:
             default:
                 ASSERT_NOT_REACHED();
             }
         }
 
@@ skipping 55 matching lines @@
 
         animation->setIterations(compositorTiming.adjustedIterationCount);
         animation->setTimeOffset(compositorTiming.scaledTimeOffset);
         animation->setAlternatesDirection(compositorTiming.alternate);
 
         animations.append(animation.release());
     }
 }
 
 } // namespace WebCore