Animations: Introduce compositor AnimationPlayer and AnimationTimeline.

Source/core/animation/AnimationPlayer.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 21 matching lines @@
 #include "core/animation/AnimationPlayer.h"
 
 #include "core/animation/Animation.h"
 #include "core/animation/AnimationTimeline.h"
 #include "core/dom/Document.h"
 #include "core/dom/ExceptionCode.h"
 #include "core/events/AnimationPlayerEvent.h"
 #include "core/frame/UseCounter.h"
 #include "core/inspector/InspectorInstrumentation.h"
 #include "core/inspector/InspectorTraceEvents.h"
+#include "platform/RuntimeEnabledFeatures.h"
 #include "platform/TraceEvent.h"
+#include "public/platform/Platform.h"
+#include "public/platform/WebCompositorAnimationPlayer.h"
+#include "public/platform/WebCompositorSupport.h"
 #include "wtf/MathExtras.h"
 
 namespace blink {
 
 namespace {
 
 static unsigned nextSequenceNumber()
 {
     static unsigned next = 0;
     return ++next;
 }
 
 }
 
 PassRefPtrWillBeRawPtr<AnimationPlayer> AnimationPlayer::create(AnimationNode* source, AnimationTimeline* timeline)
 {
     if (!timeline) {
         // FIXME: Support creating players without a timeline.
         return nullptr;
     }
 
     RefPtrWillBeRawPtr<AnimationPlayer> player = adoptRefWillBeNoop(new AnimationPlayer(timeline->document()->contextDocument().get(), *timeline, source));
     player->suspendIfNeeded();
 
     if (timeline) {
         timeline->playerAttached(*player);
+        player->attachCompositorTimeline();
     }
 
     return player.release();
 }
 
 AnimationPlayer::AnimationPlayer(ExecutionContext* executionContext, AnimationTimeline& timeline, AnimationNode* content)
     : ActiveDOMObject(executionContext)
     , m_playState(Idle)
     , m_playbackRate(1)
     , m_startTime(nullValue())
@@ skipping 22 matching lines @@
 }
 
 AnimationPlayer::~AnimationPlayer()
 {
 #if !ENABLE(OILPAN)
     if (m_content)
         m_content->detach();
     if (m_timeline)
         m_timeline->playerDestroyed(this);
 #endif
+
+    detachCompositedLayers();
+    destroyCompositorPlayer();
 }
 
 double AnimationPlayer::sourceEnd() const
 {
     return m_content ? m_content->endTimeInternal() : 0;
 }
 
 bool AnimationPlayer::limited(double currentTime) const
 {
     return (m_playbackRate < 0 && currentTime <= 0) || (m_playbackRate > 0 && currentTime >= sourceEnd());
@@ skipping 138 matching lines @@
 
     ASSERT(!m_compositorState || !std::isnan(m_compositorState->startTime));
 
     if (!shouldStart) {
         m_currentTimePending = false;
     }
 
     if (shouldStart) {
         m_compositorGroup = compositorGroup;
         if (startOnCompositor) {
+            if (isCandidateForAnimationOnCompositor()) {
+                createCompositorPlayer();

[dstockwell, 2015/03/31 02:13:01]

It now seems like createCompositorPlayer/attachCompositedLayers and
destroy/detach are always paired. Should we merge them?

[loyso (OOO), 2015/03/31 02:30:27]

Not always. AnimationPlayer::setSource uses attach/detach. Shouldn't we be able
to switch the source while compositor animation is running?

[loyso (OOO), 2015/04/01 00:14:26]

Done.

+                attachCompositedLayers();
+            }
+
             if (maybeStartAnimationOnCompositor())
                 m_compositorState = adoptPtr(new CompositorState(*this));
             else
                 cancelIncompatibleAnimationsOnCompositor();
         }
     }
 }
 
 void AnimationPlayer::postCommit(double timelineTime)
 {
@@ skipping 142 matching lines @@
 }
 
 void AnimationPlayer::setSource(AnimationNode* newSource)
 {
     if (m_content == newSource)
         return;
 
     PlayStateUpdateScope updateScope(*this, TimingUpdateOnDemand, SetCompositorPendingWithSourceChanged);
 
     double storedCurrentTime = currentTimeInternal();
-    if (m_content)
+    if (m_content) {
+        detachCompositedLayers();
         m_content->detach();
+    }
     m_content = newSource;
     if (newSource) {
         // FIXME: This logic needs to be updated once groups are implemented
         if (newSource->player()) {
             newSource->player()->cancel();
             newSource->player()->setSource(0);
         }
         newSource->attach(this);
+        attachCompositedLayers();

[dstockwell, 2015/03/31 02:13:01]

Shouldn't this be removed in favor of the call in preCommit?

[loyso (OOO), 2015/03/31 02:30:27]

It's related to the comment above. Don't we call setSource from javascript
'on-the-fly'?

[dstockwell, 2015/03/31 03:27:32]

Yes, but it can be called at any time, including before creation of layers. We
need to attachCompositedLayers in preCommit any time sourceChanged is true,
which will also include other cases like the target of an Animation changing.

[loyso (OOO), 2015/03/31 04:43:31]

Done.

         setOutdated();
     }
     setCurrentTimeInternal(storedCurrentTime, TimingUpdateOnDemand);
 }
 
 const char* AnimationPlayer::playStateString(AnimationPlayState playState)
 {
     switch (playState) {
     case Idle:
         return "idle";
@@ skipping 207 matching lines @@
     setCurrentTimeInternal(storedCurrentTime, TimingUpdateOnDemand);
 }
 
 void AnimationPlayer::setOutdated()
 {
     m_outdated = true;
     if (m_timeline)
         m_timeline->setOutdatedAnimationPlayer(this);
 }
 
-bool AnimationPlayer::canStartAnimationOnCompositor()
+bool AnimationPlayer::canStartAnimationOnCompositor() const
 {
     // FIXME: Timeline playback rates should be compositable
     if (m_playbackRate == 0 || (std::isinf(sourceEnd()) && m_playbackRate < 0) || (timeline() && timeline()->playbackRate() != 1))
         return false;
 
     return m_timeline && m_content && m_content->isAnimation() && playing();
 }
 
+bool AnimationPlayer::isCandidateForAnimationOnCompositor() const
+{
+    if (!canStartAnimationOnCompositor())
+        return false;
+
+    return toAnimation(m_content.get())->isCandidateForAnimationOnCompositor(m_playbackRate);
+}
+
 bool AnimationPlayer::maybeStartAnimationOnCompositor()
 {
     if (!canStartAnimationOnCompositor())
         return false;
 
     bool reversed = m_playbackRate < 0;
 
     double startTime = timeline()->zeroTime() + startTimeInternal();
     if (reversed) {
         startTime -= sourceEnd() / fabs(m_playbackRate);
     }
 
     double timeOffset = 0;
     if (std::isnan(startTime)) {
         timeOffset = reversed ? sourceEnd() - currentTimeInternal() : currentTimeInternal();
         timeOffset = timeOffset / fabs(m_playbackRate);
     }
     ASSERT(m_compositorGroup != 0);
     return toAnimation(m_content.get())->maybeStartAnimationOnCompositor(m_compositorGroup, startTime, timeOffset, m_playbackRate);
 }
 
 void AnimationPlayer::setCompositorPending(bool sourceChanged)
 {
     // FIXME: Animation could notify this directly?
     if (!hasActiveAnimationsOnCompositor()) {
+        detachCompositedLayers();
+        destroyCompositorPlayer();
         m_compositorState.release();
     }
     if (sourceChanged && m_compositorState) {
         m_compositorState->sourceChanged = true;
     }
     if (m_compositorPending || m_isPausedForTesting) {
         return;
     }
 
     if (sourceChanged || !m_compositorState
         || !playing() || m_compositorState->playbackRate != m_playbackRate
         || m_compositorState->startTime != m_startTime) {
         m_compositorPending = true;
         timeline()->document()->compositorPendingAnimations().add(this);
     }
 }
 
 void AnimationPlayer::cancelAnimationOnCompositor()
 {
     if (hasActiveAnimationsOnCompositor())
         toAnimation(m_content.get())->cancelAnimationOnCompositor();
+
+    detachCompositedLayers();
+    destroyCompositorPlayer();
 }
 
 void AnimationPlayer::restartAnimationOnCompositor()
 {
     if (hasActiveAnimationsOnCompositor())
         toAnimation(m_content.get())->restartAnimationOnCompositor();
 }
 
 void AnimationPlayer::cancelIncompatibleAnimationsOnCompositor()
 {
@@ skipping 82 matching lines @@
     ASSERT(!m_stateIsBeingUpdated);
     m_stateIsBeingUpdated = true;
 }
 
 void AnimationPlayer::endUpdatingState()
 {
     ASSERT(m_stateIsBeingUpdated);
     m_stateIsBeingUpdated = false;
 }
 
+void AnimationPlayer::createCompositorPlayer()
+{
+    if (RuntimeEnabledFeatures::compositorAnimationTimelinesEnabled() && !m_compositorPlayer && Platform::current()->compositorSupport()) {
+        m_compositorPlayer = adoptPtr(Platform::current()->compositorSupport()->createAnimationPlayer());
+        ASSERT(m_compositorPlayer);
+        m_compositorPlayer->setAnimationDelegate(this);
+        attachCompositorTimeline();
+    }
+}
+
+void AnimationPlayer::destroyCompositorPlayer()
+{
+    if (m_compositorPlayer) {
+        detachCompositorTimeline();
+        m_compositorPlayer->setAnimationDelegate(nullptr);
+    }
+    m_compositorPlayer.clear();
+}
+
+void AnimationPlayer::attachCompositorTimeline()
+{
+    if (m_compositorPlayer) {
+        WebCompositorAnimationTimeline* timeline = m_timeline ? m_timeline->compositorTimeline() : nullptr;
+        if (timeline)
+            timeline->playerAttached(*this);
+    }
+}
+
+void AnimationPlayer::detachCompositorTimeline()
+{
+    if (m_compositorPlayer) {
+        WebCompositorAnimationTimeline* timeline = m_timeline ? m_timeline->compositorTimeline() : nullptr;
+        if (timeline)
+            timeline->playerDestroyed(*this);
+    }
+}
+
+void AnimationPlayer::attachCompositedLayers()
+{
+    if (!RuntimeEnabledFeatures::compositorAnimationTimelinesEnabled() || !m_compositorPlayer)
+        return;
+
+    ASSERT(m_content);
+    ASSERT(m_content->isAnimation());
+    ASSERT(toAnimation(m_content.get())->canAttachCompositedLayers());
+
+    toAnimation(m_content.get())->attachCompositedLayers();
+}
+
+void AnimationPlayer::detachCompositedLayers()
+{
+    if (m_compositorPlayer && m_compositorPlayer->isLayerAttached())
+        m_compositorPlayer->detachLayer();
+}
+
+void AnimationPlayer::notifyAnimationStarted(double monotonicTime, int group)
+{
+    ASSERT(RuntimeEnabledFeatures::compositorAnimationTimelinesEnabled());
+    timeline()->document()->compositorPendingAnimations().notifyCompositorAnimationStarted(monotonicTime, group);
+}
+
 AnimationPlayer::PlayStateUpdateScope::PlayStateUpdateScope(AnimationPlayer& player, TimingUpdateReason reason, CompositorPendingChange compositorPendingChange)
     : m_player(player)
     , m_initialPlayState(m_player->playStateInternal())
     , m_compositorPendingChange(compositorPendingChange)
 {
     m_player->beginUpdatingState();
     m_player->updateCurrentTimingState(reason);
 }
 
 AnimationPlayer::PlayStateUpdateScope::~PlayStateUpdateScope()
@@ skipping 93 matching lines @@
     visitor->trace(m_content);
     visitor->trace(m_timeline);
     visitor->trace(m_pendingFinishedEvent);
     visitor->trace(m_finishedPromise);
     visitor->trace(m_readyPromise);
     EventTargetWithInlineData::trace(visitor);
     ActiveDOMObject::trace(visitor);
 }
 
 } // namespace