ChangeLog

2020-04-22  Antoine Quint  <graouts@apple.com>

        [Web Animations] Coordinate "update animations and send events" procedure across multiple timelines

        https://bugs.webkit.org/show_bug.cgi?id=202109

        <rdar://problem/59470821>

        Reviewed by NOBODY (OOPS!).

        So far, although we did manage multiple animation timelines per document, we mostly operated under the assumption that there really was a single timeline.

        In this patch we make the "update animations and send events" procedure, which is central to the lifecycle of animations, work with multiple timelines such

        that a single microtask checkpoint is performed even with multiple timelines, whereas we would perform one per timeline before. To do this, we move much of

        the logic DocumentTimeline::updateAnimationsAndSendEvents() to DocumentTimelinesController where each step is run across each timeline, rather than running

        all steps for each timeline one after the other, respecting the single microtask checkpoint in the middle of the process.

        To minimize code churn at this stage, we still keep a fair bit of logic in DocumentTimeline and, while we remove updateAnimationsAndSendEvents(),

        internalUpdateAnimationsAndSendEvents() and updateCurrentTime(), we expose three methods that allow to run the pre-flight sequence in

        documentWillUpdateAnimationsAndSendEvents(), collect pending events in prepareForPendingAnimationEventsDispatch() and run the post-flight sequence

        in documentDidUpdateAnimationsAndSendEvents().

        None of the logic changes, this is just moving code around. In the future, more patches will move code from DocumentTimeline up to DocumentTimelinesController

        such that events are enqueued there, and animation scheduling as well. But this already lets us pass a new test that used to flakily reject promises in the WPT

        test web-animations/timing-model/timelines/update-and-send-events.html.

        * animation/AnimationTimeline.h:

        (WebCore::AnimationTimeline::relevantAnimations const):

        (WebCore::AnimationTimeline::allAnimations const):

        * animation/DocumentTimeline.cpp:

        (WebCore::DocumentTimeline::documentWillUpdateAnimationsAndSendEvents):

        (WebCore::DocumentTimeline::documentDidUpdateAnimationsAndSendEvents):

        (WebCore::DocumentTimeline::prepareForPendingAnimationEventsDispatch):

        (WebCore::DocumentTimeline::updateCurrentTime): Deleted.

        (WebCore::DocumentTimeline::updateAnimationsAndSendEvents): Deleted.

        (WebCore::DocumentTimeline::internalUpdateAnimationsAndSendEvents): Deleted.

        * animation/DocumentTimeline.h:

        * animation/DocumentTimelinesController.cpp:

        (WebCore::DocumentTimelinesController::DocumentTimelinesController):

        (WebCore::DocumentTimelinesController::updateAnimationsAndSendEvents):

        * animation/DocumentTimelinesController.h:

        * animation/WebAnimationTypes.h:

        * dom/Document.cpp:

        (WebCore::Document::ensureTimelinesController):

2020-04-21  Antoine Quint  <graouts@apple.com>

        [Web Animations] Add a supporting object for Document to manage timelines

Source/WebCore/animation/AnimationTimeline.h

@@class AnimationTimeline : public RefCounted<AnimationTimeline>, public CanMakeWe

public:

    virtual bool isDocumentTimeline() const { return false; }

    AnimationCollection relevantAnimations() const { return m_animations; }

    Vector<WeakPtr<WebAnimation>> allAnimations() const { return m_allAnimations; }

    void forgetAnimation(WebAnimation*);

    virtual void animationTimingDidChange(WebAnimation&);

    virtual void removeAnimation(WebAnimation&);

Source/WebCore/animation/DocumentTimeline.cpp

#include "DeclarativeAnimation.h"

#include "Document.h"

#include "DocumentTimelinesController.h"

36 #include "EventLoop.h"

#include "EventNames.h"

#include "GraphicsLayer.h"

#include "KeyframeEffect.h"

@@bool DocumentTimeline::shouldRunUpdateAnimationsAndSendEventsIgnoringSuspensionS

    return !m_animations.isEmpty() || !m_pendingAnimationEvents.isEmpty() || !m_acceleratedAnimationsPendingRunningStateChange.isEmpty();

}

365 ~~void~~ DocumentTimeline::update~~Curr~~ent~~Time~~(DOMHighResTimeStamp timestamp)

364DocumentTimeline::ShouldUpdateAnimationsAndSendEvents DocumentTimeline::documentWillUpdateAnimationsAndSendEvents(DOMHighResTimeStamp timestamp)

