src/third_party/WebKit/Source/core/animation/AnimationTimeline.cpp

   1 /*
   2  * Copyright (C) 2013 Google Inc. All rights reserved.
   3  *
   4  * Redistribution and use in source and binary forms, with or without
   5  * modification, are permitted provided that the following conditions are
   6  * met:
   7  *
   8  *     * Redistributions of source code must retain the above copyright
   9  * notice, this list of conditions and the following disclaimer.
  10  *     * Redistributions in binary form must reproduce the above
  11  * copyright notice, this list of conditions and the following disclaimer
  12  * in the documentation and/or other materials provided with the
  13  * distribution.
  14  *     * Neither the name of Google Inc. nor the names of its
  15  * contributors may be used to endorse or promote products derived from
  16  * this software without specific prior written permission.
  17  *
  18  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  19  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  20  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  21  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  22  * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  23  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  24  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  25  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  26  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  27  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  28  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  29  */
  30
  31 #include "config.h"
  32 #include "core/animation/AnimationTimeline.h"
  33
  34 #include "core/animation/ActiveAnimations.h"
  35 #include "core/animation/AnimationClock.h"
  36 #include "core/dom/Document.h"
  37 #include "core/frame/FrameView.h"
  38 #include "core/loader/DocumentLoader.h"
  39 #include "core/page/Page.h"
  40 #include "platform/TraceEvent.h"
  41
  42 namespace blink {
  43
  44 namespace {
  45
  46 bool compareAnimationPlayers(const RefPtrWillBeMember<blink::AnimationPlayer>& left, const RefPtrWillBeMember<blink::AnimationPlayer>& right)
  47 {
  48     return AnimationPlayer::hasLowerPriority(left.get(), right.get());
  49 }
  50
  51 }
  52
  53 // This value represents 1 frame at 30Hz plus a little bit of wiggle room.
  54 // TODO: Plumb a nominal framerate through and derive this value from that.
  55 const double AnimationTimeline::s_minimumDelay = 0.04;
  56
  57
  58 PassRefPtrWillBeRawPtr<AnimationTimeline> AnimationTimeline::create(Document* document, PassOwnPtrWillBeRawPtr<PlatformTiming> timing)
  59 {
  60     return adoptRefWillBeNoop(new AnimationTimeline(document, timing));
  61 }
  62
  63 AnimationTimeline::AnimationTimeline(Document* document, PassOwnPtrWillBeRawPtr<PlatformTiming> timing)
  64     : m_document(document)
  65     , m_zeroTime(0)
  66 {
  67     if (!timing)
  68         m_timing = adoptPtrWillBeNoop(new AnimationTimelineTiming(this));
  69     else
  70         m_timing = timing;
  71
  72     ASSERT(document);
  73 }
  74
  75 AnimationTimeline::~AnimationTimeline()
  76 {
  77 #if !ENABLE(OILPAN)
  78     for (WillBeHeapHashSet<RawPtrWillBeWeakMember<AnimationPlayer> >::iterator it = m_players.begin(); it != m_players.end(); ++it)
  79         (*it)->timelineDestroyed();
  80 #endif
  81 }
  82
  83 AnimationPlayer* AnimationTimeline::createAnimationPlayer(AnimationNode* child)
  84 {
  85     RefPtrWillBeRawPtr<AnimationPlayer> player = AnimationPlayer::create(m_document->contextDocument().get(), *this, child);
  86     AnimationPlayer* result = player.get();
  87     m_players.add(result);
  88     setOutdatedAnimationPlayer(result);
  89     return result;
  90 }
  91
  92 AnimationPlayer* AnimationTimeline::play(AnimationNode* child)
  93 {
  94     if (!m_document)
  95         return 0;
  96     AnimationPlayer* player = createAnimationPlayer(child);
  97     return player;
  98 }
  99
 100 WillBeHeapVector<RefPtrWillBeMember<AnimationPlayer> > AnimationTimeline::getAnimationPlayers()
 101 {
 102     WillBeHeapVector<RefPtrWillBeMember<AnimationPlayer> > animationPlayers;
 103     for (WillBeHeapHashSet<RawPtrWillBeWeakMember<AnimationPlayer> >::iterator it = m_players.begin(); it != m_players.end(); ++it) {
 104         if ((*it)->source() && (*it)->source()->isCurrent()) {
 105             animationPlayers.append(*it);
 106         }
 107     }
 108     std::sort(animationPlayers.begin(), animationPlayers.end(), compareAnimationPlayers);
 109     return animationPlayers;
 110 }
 111
 112 void AnimationTimeline::wake()
 113 {
 114     m_timing->serviceOnNextFrame();
 115 }
 116
 117 void AnimationTimeline::serviceAnimations(TimingUpdateReason reason)
 118 {
 119     TRACE_EVENT0("blink", "AnimationTimeline::serviceAnimations");
 120
 121     m_timing->cancelWake();
 122
 123     double timeToNextEffect = std::numeric_limits<double>::infinity();
 124
 125     WillBeHeapVector<RawPtrWillBeMember<AnimationPlayer> > players;
 126     players.reserveInitialCapacity(m_playersNeedingUpdate.size());
 127     for (WillBeHeapHashSet<RefPtrWillBeMember<AnimationPlayer> >::iterator it = m_playersNeedingUpdate.begin(); it != m_playersNeedingUpdate.end(); ++it)
 128         players.append(it->get());
 129
 130     std::sort(players.begin(), players.end(), AnimationPlayer::hasLowerPriority);
 131
 132     for (size_t i = 0; i < players.size(); ++i) {
 133         AnimationPlayer* player = players[i];
 134         if (player->update(reason))
 135             timeToNextEffect = std::min(timeToNextEffect, player->timeToEffectChange());
 136         else
 137             m_playersNeedingUpdate.remove(player);
 138     }
 139
 140     if (timeToNextEffect < s_minimumDelay)
 141         m_timing->serviceOnNextFrame();
 142     else if (timeToNextEffect != std::numeric_limits<double>::infinity())
 143         m_timing->wakeAfter(timeToNextEffect - s_minimumDelay);
 144
 145     ASSERT(!hasOutdatedAnimationPlayer());
 146 }
 147
 148 void AnimationTimeline::AnimationTimelineTiming::wakeAfter(double duration)
 149 {
 150     m_timer.startOneShot(duration, FROM_HERE);
 151 }
 152
 153 void AnimationTimeline::AnimationTimelineTiming::cancelWake()
 154 {
 155     m_timer.stop();
 156 }
 157
 158 void AnimationTimeline::AnimationTimelineTiming::serviceOnNextFrame()
 159 {
 160     if (m_timeline->m_document && m_timeline->m_document->view())
 161         m_timeline->m_document->view()->scheduleAnimation();
 162 }
 163
 164 void AnimationTimeline::AnimationTimelineTiming::trace(Visitor* visitor)
 165 {
 166     visitor->trace(m_timeline);
 167     AnimationTimeline::PlatformTiming::trace(visitor);
 168 }
 169
 170 double AnimationTimeline::zeroTime()
 171 {
 172     if (!m_zeroTime && m_document && m_document->loader()) {
 173         m_zeroTime = m_document->loader()->timing()->referenceMonotonicTime();
 174     }
 175     return m_zeroTime;
 176 }
 177
 178 double AnimationTimeline::currentTime(bool& isNull)
 179 {
 180     return currentTimeInternal(isNull) * 1000;
 181 }
 182
 183 double AnimationTimeline::currentTimeInternal(bool& isNull)
 184 {
 185     if (!m_document) {
 186         isNull = true;
 187         return std::numeric_limits<double>::quiet_NaN();
 188     }
 189     double result = m_document->animationClock().currentTime() - zeroTime();
 190     isNull = std::isnan(result);
 191     return result;
 192 }
 193
 194 double AnimationTimeline::currentTime()
 195 {
 196     return currentTimeInternal() * 1000;
 197 }
 198
 199 double AnimationTimeline::currentTimeInternal()
 200 {
 201     bool isNull;
 202     return currentTimeInternal(isNull);
 203 }
 204
 205 double AnimationTimeline::effectiveTime()
 206 {
 207     double time = currentTimeInternal();
 208     return std::isnan(time) ? 0 : time;
 209 }
 210
 211 void AnimationTimeline::pauseAnimationsForTesting(double pauseTime)
 212 {
 213     for (WillBeHeapHashSet<RefPtrWillBeMember<AnimationPlayer> >::iterator it = m_playersNeedingUpdate.begin(); it != m_playersNeedingUpdate.end(); ++it)
 214         (*it)->pauseForTesting(pauseTime);
 215     serviceAnimations(TimingUpdateOnDemand);
 216 }
 217
 218 bool AnimationTimeline::hasOutdatedAnimationPlayer() const
 219 {
 220     for (WillBeHeapHashSet<RefPtrWillBeMember<AnimationPlayer> >::iterator it = m_playersNeedingUpdate.begin(); it != m_playersNeedingUpdate.end(); ++it) {
 221         if ((*it)->outdated())
 222             return true;
 223     }
 224     return false;
 225 }
 226
 227 void AnimationTimeline::setOutdatedAnimationPlayer(AnimationPlayer* player)
 228 {
 229     ASSERT(player->outdated());
 230     m_playersNeedingUpdate.add(player);
 231     if (m_document && m_document->page() && !m_document->page()->animator().isServicingAnimations())
 232         m_timing->serviceOnNextFrame();
 233 }
 234
 235 #if !ENABLE(OILPAN)
 236 void AnimationTimeline::detachFromDocument()
 237 {
 238     // FIXME: AnimationTimeline should keep Document alive.
 239     m_document = nullptr;
 240 }
 241 #endif
 242
 243 void AnimationTimeline::trace(Visitor* visitor)
 244 {
 245 #if ENABLE(OILPAN)
 246     visitor->trace(m_document);
 247     visitor->trace(m_timing);
 248     visitor->trace(m_playersNeedingUpdate);
 249     visitor->trace(m_players);
 250 #endif
 251 }
 252
 253 } // namespace