Web Animations CSS: Start running animations on the compositor

Source/core/frame/animation/AnimationController.cpp

 /*
  * Copyright (C) 2007, 2008, 2009 Apple 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:
  *
  * 1.  Redistributions of source code must retain the above copyright
  *     notice, this list of conditions and the following disclaimer.
  * 2.  Redistributions in binary form must reproduce the above copyright
@@ skipping 238 matching lines @@
 }
 
 void AnimationControllerPrivate::animationTimerFired(Timer<AnimationControllerPrivate>*)
 {
     // Make sure animationUpdateTime is updated, so that it is current even if no
     // styleChange has happened (e.g. accelerated animations)
     setBeginAnimationUpdateTime(cBeginAnimationUpdateTimeNotSet);
     serviceAnimations();
 }
 
-bool AnimationControllerPrivate::isRunningAnimationOnRenderer(RenderObject* renderer, CSSPropertyID property, bool isRunningNow) const
+bool AnimationControllerPrivate::isRunningAnimationOnRenderer(const RenderObject* renderer, CSSPropertyID property, bool isRunningNow) const
 {
-    RefPtr<CompositeAnimation> animation = m_compositeAnimations.get(renderer);
+    RefPtr<CompositeAnimation> animation = m_compositeAnimations.get(const_cast<RenderObject*>(renderer));
     if (!animation)
         return false;
 
     return animation->isAnimatingProperty(property, false, isRunningNow);
 }
 
-bool AnimationControllerPrivate::isRunningAcceleratableAnimationOnRenderer(RenderObject *renderer) const
+bool AnimationControllerPrivate::isRunningAcceleratableAnimationOnRenderer(const RenderObject *renderer) const
 {
-    RefPtr<CompositeAnimation> animation = m_compositeAnimations.get(renderer);
+    RefPtr<CompositeAnimation> animation = m_compositeAnimations.get(const_cast<RenderObject*>(renderer));
     if (!animation)
         return false;
 
     bool acceleratedOnly = false;
     bool isRunningNow = true;
     return animation->isAnimatingProperty(CSSPropertyOpacity, acceleratedOnly, isRunningNow)
         || animation->isAnimatingProperty(CSSPropertyWebkitTransform, acceleratedOnly, isRunningNow)
         || animation->isAnimatingProperty(CSSPropertyWebkitFilter, acceleratedOnly, isRunningNow);
 }
 
-bool AnimationControllerPrivate::isRunningAcceleratedAnimationOnRenderer(RenderObject* renderer, CSSPropertyID property, bool isRunningNow) const
+bool AnimationControllerPrivate::isRunningAcceleratedAnimationOnRenderer(const RenderObject* renderer, CSSPropertyID property, bool isRunningNow) const
 {
-    RefPtr<CompositeAnimation> animation = m_compositeAnimations.get(renderer);
+    RefPtr<CompositeAnimation> animation = m_compositeAnimations.get(const_cast<RenderObject*>(renderer));
     if (!animation)
         return false;
 
     return animation->isAnimatingProperty(property, true, isRunningNow);
 }
 
 void AnimationControllerPrivate::pauseAnimationsForTesting(double t)
 {
     RenderObjectAnimationMap::const_iterator animationsEnd = m_compositeAnimations.end();
     for (RenderObjectAnimationMap::const_iterator it = m_compositeAnimations.begin(); it != animationsEnd; ++it) {
@@ skipping 180 matching lines @@
         // the style to impose the stacking rules. Note that this is also
         // done in StyleResolver::adjustRenderStyle().
         if (blendedStyle->hasAutoZIndex() && (blendedStyle->opacity() < 1.0f || blendedStyle->hasTransform()))
             blendedStyle->setZIndex(0);
     }
     return blendedStyle.release();
 }
 
 PassRefPtr<RenderStyle> AnimationController::getAnimatedStyleForRenderer(RenderObject* renderer)
 {
+    ASSERT(!RuntimeEnabledFeatures::webAnimationsCSSEnabled());

[Steve Block, 2013/11/18 05:03:03]

Shouldn't we just assert in the constructor?

[dstockwell, 2013/11/18 05:30:34]

I removed these for now. But I think this object is still created, we should
disable it in a separate patch.

     return m_data->getAnimatedStyleForRenderer(renderer);
 }
 
 void AnimationController::notifyAnimationStarted(RenderObject*, double startTime)
 {
     m_data->receivedStartTimeResponse(startTime);
 }
 
 void AnimationController::pauseAnimationsForTesting(double t)
 {
     m_data->pauseAnimationsForTesting(t);
 }
 
 unsigned AnimationController::numberOfActiveAnimations(Document* document) const
 {
     return m_data->numberOfActiveAnimations(document);
 }
 
-bool AnimationController::isRunningAnimationOnRenderer(RenderObject* renderer, CSSPropertyID property, bool isRunningNow) const
+bool AnimationController::isRunningAnimationOnRenderer(const RenderObject* renderer, CSSPropertyID property, bool isRunningNow) const
 {
+    ASSERT(!RuntimeEnabledFeatures::webAnimationsCSSEnabled());
     return m_data->isRunningAnimationOnRenderer(renderer, property, isRunningNow);
 }
 
-bool AnimationController::isRunningAcceleratableAnimationOnRenderer(RenderObject* renderer) const
+bool AnimationController::isRunningAcceleratableAnimationOnRenderer(const RenderObject* renderer) const
 {
+    ASSERT(!RuntimeEnabledFeatures::webAnimationsCSSEnabled());
     return m_data->isRunningAcceleratableAnimationOnRenderer(renderer);
 }
 
-bool AnimationController::isRunningAcceleratedAnimationOnRenderer(RenderObject* renderer, CSSPropertyID property, bool isRunningNow) const
+bool AnimationController::isRunningAcceleratedAnimationOnRenderer(const RenderObject* renderer, CSSPropertyID property, bool isRunningNow) const
 {
+    ASSERT(!RuntimeEnabledFeatures::webAnimationsCSSEnabled());
     return m_data->isRunningAcceleratedAnimationOnRenderer(renderer, property, isRunningNow);
 }
 
 void AnimationController::serviceAnimations()
 {
     m_data->serviceAnimations();
 }
 
 void AnimationController::beginAnimationUpdate()
 {
     if (!m_beginAnimationUpdateCount)
         m_data->setBeginAnimationUpdateTime(cBeginAnimationUpdateTimeNotSet);
     ++m_beginAnimationUpdateCount;
 }
 
 void AnimationController::endAnimationUpdate()
 {
     ASSERT(m_beginAnimationUpdateCount > 0);
     --m_beginAnimationUpdateCount;
     if (!m_beginAnimationUpdateCount)
         m_data->endAnimationUpdate();
 }
 
 bool AnimationController::supportsAcceleratedAnimationOfProperty(CSSPropertyID property)
 {
     return CSSPropertyAnimation::animationOfPropertyIsAccelerated(property);
 }
 
 } // namespace WebCore