{

    // We need to freeze the current time even if no animation is running.

    // document.timeline.currentTime may be called from a rAF callback and

    // it has to match the rAF timestamp.

    if (!m_isSuspended || !shouldRunUpdateAnimationsAndSendEventsIgnoringSuspensionState())

        cacheCurrentTime(timestamp);

372 }

373371

374 void DocumentTimeline::updateAnimationsAndSendEvents()

375 {

376372 // Updating animations and sending events may invalidate the timing of some animations, so we must set the m_animationResolutionScheduled

377373 // flag to false prior to running that procedure to allow animation with timing model updates to schedule updates.

    m_animationResolutionScheduled = false;

    if (m_isSuspended)

        return;

    if (!shouldRunUpdateAnimationsAndSendEventsIgnoringSuspensionState())

        return;

    internalUpdateAnimationsAndSendEvents();

    applyPendingAcceleratedAnimations();

374 bool wasAnimationResolutionScheduled = std::exchange(m_animationResolutionScheduled, false);

388375

    if (!m_animationResolutionScheduled)

        scheduleNextTick();

}

376 if (!wasAnimationResolutionScheduled || m_isSuspended || !shouldRunUpdateAnimationsAndSendEventsIgnoringSuspensionState())

377 return DocumentTimeline::ShouldUpdateAnimationsAndSendEvents::No;

392378

393 void DocumentTimeline::internalUpdateAnimationsAndSendEvents()

394 {

    m_numberOfAnimationTimelineInvalidationsForTesting++;

    // enqueueAnimationEvent() calls scheduleAnimationResolution() to ensure that the "update animations and send events"

@@void DocumentTimeline::internalUpdateAnimationsAndSendEvents()

    // this procedure is running should not schedule animation resolution until the event queue has been cleared.

    m_shouldScheduleAnimationResolutionForNewPendingEvents = false;

    // https://drafts.csswg.org/web-animations/#update-animations-and-send-events

    // 1. Update the current time of all timelines associated with doc passing now as the timestamp.

    Vector<RefPtr<WebAnimation>> animationsToRemove;

    Vector<RefPtr<CSSTransition>> completedTransitions;

    for (auto& animation : m_animations) {

        if (animation->timeline() != this) {

            ASSERT(!animation->timeline());

            animationsToRemove.append(animation);

            continue;

        }

        // This will notify the animation that timing has changed and will call automatically

        // schedule invalidation if required for this animation.

        animation->tick();

        if (!animation->isRelevant() && !animation->needsTick())

            animationsToRemove.append(animation);

        if (!animation->needsTick() && is<CSSTransition>(animation) && animation->playState() == WebAnimation::PlayState::Finished) {

            auto* transition = downcast<CSSTransition>(animation.get());

            if (transition->owningElement())

                completedTransitions.append(transition);

        }

    }

    // 2. Remove replaced animations for doc.

    removeReplacedAnimations();

    // 3. Perform a microtask checkpoint.

    if (auto document = makeRefPtr(this->document()))

        document->eventLoop().performMicrotaskCheckpoint();

    // 4. Let events to dispatch be a copy of doc's pending animation event queue.

    // 5. Clear doc's pending animation event queue.

    auto pendingAnimationEvents = WTFMove(m_pendingAnimationEvents);

    m_shouldScheduleAnimationResolutionForNewPendingEvents = true;

    // 6. Perform a stable sort of the animation events in events to dispatch as follows.

    std::stable_sort(pendingAnimationEvents.begin(), pendingAnimationEvents.end(), [] (const Ref<AnimationEventBase>& lhs, const Ref<AnimationEventBase>& rhs) {

        // 1. Sort the events by their scheduled event time such that events that were scheduled to occur earlier, sort before events scheduled to occur later

        // and events whose scheduled event time is unresolved sort before events with a resolved scheduled event time.

        // 2. Within events with equal scheduled event times, sort by their composite order. FIXME: We don't do this.

        if (lhs->timelineTime() && !rhs->timelineTime())

            return false;

        if (!lhs->timelineTime() && rhs->timelineTime())

            return true;

        if (!lhs->timelineTime() && !rhs->timelineTime())

            return true;

        return lhs->timelineTime().value() < rhs->timelineTime().value();

    });

    // 7. Dispatch each of the events in events to dispatch at their corresponding target using the order established in the previous step.

    for (auto& pendingAnimationEvent : pendingAnimationEvents)

        pendingAnimationEvent->target()->dispatchEvent(pendingAnimationEvent);

386 return DocumentTimeline::ShouldUpdateAnimationsAndSendEvents::Yes;

387}

