Rename KeyframeEffect::isAnimation to KeyframeEffect::isKeyframeEffect

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 342 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->isAnimation())
+    if (!m_content || !m_content->isKeyframeEffect())
         return false;
 
     const KeyframeEffect* effect = toKeyframeEffect(m_content.get());
     return (effect->target() == &element) && effect->affects(PropertyHandle(property));
 }
 
 double Animation::calculateStartTime(double currentTime) const
 {
     return m_timeline->effectiveTime() - currentTime / m_playbackRate;
 }
@@ skipping 314 matching lines @@
 
 bool Animation::canStartAnimationOnCompositor() const
 {
     if (m_isCompositedAnimationDisabledForTesting)
         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->isAnimation() && playing();
+    return m_timeline && m_content && m_content->isKeyframeEffect() && playing();
 }
 
 bool Animation::isCandidateForAnimationOnCompositor() const
 {
     if (!canStartAnimationOnCompositor())
         return false;
 
     return toKeyframeEffect(m_content.get())->isCandidateForAnimationOnCompositor(m_playbackRate);
 }
 
@@ skipping 51 matching lines @@
 }
 
 void Animation::restartAnimationOnCompositor()
 {
     if (hasActiveAnimationsOnCompositor())
         toKeyframeEffect(m_content.get())->restartAnimationOnCompositor();
 }
 
 void Animation::cancelIncompatibleAnimationsOnCompositor()
 {
-    if (m_content && m_content->isAnimation())
+    if (m_content && m_content->isKeyframeEffect())
         toKeyframeEffect(m_content.get())->cancelIncompatibleAnimationsOnCompositor();
 }
 
 bool Animation::hasActiveAnimationsOnCompositor()
 {
-    if (!m_content || !m_content->isAnimation())
+    if (!m_content || !m_content->isKeyframeEffect())
         return false;
 
     return toKeyframeEffect(m_content.get())->hasActiveAnimationsOnCompositor();
 }
 
 bool Animation::update(TimingUpdateReason reason)
 {
     if (!m_timeline)
         return false;
 
@@ skipping 160 matching lines @@
             timeline->playerDestroyed(*this);
     }
 }
 
 void Animation::attachCompositedLayers()
 {
     if (!RuntimeEnabledFeatures::compositorAnimationTimelinesEnabled() || !m_compositorPlayer)
         return;
 
     ASSERT(m_content);
-    ASSERT(m_content->isAnimation());
+    ASSERT(m_content->isKeyframeEffect());
 
     if (toKeyframeEffect(m_content.get())->canAttachCompositedLayers())
         toKeyframeEffect(m_content.get())->attachCompositedLayers();
 }
 
 void Animation::detachCompositedLayers()
 {
     if (m_compositorPlayer && m_compositorPlayer->isLayerAttached())
         m_compositorPlayer->detachLayer();
 }
@@ skipping 116 matching lines @@
     visitor->trace(m_content);
     visitor->trace(m_timeline);
     visitor->trace(m_pendingFinishedEvent);
     visitor->trace(m_finishedPromise);
     visitor->trace(m_readyPromise);
     RefCountedGarbageCollectedEventTargetWithInlineData<Animation>::trace(visitor);
     ActiveDOMObject::trace(visitor);
 }
 
 } // namespace