Construct KeyframeEffectReadOnly objects

third_party/WebKit/Source/core/animation/css/CSSAnimations.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 20 matching lines @@
 #include "core/animation/css/CSSAnimations.h"
 
 #include "core/StylePropertyShorthand.h"
 #include "core/animation/Animation.h"
 #include "core/animation/CompositorAnimations.h"
 #include "core/animation/DocumentTimeline.h"
 #include "core/animation/ElementAnimations.h"
 #include "core/animation/InertEffect.h"
 #include "core/animation/Interpolation.h"
 #include "core/animation/KeyframeEffectModel.h"
+#include "core/animation/KeyframeEffectReadOnly.h"
 #include "core/animation/LegacyStyleInterpolation.h"
 #include "core/animation/css/CSSAnimatableValueFactory.h"
 #include "core/css/CSSKeyframeRule.h"
 #include "core/css/CSSPropertyEquality.h"
 #include "core/css/CSSPropertyMetadata.h"
 #include "core/css/CSSValueList.h"
 #include "core/css/resolver/CSSToStyleMap.h"
 #include "core/css/resolver/StyleResolver.h"
 #include "core/dom/Element.h"
 #include "core/dom/PseudoElement.h"
@@ skipping 192 matching lines @@
   calculateAnimationActiveInterpolations(animationUpdate, animatingElement);
   calculateTransitionUpdate(animationUpdate, animatingElement, style);
   calculateTransitionActiveInterpolations(animationUpdate, animatingElement);
 }
 
 static const KeyframeEffectModelBase* getKeyframeEffectModelBase(
     const AnimationEffectReadOnly* effect) {
   if (!effect)
     return nullptr;
   const EffectModel* model = nullptr;
-  if (effect->isKeyframeEffect())
-    model = toKeyframeEffect(effect)->model();
+  if (effect->isKeyframeEffectReadOnly())
+    model = toKeyframeEffectReadOnly(effect)->model();
   else if (effect->isInertEffect())
     model = toInertEffect(effect)->model();
   if (!model || !model->isKeyframeEffectModel())
     return nullptr;
   return toKeyframeEffectModelBase(model);
 }
 
 void CSSAnimations::calculateCompositorAnimationUpdate(
     CSSAnimationUpdate& update,
     const Element* animatingElement,
@@ skipping 215 matching lines @@
     else
       animation.pause();
     if (animation.outdated())
       animation.update(TimingUpdateOnDemand);
   }
 
   for (const auto& animation : m_pendingUpdate.updatedCompositorKeyframes())
     animation->setCompositorPending(true);
 
   for (const auto& entry : m_pendingUpdate.animationsWithUpdates()) {
-    KeyframeEffect* effect = toKeyframeEffect(entry.animation->effect());
+    KeyframeEffectReadOnly* effect =
+        toKeyframeEffectReadOnly(entry.animation->effect());
 
     effect->setModel(entry.effect->model());
     effect->updateSpecifiedTiming(entry.effect->specifiedTiming());
 
     m_runningAnimations[entry.index]->update(entry);
   }
 
   const Vector<size_t>& cancelledIndices =
       m_pendingUpdate.cancelledAnimationIndices();
   for (size_t i = cancelledIndices.size(); i-- > 0;) {
@@ skipping 19 matching lines @@
     animation->update(TimingUpdateOnDemand);
 
     m_runningAnimations.append(new RunningAnimation(animation, entry));
   }
 
   // Transitions that are run on the compositor only update main-thread state
   // lazily. However, we need the new state to know what the from state shoud
   // be when transitions are retargeted. Instead of triggering complete style
   // recalculation, we find these cases by searching for new transitions that
   // have matching cancelled animation property IDs on the compositor.