459388

    // This will cancel any scheduled invalidation if we end up removing all animations.

    for (auto& animation : animationsToRemove) {

        // An animation that was initially marked as irrelevant may have changed while we were sending events, so we run the same

        // check that we ran to add it to animationsToRemove in the first place.

        if (!animation->isRelevant() && !animation->needsTick())

            removeAnimation(*animation);

    }

void DocumentTimeline::documentDidUpdateAnimationsAndSendEvents()

{

    applyPendingAcceleratedAnimations();

467392

    // Now that animations that needed removal have been removed, let's update the list of completed transitions.

    // This needs to happen after dealing with the list of animations to remove as the animation may have been

    // removed from the list of completed transitions otherwise.

    for (auto& completedTransition : completedTransitions)

        transitionDidComplete(completedTransition);

393 if (!m_animationResolutionScheduled)

394 scheduleNextTick();

}

bool DocumentTimeline::animationCanBeRemoved(WebAnimation& animation)

@@void DocumentTimeline::enqueueAnimationEvent(AnimationEventBase& event)

        scheduleAnimationResolution();

}

AnimationEvents DocumentTimeline::prepareForPendingAnimationEventsDispatch()

{

    m_shouldScheduleAnimationResolutionForNewPendingEvents = true;

    return std::exchange(m_pendingAnimationEvents, { });

}

Vector<std::pair<String, double>> DocumentTimeline::acceleratedAnimationsForElement(Element& element) const

