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

Source/core/animation/DocumentTimeline.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 27 matching lines @@
 #include "core/page/Page.h"
 #include "platform/TraceEvent.h"
 
 namespace WebCore {
 
 // This value represents 1 frame at 30Hz plus a little bit of wiggle room.
 // TODO: Plumb a nominal framerate through and derive this value from that.
 const double DocumentTimeline::s_minimumDelay = 0.04;
 
 
-PassRefPtr<DocumentTimeline> DocumentTimeline::create(Document* document, PassOwnPtr<PlatformTiming> timing)
+PassRefPtrWillBeRawPtr<DocumentTimeline> DocumentTimeline::create(Document* document, PassOwnPtrWillBeRawPtr<PlatformTiming> timing)
 {
-    return adoptRef(new DocumentTimeline(document, timing));
+    return adoptRefWillBeNoop(new DocumentTimeline(document, timing));
 }
 
-DocumentTimeline::DocumentTimeline(Document* document, PassOwnPtr<PlatformTiming> timing)
+DocumentTimeline::DocumentTimeline(Document* document, PassOwnPtrWillBeRawPtr<PlatformTiming> timing)
     : m_zeroTime(nullValue())
     , m_document(document)
 {
     if (!timing)
-        m_timing = adoptPtr(new DocumentTimelineTiming(this));
+        m_timing = adoptPtrWillBeNoop(new DocumentTimelineTiming(this));
     else
         m_timing = timing;
 
     ASSERT(document);
 }
 
 DocumentTimeline::~DocumentTimeline()
 {
-    for (HashSet<AnimationPlayer*>::iterator it = m_players.begin(); it != m_players.end(); ++it)
+#if !ENABLE(OILPAN)
+    for (WillBeHeapHashSet<RawPtrWillBeWeakMember<AnimationPlayer> >::iterator it = m_players.begin(); it != m_players.end(); ++it)
         (*it)->timelineDestroyed();
+#endif
 }
 
 AnimationPlayer* DocumentTimeline::createAnimationPlayer(TimedItem* child)
 {
-    RefPtr<AnimationPlayer> player = AnimationPlayer::create(*this, child);
+    RefPtrWillBeRawPtr<AnimationPlayer> player = AnimationPlayer::create(*this, child);
     AnimationPlayer* result = player.get();
     m_players.add(result);
     setOutdatedAnimationPlayer(result);
     return result;
 }
 
 AnimationPlayer* DocumentTimeline::play(TimedItem* child)
 {
     if (!m_document)
         return 0;
     AnimationPlayer* player = createAnimationPlayer(child);
     player->setStartTimeInternal(effectiveTime());
     m_document->compositorPendingAnimations().add(player);
     return player;
 }
 
 void DocumentTimeline::wake()
 {
     m_timing->serviceOnNextFrame();
 }
 
 void DocumentTimeline::serviceAnimations(TimingUpdateReason reason)
 {
     TRACE_EVENT0("webkit", "DocumentTimeline::serviceAnimations");
 
     m_timing->cancelWake();
 
     double timeToNextEffect = std::numeric_limits<double>::infinity();
-    Vector<AnimationPlayer*> players;
-    for (HashSet<RefPtr<AnimationPlayer> >::iterator it = m_playersNeedingUpdate.begin(); it != m_playersNeedingUpdate.end(); ++it)
+    WillBeHeapVector<RawPtrWillBeMember<AnimationPlayer> > players;
+    for (WillBeHeapHashSet<RefPtrWillBeMember<AnimationPlayer> >::iterator it = m_playersNeedingUpdate.begin(); it != m_playersNeedingUpdate.end(); ++it)
         players.append(it->get());
 
     std::sort(players.begin(), players.end(), AnimationPlayer::hasLowerPriority);
 
     for (size_t i = 0; i < players.size(); ++i) {
         AnimationPlayer* player = players[i];
         if (player->update(reason))
             timeToNextEffect = std::min(timeToNextEffect, player->timeToEffectChange());
         else
             m_playersNeedingUpdate.remove(player);
@@ skipping 24 matching lines @@
 {
     m_timer.stop();
 }
 
 void DocumentTimeline::DocumentTimelineTiming::serviceOnNextFrame()
 {
     if (m_timeline->m_document && m_timeline->m_document->view())
         m_timeline->m_document->view()->scheduleAnimation();
 }
 
+void DocumentTimeline::DocumentTimelineTiming::trace(Visitor* visitor)
+{
+    visitor->trace(m_timeline);
+    DocumentTimeline::PlatformTiming::trace(visitor);
+}
+
 double DocumentTimeline::currentTime(bool& isNull)
 {
     return currentTimeInternal(isNull) * 1000;
 }
 
 double DocumentTimeline::currentTimeInternal(bool& isNull)
 {
     if (!m_document) {
         isNull = true;
         return std::numeric_limits<double>::quiet_NaN();
@@ skipping 15 matching lines @@
 }
 
 double DocumentTimeline::effectiveTime()
 {
     double time = currentTimeInternal();
     return std::isnan(time) ? 0 : time;
 }
 
 void DocumentTimeline::pauseAnimationsForTesting(double pauseTime)
 {
-    for (HashSet<RefPtr<AnimationPlayer> >::iterator it = m_playersNeedingUpdate.begin(); it != m_playersNeedingUpdate.end(); ++it)
+    for (WillBeHeapHashSet<RefPtrWillBeMember<AnimationPlayer> >::iterator it = m_playersNeedingUpdate.begin(); it != m_playersNeedingUpdate.end(); ++it)
         (*it)->pauseForTesting(pauseTime);
     serviceAnimations(TimingUpdateOnDemand);
 }
 
 bool DocumentTimeline::hasOutdatedAnimationPlayer() const
 {
-    for (HashSet<RefPtr<AnimationPlayer> >::iterator it = m_playersNeedingUpdate.begin(); it != m_playersNeedingUpdate.end(); ++it) {
+    for (WillBeHeapHashSet<RefPtrWillBeMember<AnimationPlayer> >::iterator it = m_playersNeedingUpdate.begin(); it != m_playersNeedingUpdate.end(); ++it) {
         if ((*it)->outdated())
             return true;
     }
     return false;
 }
 
 void DocumentTimeline::setOutdatedAnimationPlayer(AnimationPlayer* player)
 {
     ASSERT(player->outdated());
     m_playersNeedingUpdate.add(player);
     if (m_document && m_document->page() && !m_document->page()->animator().isServicingAnimations())
         m_timing->serviceOnNextFrame();
 }
 
 size_t DocumentTimeline::numberOfActiveAnimationsForTesting() const
 {
     // Includes all players whose directly associated timed items
     // are current or in effect.
     if (isNull(m_zeroTime))
         return 0;
     size_t count = 0;
-    for (HashSet<RefPtr<AnimationPlayer> >::iterator it = m_playersNeedingUpdate.begin(); it != m_playersNeedingUpdate.end(); ++it) {
+    for (WillBeHeapHashSet<RefPtrWillBeMember<AnimationPlayer> >::iterator it = m_playersNeedingUpdate.begin(); it != m_playersNeedingUpdate.end(); ++it) {
         const TimedItem* timedItem = (*it)->source();
         if ((*it)->hasStartTime())
             count += (timedItem && (timedItem->isCurrent() || timedItem->isInEffect()));
     }
     return count;
 }
 
-void DocumentTimeline::detachFromDocument() {
+#if !ENABLE(OILPAN)
+void DocumentTimeline::detachFromDocument()
+{
     // FIXME: DocumentTimeline should keep Document alive.
-    m_document = 0;
+    m_document = nullptr;
+}
+#endif
+
+void DocumentTimeline::trace(Visitor* visitor)
+{
+    visitor->trace(m_document);
+    visitor->trace(m_timing);
+    visitor->trace(m_playersNeedingUpdate);
+    visitor->trace(m_players);
 }
 
 } // namespace