Oilpan: Completely move core/animations/ to oilpan's heap

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 28 matching lines @@
 #include "core/animation/CompositorAnimations.h"
 #include "core/animation/DocumentTimeline.h"
 #include "core/animation/Interpolation.h"
 #include "core/animation/KeyframeEffectModel.h"
 #include "core/dom/Element.h"
 #include "core/frame/UseCounter.h"
 #include "core/rendering/RenderLayer.h"
 
 namespace WebCore {
 
-PassRefPtr<Animation> Animation::create(Element* target, PassRefPtrWillBeRawPtr<AnimationEffect> effect, const Timing& timing, Priority priority, PassOwnPtr<EventDelegate> eventDelegate)
+PassRefPtrWillBeRawPtr<Animation> Animation::create(Element* target, PassRefPtrWillBeRawPtr<AnimationEffect> effect, const Timing& timing, Priority priority, PassOwnPtr<EventDelegate> eventDelegate)
 {
-    return adoptRef(new Animation(target, effect, timing, priority, eventDelegate));
+    return adoptRefWillBeNoop(new Animation(target, effect, timing, priority, eventDelegate));
 }
 
-PassRefPtr<Animation> Animation::create(Element* element, PassRefPtrWillBeRawPtr<AnimationEffect> effect, const Dictionary& timingInputDictionary)
+PassRefPtrWillBeRawPtr<Animation> Animation::create(Element* element, PassRefPtrWillBeRawPtr<AnimationEffect> effect, const Dictionary& timingInputDictionary)
 {
     ASSERT(RuntimeEnabledFeatures::webAnimationsAPIEnabled());
     return create(element, effect, TimingInput::convert(timingInputDictionary));
 }
-PassRefPtr<Animation> Animation::create(Element* element, PassRefPtrWillBeRawPtr<AnimationEffect> effect, double duration)
+PassRefPtrWillBeRawPtr<Animation> Animation::create(Element* element, PassRefPtrWillBeRawPtr<AnimationEffect> effect, double duration)
 {
     ASSERT(RuntimeEnabledFeatures::webAnimationsAPIEnabled());
     return create(element, effect, TimingInput::convert(duration));
 }
-PassRefPtr<Animation> Animation::create(Element* element, PassRefPtrWillBeRawPtr<AnimationEffect> effect)
+PassRefPtrWillBeRawPtr<Animation> Animation::create(Element* element, PassRefPtrWillBeRawPtr<AnimationEffect> effect)
 {
     ASSERT(RuntimeEnabledFeatures::webAnimationsAPIEnabled());
     return create(element, effect, Timing());
 }
-PassRefPtr<Animation> Animation::create(Element* element, const Vector<Dictionary>& keyframeDictionaryVector, const Dictionary& timingInputDictionary, ExceptionState& exceptionState)
+PassRefPtrWillBeRawPtr<Animation> Animation::create(Element* element, const Vector<Dictionary>& keyframeDictionaryVector, const Dictionary& timingInputDictionary, ExceptionState& exceptionState)
 {
     ASSERT(RuntimeEnabledFeatures::webAnimationsAPIEnabled());
     if (element)
         UseCounter::count(element->document(), UseCounter::AnimationConstructorKeyframeListEffectObjectTiming);
     return create(element, EffectInput::convert(element, keyframeDictionaryVector, exceptionState), TimingInput::convert(timingInputDictionary));
 }
-PassRefPtr<Animation> Animation::create(Element* element, const Vector<Dictionary>& keyframeDictionaryVector, double duration, ExceptionState& exceptionState)
+PassRefPtrWillBeRawPtr<Animation> Animation::create(Element* element, const Vector<Dictionary>& keyframeDictionaryVector, double duration, ExceptionState& exceptionState)
 {
     ASSERT(RuntimeEnabledFeatures::webAnimationsAPIEnabled());
     if (element)
         UseCounter::count(element->document(), UseCounter::AnimationConstructorKeyframeListEffectDoubleTiming);
     return create(element, EffectInput::convert(element, keyframeDictionaryVector, exceptionState), TimingInput::convert(duration));
 }
-PassRefPtr<Animation> Animation::create(Element* element, const Vector<Dictionary>& keyframeDictionaryVector, ExceptionState& exceptionState)
+PassRefPtrWillBeRawPtr<Animation> Animation::create(Element* element, const Vector<Dictionary>& keyframeDictionaryVector, ExceptionState& exceptionState)
 {
     ASSERT(RuntimeEnabledFeatures::webAnimationsAPIEnabled());
     if (element)
         UseCounter::count(element->document(), UseCounter::AnimationConstructorKeyframeListEffectNoTiming);
     return create(element, EffectInput::convert(element, keyframeDictionaryVector, exceptionState), Timing());
 }
 
 Animation::Animation(Element* target, PassRefPtrWillBeRawPtr<AnimationEffect> effect, const Timing& timing, Priority priority, PassOwnPtr<EventDelegate> eventDelegate)
     : TimedItem(timing, eventDelegate)
     , m_target(target)
     , m_effect(effect)
-    , m_sampledEffect(0)
+    , m_sampledEffect(nullptr)
     , m_priority(priority)
 {
+#if !ENABLE(OILPAN)
     if (m_target)
         m_target->ensureActiveAnimations().addAnimation(this);
+#endif
 }
 
 Animation::~Animation()
 {
+#if !ENABLE(OILPAN)
     if (m_target)
         m_target->activeAnimations()->notifyAnimationDestroyed(this);
+#endif
 }
 
-void Animation::didAttach()
+void Animation::attach(AnimationPlayer* player)
 {
     if (m_target) {
-        m_target->ensureActiveAnimations().addPlayer(player());
+        m_target->ensureActiveAnimations().addPlayer(player);
         m_target->setNeedsAnimationStyleRecalc();
     }
+    TimedItem::attach(player);
 }
 
-void Animation::willDetach()
+void Animation::detach()
 {
     if (m_target)
         m_target->activeAnimations()->removePlayer(player());
     if (m_sampledEffect)
         clearEffects();
+    TimedItem::detach();
 }
 
 void Animation::specifiedTimingChanged()
 {
     cancelAnimationOnCompositor();
     if (player()) {
         // FIXME: Needs to consider groups when added.
         ASSERT(player()->source() == this);
         player()->schedulePendingAnimationOnCompositor();
     }
@@ skipping 11 matching lines @@
     if (!m_target || !m_effect)
         return;
 
     double iteration = currentIteration();
     ASSERT(iteration >= 0);
     // FIXME: Handle iteration values which overflow int.
     OwnPtrWillBeRawPtr<WillBeHeapVector<RefPtrWillBeMember<Interpolation> > > interpolations = m_effect->sample(static_cast<int>(iteration), timeFraction(), iterationDuration());
     if (m_sampledEffect) {
         m_sampledEffect->setInterpolations(interpolations.release());
     } else if (!interpolations->isEmpty()) {
-        OwnPtr<SampledEffect> sampledEffect = SampledEffect::create(this, interpolations.release());
+        OwnPtrWillBeRawPtr<SampledEffect> sampledEffect = SampledEffect::create(this, interpolations.release());
         m_sampledEffect = sampledEffect.get();
         ensureAnimationStack(m_target).add(sampledEffect.release());
     } else {
         return;
     }
 
     m_target->setNeedsAnimationStyleRecalc();
 }
 
 void Animation::clearEffects()
 {
     ASSERT(player());
     ASSERT(m_sampledEffect);
 
     m_sampledEffect->clear();
-    m_sampledEffect = 0;
+    m_sampledEffect = nullptr;
     cancelAnimationOnCompositor();
     m_target->setNeedsAnimationStyleRecalc();
     invalidate();
 }
 
 void Animation::updateChildrenAndEffects() const
 {
     if (!m_effect)
         return;
     if (isInEffect())
@@ skipping 38 matching lines @@
         return std::numeric_limits<double>::infinity();
     default:
         ASSERT_NOT_REACHED();
         return std::numeric_limits<double>::infinity();
     }
 }
 
 void Animation::notifySampledEffectRemovedFromAnimationStack()
 {
     ASSERT(m_sampledEffect);
-    m_sampledEffect = 0;
+    m_sampledEffect = nullptr;
 }
 