-  HeapHashMap<CSSPropertyID, std::pair<Member<KeyframeEffect>, double>>
+  HeapHashMap<CSSPropertyID, std::pair<Member<KeyframeEffectReadOnly>, double>>
       retargetedCompositorTransitions;
   for (CSSPropertyID id : m_pendingUpdate.cancelledTransitions()) {
     DCHECK(m_transitions.contains(id));
 
     Animation* animation = m_transitions.take(id).animation;
-    KeyframeEffect* effect = toKeyframeEffect(animation->effect());
+    KeyframeEffectReadOnly* effect =
+        toKeyframeEffectReadOnly(animation->effect());
     if (effect->hasActiveAnimationsOnCompositor(id) &&
         m_pendingUpdate.newTransitions().find(id) !=
             m_pendingUpdate.newTransitions().end() &&
         !animation->limited())
       retargetedCompositorTransitions.add(
-          id, std::pair<KeyframeEffect*, double>(
+          id, std::pair<KeyframeEffectReadOnly*, double>(
                   effect, animation->startTimeInternal()));
     animation->cancel();
     // after cancelation, transitions must be downgraded or they'll fail
     // to be considered when retriggering themselves. This can happen if
     // the transition is captured through getAnimations then played.
-    if (animation->effect() && animation->effect()->isKeyframeEffect())
-      toKeyframeEffect(animation->effect())->downgradeToNormal();
+    if (animation->effect() && animation->effect()->isKeyframeEffectReadOnly())
+      toKeyframeEffectReadOnly(animation->effect())->downgradeToNormal();
     animation->update(TimingUpdateOnDemand);
   }
 
   for (CSSPropertyID id : m_pendingUpdate.finishedTransitions()) {
     // This transition can also be cancelled and finished at the same time
     if (m_transitions.contains(id)) {
       Animation* animation = m_transitions.take(id).animation;
       // Transition must be downgraded
-      if (animation->effect() && animation->effect()->isKeyframeEffect())
-        toKeyframeEffect(animation->effect())->downgradeToNormal();
+      if (animation->effect() &&
+          animation->effect()->isKeyframeEffectReadOnly())
+        toKeyframeEffectReadOnly(animation->effect())->downgradeToNormal();
     }
   }
 
   for (const auto& entry : m_pendingUpdate.newTransitions()) {
     const CSSAnimationUpdate::NewTransition& newTransition = entry.value;
 
     RunningTransition runningTransition;
     runningTransition.from = newTransition.from;
     runningTransition.to = newTransition.to;
     runningTransition.reversingAdjustedStartValue =
         newTransition.reversingAdjustedStartValue;
     runningTransition.reversingShorteningFactor =
         newTransition.reversingShorteningFactor;
 
     CSSPropertyID id = newTransition.id;
     const InertEffect* inertAnimation = newTransition.effect.get();
     TransitionEventDelegate* eventDelegate =
         new TransitionEventDelegate(element, id);
 
     EffectModel* model = inertAnimation->model();
 
     if (retargetedCompositorTransitions.contains(id)) {
-      const std::pair<Member<KeyframeEffect>, double>& oldTransition =
+      const std::pair<Member<KeyframeEffectReadOnly>, double>& oldTransition =
           retargetedCompositorTransitions.get(id);
-      KeyframeEffect* oldAnimation = oldTransition.first;
+      KeyframeEffectReadOnly* oldAnimation = oldTransition.first;
       double oldStartTime = oldTransition.second;
       double inheritedTime =
           isNull(oldStartTime)
               ? 0
               : element->document().timeline().currentTimeInternal() -
                     oldStartTime;
 
       AnimatableValueKeyframeEffectModel* oldEffect =
           toAnimatableValueKeyframeEffectModel(inertAnimation->model());
       const KeyframeVector& frames = oldEffect->getFrames();
@@ skipping 488 matching lines @@
   return toShadowRoot(treeScope.rootNode()).host() == element;
 }
 
 DEFINE_TRACE(CSSAnimations) {
   visitor->trace(m_transitions);
   visitor->trace(m_pendingUpdate);
   visitor->trace(m_runningAnimations);
 }
 
 }  // namespace blink