Construct KeyframeEffectReadOnly objects

third_party/WebKit/Source/core/animation/Animation.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 14 matching lines @@
  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 #include "core/animation/Animation.h"
 
 #include "core/animation/AnimationTimeline.h"
 #include "core/animation/CompositorPendingAnimations.h"
-#include "core/animation/KeyframeEffect.h"
+#include "core/animation/KeyframeEffectReadOnly.h"
 #include "core/animation/css/CSSAnimations.h"
 #include "core/dom/Document.h"
 #include "core/dom/ExceptionCode.h"
 #include "core/dom/StyleChangeReason.h"
 #include "core/events/AnimationPlaybackEvent.h"
 #include "core/frame/UseCounter.h"
 #include "core/inspector/InspectorInstrumentation.h"
 #include "core/inspector/InspectorTraceEvents.h"
 #include "platform/RuntimeEnabledFeatures.h"
 #include "platform/animation/CompositorAnimationPlayer.h"
@@ skipping 335 matching lines @@
 
     // FIXME: This avoids marking this animation as outdated needlessly when a
     // start time is notified, but we should refactor how outdating works to
     // avoid this.
     clearOutdated();
     m_currentTimePending = false;
   }
 }
 
 bool Animation::affects(const Element& element, CSSPropertyID property) const {
-  if (!m_content || !m_content->isKeyframeEffect())
+  if (!m_content || !m_content->isKeyframeEffectReadOnly())
     return false;
 
-  const KeyframeEffect* effect = toKeyframeEffect(m_content.get());
+  const KeyframeEffectReadOnly* effect =
+      toKeyframeEffectReadOnly(m_content.get());
   return (effect->target() == &element) &&
          effect->affects(PropertyHandle(property));
 }
 
 double Animation::calculateStartTime(double currentTime) const {
   return m_timeline->effectiveTime() - currentTime / m_playbackRate;
 }
 
 double Animation::calculateCurrentTime() const {
   if (isNull(m_startTime) || !m_timeline)
@@ skipping 309 matching lines @@
 
 bool Animation::canStartAnimationOnCompositor() const {
   if (m_isCompositedAnimationDisabledForTesting || effectSuppressed())
     return false;
 
   // FIXME: Timeline playback rates should be compositable
   if (m_playbackRate == 0 || (std::isinf(effectEnd()) && m_playbackRate < 0) ||
       (timeline() && timeline()->playbackRate() != 1))
     return false;
 
-  return m_timeline && m_content && m_content->isKeyframeEffect() && playing();
+  return m_timeline && m_content && m_content->isKeyframeEffectReadOnly() &&
+         playing();
 }
 
 bool Animation::isCandidateForAnimationOnCompositor() const {
   if (!canStartAnimationOnCompositor())
     return false;
 
-  return toKeyframeEffect(m_content.get())
+  return toKeyframeEffectReadOnly(m_content.get())
       ->isCandidateForAnimationOnCompositor(m_playbackRate);
 }
 
 bool Animation::maybeStartAnimationOnCompositor() {
   if (!canStartAnimationOnCompositor())
     return false;
 
   bool reversed = m_playbackRate < 0;
 
   double startTime = timeline()->zeroTime() + startTimeInternal();
   if (reversed) {
     startTime -= effectEnd() / fabs(m_playbackRate);
   }
 
   double timeOffset = 0;
   if (std::isnan(startTime)) {
     timeOffset =
         reversed ? effectEnd() - currentTimeInternal() : currentTimeInternal();
     timeOffset = timeOffset / fabs(m_playbackRate);
   }
   DCHECK_NE(m_compositorGroup, 0);
-  return toKeyframeEffect(m_content.get())
+  return toKeyframeEffectReadOnly(m_content.get())
       ->maybeStartAnimationOnCompositor(m_compositorGroup, startTime,
                                         timeOffset, m_playbackRate);
 }
 
 void Animation::setCompositorPending(bool effectChanged) {
   // FIXME: KeyframeEffect could notify this directly?
   if (!hasActiveAnimationsOnCompositor()) {
     destroyCompositorPlayer();
     m_compositorState.reset();
   }
   if (effectChanged && m_compositorState) {
     m_compositorState->effectChanged = true;
   }
   if (m_compositorPending || m_isPausedForTesting) {
     return;
   }
   if (!m_compositorState || m_compositorState->effectChanged ||
       m_compositorState->playbackRate != m_playbackRate ||
       m_compositorState->startTime != m_startTime) {
     m_compositorPending = true;
     timeline()->document()->compositorPendingAnimations().add(this);
   }
 }
 
 void Animation::cancelAnimationOnCompositor() {
   if (hasActiveAnimationsOnCompositor())
-    toKeyframeEffect(m_content.get())->cancelAnimationOnCompositor();
+    toKeyframeEffectReadOnly(m_content.get())->cancelAnimationOnCompositor();
 
   destroyCompositorPlayer();
 }
 
 void Animation::restartAnimationOnCompositor() {
   if (hasActiveAnimationsOnCompositor())
-    toKeyframeEffect(m_content.get())->restartAnimationOnCompositor();
+    toKeyframeEffectReadOnly(m_content.get())->restartAnimationOnCompositor();
 }
 
 void Animation::cancelIncompatibleAnimationsOnCompositor() {
-  if (m_content && m_content->isKeyframeEffect())
-    toKeyframeEffect(m_content.get())
+  if (m_content && m_content->isKeyframeEffectReadOnly())
+    toKeyframeEffectReadOnly(m_content.get())
         ->cancelIncompatibleAnimationsOnCompositor();
 }
 
 bool Animation::hasActiveAnimationsOnCompositor() {
-  if (!m_content || !m_content->isKeyframeEffect())
+  if (!m_content || !m_content->isKeyframeEffectReadOnly())
     return false;
 
-  return toKeyframeEffect(m_content.get())->hasActiveAnimationsOnCompositor();
+  return toKeyframeEffectReadOnly(m_content.get())
+      ->hasActiveAnimationsOnCompositor();
 }
 
 bool Animation::update(TimingUpdateReason reason) {
   if (!m_timeline)
     return false;
 
   PlayStateUpdateScope updateScope(*this, reason, DoNotSetCompositorPending);
 
   clearOutdated();
   bool idle = playStateInternal() == Idle;
@@ skipping 129 matching lines @@
     if (timeline)
       timeline->playerDestroyed(*this);
   }
 }
 
 void Animation::attachCompositedLayers() {
   if (!m_compositorPlayer)
     return;
 
   DCHECK(m_content);
-  DCHECK(m_content->isKeyframeEffect());
+  DCHECK(m_content->isKeyframeEffectReadOnly());
 
-  toKeyframeEffect(m_content.get())->attachCompositedLayers();
+  toKeyframeEffectReadOnly(m_content.get())->attachCompositedLayers();
 }
 
 void Animation::detachCompositedLayers() {
   if (m_compositorPlayer && m_compositorPlayer->isElementAttached())
     m_compositorPlayer->detachElement();
 }
 
 void Animation::notifyAnimationStarted(double monotonicTime, int group) {
   timeline()
       ->document()
@@ skipping 107 matching lines @@
     RegisteredEventListener& registeredListener) {
   EventTargetWithInlineData::addedEventListener(eventType, registeredListener);
   if (eventType == EventTypeNames::finish)
     UseCounter::count(getExecutionContext(), UseCounter::AnimationFinishEvent);
 }
 
 void Animation::pauseForTesting(double pauseTime) {
   RELEASE_ASSERT(!paused());
   setCurrentTimeInternal(pauseTime, TimingUpdateOnDemand);
   if (hasActiveAnimationsOnCompositor())
-    toKeyframeEffect(m_content.get())
+    toKeyframeEffectReadOnly(m_content.get())
         ->pauseAnimationForTestingOnCompositor(currentTimeInternal());
   m_isPausedForTesting = true;
   pause();
 }
 
 void Animation::setEffectSuppressed(bool suppressed) {
   m_effectSuppressed = suppressed;
   if (suppressed)
     cancelAnimationOnCompositor();
 }
 
 void Animation::disableCompositedAnimationForTesting() {
   m_isCompositedAnimationDisabledForTesting = true;
   cancelAnimationOnCompositor();
 }
 
 void Animation::invalidateKeyframeEffect(const TreeScope& treeScope) {
-  if (!m_content || !m_content->isKeyframeEffect())
+  if (!m_content || !m_content->isKeyframeEffectReadOnly())
     return;
 
-  Element& target = *toKeyframeEffect(m_content.get())->target();
+  Element& target = *toKeyframeEffectReadOnly(m_content.get())->target();
 
   if (CSSAnimations::isAffectedByKeyframesFromScope(target, treeScope))
     target.setNeedsStyleRecalc(LocalStyleChange,
                                StyleChangeReasonForTracing::create(
                                    StyleChangeReason::StyleSheetChange));
 }
 
 DEFINE_TRACE(Animation) {
   visitor->trace(m_content);
   visitor->trace(m_timeline);
   visitor->trace(m_pendingFinishedEvent);
   visitor->trace(m_pendingCancelledEvent);
   visitor->trace(m_finishedPromise);
   visitor->trace(m_readyPromise);
   EventTargetWithInlineData::trace(visitor);
   ActiveDOMObject::trace(visitor);
 }
 
 }  // namespace blink