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 (const auto& player : m_players)
  79         player->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 nullptr;
  96     AnimationPlayer* player = createAnimationPlayer(child);
  97     return player;
  98 }
  99
 100 WillBeHeapVector<RefPtrWillBeMember<AnimationPlayer>> AnimationTimeline::getAnimationPlayers()
 101 {
 102     WillBeHeapVector<RefPtrWillBeMember<AnimationPlayer>> animationPlayers;
 103     for (const auto& player : m_players) {
 104         if (player->source() && player->source()->isCurrent())
 105             animationPlayers.append(player);
 106     }
 107     std::sort(animationPlayers.begin(), animationPlayers.end(), compareAnimationPlayers);
 108     return animationPlayers;
 109 }
 110
 111 void AnimationTimeline::wake()
 112 {
 113     m_timing->serviceOnNextFrame();
 114 }
 115
 116 void AnimationTimeline::serviceAnimations(TimingUpdateReason reason)
 117 {
 118     TRACE_EVENT0("blink", "AnimationTimeline::serviceAnimations");
 119
 120     m_timing->cancelWake();
 121
 122     double timeToNextEffect = std::numeric_limits<double>::infinity();
 123
 124     WillBeHeapVector<RawPtrWillBeMember<AnimationPlayer>> players;
 125     players.reserveInitialCapacity(m_playersNeedingUpdate.size());
 126     for (RefPtrWillBeMember<AnimationPlayer> player : m_playersNeedingUpdate)
 127         players.append(player.get());
 128
 129     std::sort(players.begin(), players.end(), AnimationPlayer::hasLowerPriority);
 130
 131     for (AnimationPlayer* player : players) {
 132         if (player->update(reason))
 133             timeToNextEffect = std::min(timeToNextEffect, player->timeToEffectChange());
 134         else
 135             m_playersNeedingUpdate.remove(player);
 136     }
 137
 138     if (timeToNextEffect < s_minimumDelay)
 139         m_timing->serviceOnNextFrame();
 140     else if (timeToNextEffect != std::numeric_limits<double>::infinity())
 141         m_timing->wakeAfter(timeToNextEffect - s_minimumDelay);
 142
 143     ASSERT(!hasOutdatedAnimationPlayer());
 144 }
 145
 146 void AnimationTimeline::AnimationTimelineTiming::wakeAfter(double duration)
 147 {
 148     m_timer.startOneShot(duration, FROM_HERE);
 149 }
 150
 151 void AnimationTimeline::AnimationTimelineTiming::cancelWake()
 152 {
 153     m_timer.stop();
 154 }
 155
 156 void AnimationTimeline::AnimationTimelineTiming::serviceOnNextFrame()
 157 {
 158     if (m_timeline->m_document && m_timeline->m_document->view())
 159         m_timeline->m_document->view()->scheduleAnimation();
 160 }
 161
 162 void AnimationTimeline::AnimationTimelineTiming::trace(Visitor* visitor)
 163 {
 164     visitor->trace(m_timeline);
 165     AnimationTimeline::PlatformTiming::trace(visitor);
 166 }
 167
 168 double AnimationTimeline::zeroTime()
 169 {
 170     if (!m_zeroTime && m_document && m_document->loader()) {
 171         m_zeroTime = m_document->loader()->timing()->referenceMonotonicTime();
 172     }
 173     return m_zeroTime;
 174 }
 175
 176 double AnimationTimeline::currentTime(bool& isNull)
 177 {
 178     return currentTimeInternal(isNull) * 1000;
 179 }
 180
 181 double AnimationTimeline::currentTimeInternal(bool& isNull)
 182 {
 183     if (!m_document) {
 184         isNull = true;
 185         return std::numeric_limits<double>::quiet_NaN();
 186     }
 187     double result = m_document->animationClock().currentTime() - zeroTime();
 188     isNull = std::isnan(result);
 189     return result;
 190 }
 191
 192 double AnimationTimeline::currentTime()
 193 {
 194     return currentTimeInternal() * 1000;
 195 }
 196
 197 double AnimationTimeline::currentTimeInternal()
 198 {
 199     bool isNull;
 200     return currentTimeInternal(isNull);
 201 }
 202
 203 double AnimationTimeline::effectiveTime()
 204 {
 205     double time = currentTimeInternal();
 206     return std::isnan(time) ? 0 : time;
 207 }
 208
 209 void AnimationTimeline::pauseAnimationsForTesting(double pauseTime)
 210 {
 211     for (const auto& player : m_playersNeedingUpdate)
 212         player->pauseForTesting(pauseTime);
 213     serviceAnimations(TimingUpdateOnDemand);
 214 }
 215
 216 bool AnimationTimeline::hasOutdatedAnimationPlayer() const
 217 {
 218     for (const auto& player : m_playersNeedingUpdate) {
 219         if (player->outdated())
 220             return true;
 221     }
 222     return false;
 223 }
 224
 225 void AnimationTimeline::setOutdatedAnimationPlayer(AnimationPlayer* player)
 226 {
 227     ASSERT(player->outdated());
 228     m_playersNeedingUpdate.add(player);
 229     if (m_document && m_document->page() && !m_document->page()->animator().isServicingAnimations())
 230         m_timing->serviceOnNextFrame();
 231 }
 232
 233 #if !ENABLE(OILPAN)
 234 void AnimationTimeline::detachFromDocument()
 235 {
 236     // FIXME: AnimationTimeline should keep Document alive.
 237     m_document = nullptr;
 238 }
 239 #endif
 240
 241 void AnimationTimeline::trace(Visitor* visitor)
 242 {
 243 #if ENABLE(OILPAN)
 244     visitor->trace(m_document);
 245     visitor->trace(m_timing);
 246     visitor->trace(m_playersNeedingUpdate);
 247     visitor->trace(m_players);
 248 #endif
 249 }
 250
 251 } // namespace