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())
     , m_holdTime(0)
     , m_sequenceNumber(nextSequenceNumber())
     , m_content(content)
     , m_timeline(&timeline)
     , m_paused(false)
     , m_held(true)
     , m_isPausedForTesting(false)
     , m_outdated(false)
     , m_finished(true)
     , m_compositorState(nullptr)
     , m_compositorPending(false)
     , m_compositorGroup(0)
+    , m_attachCompositedLayers(false)
     , m_currentTimePending(false)
     , m_stateIsBeingUpdated(false)
 {
     if (m_content) {
         if (m_content->player()) {
             m_content->player()->cancel();
             m_content->player()->setSource(0);
         }
         m_content->attach(this);
     }
 }
 
 AnimationPlayer::~AnimationPlayer()
 {
 #if !ENABLE(OILPAN)
-    if (m_content)
+    if (m_content) {
+        detachCompositedLayers();
         m_content->detach();
+    }
     if (m_timeline)
         m_timeline->playerDestroyed(this);
 #endif
+
+    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 142 matching lines @@
 
     ASSERT(!m_compositorState || !std::isnan(m_compositorState->startTime));
 
     if (!shouldStart) {
         m_currentTimePending = false;
     }
 
     if (shouldStart) {
         m_compositorGroup = compositorGroup;
         if (startOnCompositor) {
+            if (isCandidateForAnimationOnCompositor()) {

[loyso (OOO), 2015/03/24 06:30:15]

Do we need to delete it on cancellation? I'm afraid of frequent reallocations.

[dstockwell, 2015/03/26 03:04:39]

I think we should. We can revisit if necessary. I don't think this is a common
case, starting new players should happen far more often than replaying existing
players.

[loyso (OOO), 2015/03/26 23:36:13]

Acknowledged.

+                createCompositorPlayer();
+                attachCompositedLayers();
+            }
+
             if (maybeStartAnimationOnCompositor())
                 m_compositorState = adoptPtr(new CompositorState(*this));
             else
                 cancelIncompatibleAnimationsOnCompositor();
         }
     }
 }
 
 void AnimationPlayer::postCommit(double timelineTime)
 {
@@ skipping 143 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/26 03:04:39]

Is this really the correct time to do this? Compositing information is not up to
date until precommit.

[loyso (OOO), 2015/03/26 23:36:14]

If compositing information isn't ready, the m_attachCompositedLayers flag stays
switched on. Which is basically a deferred command "attach composited layers".
It needs a better name, really. How about m_needsCompositedLayersAttachment?

         setOutdated();
     }
     setCurrentTimeInternal(storedCurrentTime, TimingUpdateOnDemand);
 }
 
 const char* AnimationPlayer::playStateString(AnimationPlayState playState)
 {
     switch (playState) {
     case Idle:
         return "idle";
@@ skipping 206 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);
@@ skipping 132 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()
+{
+    m_attachCompositedLayers = true;

[dstockwell, 2015/03/26 03:04:39]

m_compositedLayersAttached

[loyso (OOO), 2015/03/26 23:36:14]

It's a command, or 'dirty' flag. Not a sign that event happened. See those extra
2 comments around.

[dstockwell, 2015/03/27 00:27:22]

It seems wrong that this method is called attachCompositedLayers, but it does
may not actually attach the layers. Perhaps, setNeedsCompositeLayerAttachment

[loyso (OOO), 2015/03/30 02:47:19]

UPDATE: Simplified it so not applicable.

+    updateCompositedLayersAttachment();

[dstockwell, 2015/03/27 00:27:22]

So, why do we need to attempt do the attachment at this point? Why not wait
until after the compositing update in preCommit?

[loyso (OOO), 2015/03/27 01:02:42]

Preface: we had to attach the layer too early in a previous patch-set.

We may want to attach layer in two scenarios:
1) when compositing information isn't available yet, so we want it ot be
attached ASAP (on next preCommit)
2) when compositing information is in place and we are allowed to query it.

If we make it always deferred (case 1) it may complicate some sub-systems and
make attachments/additions of animations scattered across the time and code. I
need to migrate a couple of blink subsystems (LinkHighlight and
ProgrammaticScrollAnimator).

I could make these scenarios explicit with two functions.
Or we could go with always async way (attach on next preCommit).

+}
+
+void AnimationPlayer::detachCompositedLayers()
+{
+    m_attachCompositedLayers = false;
+    if (m_compositorPlayer && m_compositorPlayer->isLayerAttached())
+        m_compositorPlayer->detachLayer();
+}
+
+void AnimationPlayer::updateCompositedLayersAttachment()
+{
+    if (!RuntimeEnabledFeatures::compositorAnimationTimelinesEnabled() || !m_attachCompositedLayers)
+        return;
+    if (!m_compositorPlayer || !m_content || !m_content->isAnimation() || !toAnimation(m_content.get())->canAttachCompositedLayers())
+        return;
+
+    m_attachCompositedLayers = false;
+    toAnimation(m_content.get())->attachCompositedLayers();
+}
+
+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