{

    auto* renderer = element.renderer();

Source/WebCore/animation/DocumentTimeline.h

@@public:

    void removeAnimation(WebAnimation&) override;

    void animationWasAddedToElement(WebAnimation&, Element&) final;

    void animationWasRemovedFromElement(WebAnimation&, Element&) final;

61 void transitionDidComplete(RefPtr<CSSTransition>);

    // If possible, compute the visual extent of any transform animation on the given renderer

    // using the given rect, returning the result in the rect. Return false if there is some

@@public:

    void enqueueAnimationEvent(AnimationEventBase&);

    

    bool scheduledUpdate() const { return m_animationResolutionScheduled; }

    void updateCurrentTime(DOMHighResTimeStamp timestamp);

    void updateAnimationsAndSendEvents();

    enum class ShouldUpdateAnimationsAndSendEvents : uint8_t { Yes, No };

    ShouldUpdateAnimationsAndSendEvents documentWillUpdateAnimationsAndSendEvents(DOMHighResTimeStamp);

    void removeReplacedAnimations();

    AnimationEvents prepareForPendingAnimationEventsDispatch();

    void documentDidUpdateAnimationsAndSendEvents();

    void updateThrottlingState();

    WEBCORE_EXPORT Seconds animationInterval() const;

@@private:

    void clearTickScheduleTimer();

    void internalUpdateAnimationsAndSendEvents();

    void updateListOfElementsWithRunningAcceleratedAnimationsForElement(Element&);

101 void transitionDidComplete(RefPtr<CSSTransition>);

102104 void scheduleNextTick();

103 void removeReplacedAnimations();

    bool animationCanBeRemoved(WebAnimation&);

    bool shouldRunUpdateAnimationsAndSendEventsIgnoringSuspensionState() const;

@@private:

    GenericTaskQueue<Timer> m_currentTimeClearingTaskQueue;

    HashSet<RefPtr<WebAnimation>> m_acceleratedAnimationsPendingRunningStateChange;

    HashSet<Element*> m_elementsWithRunningAcceleratedAnimations;

111 ~~Vector<Ref<~~AnimationEventBa~~se>>~~ m_pendingAnimationEvents;

112 AnimationEvents m_pendingAnimationEvents;

    WeakPtr<Document> m_document;

    Markable<Seconds, Seconds::MarkableTraits> m_cachedCurrentTime;

    Seconds m_originTime;

Source/WebCore/animation/DocumentTimelinesController.cpp

#include "config.h"

#include "DocumentTimelinesController.h"

#include "AnimationEventBase.h"

#include "CSSTransition.h"

#include "Document.h"

2932#include "DocumentTimeline.h"

#include "EventLoop.h"

#include "WebAnimation.h"

#include "WebAnimationTypes.h"

namespace WebCore {

33 DocumentTimelinesController::DocumentTimelinesController()

39DocumentTimelinesController::DocumentTimelinesController(Document& document)

40 : m_document(document)

{

}

@@void DocumentTimelinesController::updateAnimationsAndSendEvents(DOMHighResTimeSt

{

    ASSERT(!m_timelines.hasNullReferences());

    // We need to copy m_timelines before iterating over its members since calling updateAnimationsAndSendEvents() may mutate m_timelines.

    Vector<RefPtr<DocumentTimeline>> timelines;

    bool shouldUpdateAnimations = false;

    for (auto& timeline : m_timelines) {

        if (timeline.scheduledUpdate())

            shouldUpdateAnimations = true;

        timelines.append(&timeline);

    // We need to copy m_timelines before iterating over its members since the steps in this procedure may mutate m_timelines.

    Vector<RefPtr<DocumentTimeline>> protectedTimelines;

    for (auto& timeline : m_timelines)

        protectedTimelines.append(&timeline);

    // 1. Update the current time of all timelines associated with doc passing now as the timestamp.

    Vector<DocumentTimeline*> timelinesToUpdate;

    Vector<RefPtr<WebAnimation>> animationsToRemove;

    Vector<RefPtr<CSSTransition>> completedTransitions;

    for (auto& timeline : protectedTimelines) {

        auto shouldUpdateAnimationsAndSendEvents = timeline->documentWillUpdateAnimationsAndSendEvents(timestamp);

        if (shouldUpdateAnimationsAndSendEvents == DocumentTimeline::ShouldUpdateAnimationsAndSendEvents::No)

            continue;

        timelinesToUpdate.append(timeline.get());

        for (auto& animation : timeline->relevantAnimations()) {

            if (animation->timeline() != timeline.get()) {

                ASSERT(!animation->timeline());

                animationsToRemove.append(animation);

                continue;

            }

            // This will notify the animation that timing has changed and will call automatically

            // schedule invalidation if required for this animation.

            animation->tick();

            if (!animation->isRelevant() && !animation->needsTick())

                animationsToRemove.append(animation);

            if (!animation->needsTick() && is<CSSTransition>(animation) && animation->playState() == WebAnimation::PlayState::Finished) {

                auto* transition = downcast<CSSTransition>(animation.get());

                if (transition->owningElement())

                    completedTransitions.append(transition);

            }

        }

68104 }

69105

    for (auto& timeline : timelines) {

        timeline->updateCurrentTime(timestamp);

        if (shouldUpdateAnimations)

            timeline->updateAnimationsAndSendEvents();

    if (timelinesToUpdate.isEmpty())

        return;

    // 2. Remove replaced animations for doc.

    for (auto& timeline : m_timelines)

        timeline.removeReplacedAnimations();

    // 3. Perform a microtask checkpoint.

    auto document = makeRefPtr(m_document);

    document->eventLoop().performMicrotaskCheckpoint();

    // 4. Let events to dispatch be a copy of doc's pending animation event queue.

    // 5. Clear doc's pending animation event queue.

    AnimationEvents events;

    for (auto& timeline : timelinesToUpdate)

        events.appendVector(timeline->prepareForPendingAnimationEventsDispatch());

    // 6. Perform a stable sort of the animation events in events to dispatch as follows.

    std::stable_sort(events.begin(), events.end(), [] (const Ref<AnimationEventBase>& lhs, const Ref<AnimationEventBase>& rhs) {

        // 1. Sort the events by their scheduled event time such that events that were scheduled to occur earlier, sort before events scheduled to occur later

        // and events whose scheduled event time is unresolved sort before events with a resolved scheduled event time.

        // 2. Within events with equal scheduled event times, sort by their composite order. FIXME: We don't do this.

        if (lhs->timelineTime() && !rhs->timelineTime())

            return false;

        if (!lhs->timelineTime() && rhs->timelineTime())

            return true;

        if (!lhs->timelineTime() && !rhs->timelineTime())

            return true;

        return lhs->timelineTime().value() < rhs->timelineTime().value();

    });

    // 7. Dispatch each of the events in events to dispatch at their corresponding target using the order established in the previous step.

    for (auto& event : events)

        event->target()->dispatchEvent(event);

    // This will cancel any scheduled invalidation if we end up removing all animations.

    for (auto& animation : animationsToRemove) {

        // An animation that was initially marked as irrelevant may have changed while we were sending events, so we run the same

        // check that we ran to add it to animationsToRemove in the first place.

        if (!animation->isRelevant() && !animation->needsTick())

            animation->timeline()->removeAnimation(*animation);

74147 }

    // Now that animations that needed removal have been removed, let's update the list of completed transitions.

    // This needs to happen after dealing with the list of animations to remove as the animation may have been

    // removed from the list of completed transitions otherwise.

    for (auto& completedTransition : completedTransitions)

        downcast<DocumentTimeline>(*completedTransition->timeline()).transitionDidComplete(completedTransition);

    for (auto& timeline : timelinesToUpdate)

        timeline->documentDidUpdateAnimationsAndSendEvents();

}

} // namespace WebCore

Source/WebCore/animation/DocumentTimelinesController.h

namespace WebCore {

33class CSSTransition;

34class Document;

3335class DocumentTimeline;

36class WebAnimation;

class DocumentTimelinesController {

    WTF_MAKE_FAST_ALLOCATED;

public:

38 explicit DocumentTimelinesController();

41 explicit DocumentTimelinesController(Document&);

    ~DocumentTimelinesController();

    void addTimeline(DocumentTimeline&);

@@public:

    void updateAnimationsAndSendEvents(DOMHighResTimeStamp);

private:

    struct AnimationsToProcess {

        Vector<RefPtr<WebAnimation>> animationsToRemove;

        Vector<RefPtr<CSSTransition>> completedTransitions;

    };

4755 WeakHashSet<DocumentTimeline> m_timelines;

56 Document& m_document;

};

} // namespace WebCore

51

Source/WebCore/animation/WebAnimationTypes.h

namespace WebCore {

35class AnimationEventBase;

class AnimationList;

class CSSAnimation;

class CSSTransition;

@@struct WebAnimationsMarkableDoubleTraits {

using MarkableDouble = Markable<double, WebAnimationsMarkableDoubleTraits>;

using AnimationCollection = ListHashSet<RefPtr<WebAnimation>>;

56using AnimationEvents = Vector<Ref<AnimationEventBase>>;

using PropertyToTransitionMap = HashMap<CSSPropertyID, RefPtr<CSSTransition>>;

using CSSAnimationCollection = ListHashSet<RefPtr<CSSAnimation>>;

Source/WebCore/dom/Document.cpp

@@void Document::setConsoleMessageListener(RefPtr<StringCallback>&& listener)

DocumentTimelinesController& Document::ensureTimelinesController()

{

    if (!m_timelinesController)

8083 m_timelinesController = makeUnique<DocumentTimelinesController>();

8083 m_timelinesController = makeUnique<DocumentTimelinesController>(*this);

    return *m_timelinesController.get();

}

LayoutTests/ChangeLog

2020-04-22  Antoine Quint  <graouts@apple.com>

        [Web Animations] Coordinate "update animations and send events" procedure across multiple timelines

        https://bugs.webkit.org/show_bug.cgi?id=202109

        <rdar://problem/59470821>

        Reviewed by NOBODY (OOPS!).

        Remove the flaky expectation for the improved test.

        * TestExpectations:

2020-04-22  Diego Pino Garcia  <dpino@igalia.com>

        [GTK] Gardening, update test expectations

LayoutTests/imported/w3c/ChangeLog

2020-04-22  Antoine Quint  <graouts@apple.com>

        [Web Animations] Coordinate "update animations and send events" procedure across multiple timelines

        https://bugs.webkit.org/show_bug.cgi?id=202109

        <rdar://problem/59470821>

        Reviewed by NOBODY (OOPS!).

        Mark a new test as PASS which shows that we correctly perform a single microstask checkpoint when updating multiple timelines.

        * web-platform-tests/web-animations/timing-model/timelines/update-and-send-events-expected.txt:

2020-04-21  Sergio Villar Senin  <svillar@igalia.com>

        Import latest changes from web-platform-test/webxr/resources to enable testing in WebKit

LayoutTests/TestExpectations

@@webkit.org/b/207261 [ Debug ] imported/w3c/web-platform-tests/css/css-background

webkit.org/b/207262 imported/w3c/web-platform-tests/web-animations/timing-model/animations/sync-start-times.html [ Pass ImageOnlyFailure ]

4067 webkit.org/b/202109 imported/w3c/web-platform-tests/web-animations/timing-model/timelines/update-and-send-events.html [ Pass Failure ]

4068

# WebXR is being implemented

webkit.org/b/208988 imported/w3c/web-platform-tests/webxr [ Skip ]

LayoutTests/imported/w3c/web-platform-tests/web-animations/timing-model/timelines/update-and-send-events-expected.txt

@@FAIL Sorts cancel events by composite order assert_array_equals: cancel events s

PASS Queues a cancel event in transitionstart event callback 

PASS Sorts events for the same transition 

PASS Playback events with the same timeline retain the order in which they arequeued 

9 F~~AIL~~ All timelines are updated before running microtasks ~~promise_test: Unhandled rejection with value: object "AbortError: The operation was aborted."~~

9PASS All timelines are updated before running microtasks

1010