+#if !ENABLE(OILPAN)
 void Animation::notifyElementDestroyed()
 {
     // If our player is kept alive just by the sampledEffect, we might get our
     // destructor called when we call SampledEffect::clear(), so we need to
     // clear m_sampledEffect first.
     m_target = 0;
     clearEventDelegate();
     SampledEffect* sampledEffect = m_sampledEffect;
-    m_sampledEffect = 0;
+    m_sampledEffect = nullptr;
     if (sampledEffect)
         sampledEffect->clear();
 }
+#endif
 
 bool Animation::isCandidateForAnimationOnCompositor() const
 {
     if (!effect() || !m_target)
         return false;
     return CompositorAnimations::instance()->isCandidateForAnimationOnCompositor(specifiedTiming(), *effect());
 }
 
 bool Animation::maybeStartAnimationOnCompositor(double startTime)
 {
@@ skipping 40 matching lines @@
 
 void Animation::pauseAnimationForTestingOnCompositor(double pauseTime)
 {
     ASSERT(hasActiveAnimationsOnCompositor());
     if (!m_target || !m_target->renderer())
         return;
     for (size_t i = 0; i < m_compositorAnimationIds.size(); ++i)
         CompositorAnimations::instance()->pauseAnimationForTestingOnCompositor(*m_target, m_compositorAnimationIds[i], pauseTime);
 }
 
+void Animation::trace(Visitor* visitor)
+{
+    visitor->trace(m_target);
+    visitor->trace(m_effect);
+    visitor->trace(m_sampledEffect);
+    TimedItem::trace(visitor);
+}
+
 } // namespace WebCore