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::isCandidateForCompositorAnimations(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::canStartCompositorAnimations(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::startCompositorAnimations(const Element& element, const Timing& timing, const AnimationEffect& effect, Vector<int>& startedAnimationIds)
 {
-    ASSERT(isCandidateForCompositorAnimation(timing, effect));
-    ASSERT(canStartCompositorAnimation(element));
+    ASSERT(startedAnimationIds.isEmpty());
+    ASSERT(isCandidateForCompositorAnimations(timing, effect));
+    ASSERT(canStartCompositorAnimations(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.

[ajuma, 2013/11/18 21:21:17]

Note that for the old path, there's logic to avoid sending pixel-moving filter
animations to the compositor (e.g. see
https://code.google.com/p/chromium/codesearch#chromium/src/third_party/WebKit...).
We'll need something equivalent for the new path too.

[dstockwell, 2013/11/18 21:34:03]

Thanks for taking a look. We have the same logic here:
https://code.google.com/p/chromium/codesearch#chromium/src/third_party/WebKit...

+            for (size_t j = 0; j < startedAnimationIds.size(); ++j)
+                cancelCompositorAnimations(element, startedAnimationIds[j]);
+            startedAnimationIds.clear();
+            return false;
+        }
+        startedAnimationIds.append(id);
     }
+    return true;
 }
 
-void CompositorAnimations::cancelCompositorAnimation(const Element& element, int id)
+void CompositorAnimations::cancelCompositorAnimations(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 284 matching lines @@
 
         animation->setIterations(compositorTiming.adjustedIterationCount);
         animation->setTimeOffset(compositorTiming.scaledTimeOffset);
         animation->setAlternatesDirection(compositorTiming.alternate);
 
         animations.append(animation.release());
     }
 }
 
 } // namespace WebCore