diff options
Diffstat (limited to 'Source/WebCore/page/animation')
14 files changed, 2536 insertions, 1851 deletions
diff --git a/Source/WebCore/page/animation/AnimationBase.cpp b/Source/WebCore/page/animation/AnimationBase.cpp index dd3315ebb..44bfe82a3 100644 --- a/Source/WebCore/page/animation/AnimationBase.cpp +++ b/Source/WebCore/page/animation/AnimationBase.cpp @@ -10,7 +10,7 @@ * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. - * 3. Neither the name of Apple Computer, Inc. ("Apple") nor the names of + * 3. Neither the name of Apple Inc. ("Apple") nor the names of * its contributors may be used to endorse or promote products derived * from this software without specific prior written permission. * @@ -29,16 +29,18 @@ #include "config.h" #include "AnimationBase.h" -#include "AnimationControllerPrivate.h" +#include "CSSAnimationControllerPrivate.h" #include "CSSPrimitiveValue.h" #include "CSSPropertyAnimation.h" #include "CompositeAnimation.h" #include "Document.h" -#include "EventNames.h" #include "FloatConversion.h" +#include "GeometryUtilities.h" #include "Logging.h" #include "RenderBox.h" #include "RenderStyle.h" +#include "RenderView.h" +#include "SpringSolver.h" #include "UnitBezier.h" #include <algorithm> #include <wtf/CurrentTime.h> @@ -68,21 +70,16 @@ static inline double solveStepsFunction(int numSteps, bool stepAtStart, double t return floor(numSteps * t) / numSteps; } -AnimationBase::AnimationBase(const Animation& transition, RenderElement* renderer, CompositeAnimation* compAnim) - : m_animState(AnimationStateNew) - , m_isAccelerated(false) - , m_transformFunctionListValid(false) -#if ENABLE(CSS_FILTERS) - , m_filterFunctionListsMatch(false) -#endif - , m_startTime(0) - , m_pauseTime(-1) - , m_requestedStartTime(0) - , m_totalDuration(-1) - , m_nextIterationDuration(-1) - , m_object(renderer) - , m_animation(const_cast<Animation*>(&transition)) - , m_compAnim(compAnim) +static inline double solveSpringFunction(double mass, double stiffness, double damping, double initialVelocity, double t, double duration) +{ + SpringSolver solver(mass, stiffness, damping, initialVelocity); + return solver.solve(t * duration); +} + +AnimationBase::AnimationBase(const Animation& animation, RenderElement* renderer, CompositeAnimation* compositeAnimation) + : m_object(renderer) + , m_compositeAnimation(compositeAnimation) + , m_animation(const_cast<Animation&>(animation)) { // Compute the total duration if (m_animation->iterationCount() > 0) @@ -91,9 +88,11 @@ AnimationBase::AnimationBase(const Animation& transition, RenderElement* rendere void AnimationBase::setNeedsStyleRecalc(Element* element) { - ASSERT(!element || !element->document().inPageCache()); - if (element) - element->setNeedsStyleRecalc(SyntheticStyleChange); + if (!element || element->document().renderTreeBeingDestroyed()) + return; + + ASSERT(element->document().pageCacheState() == Document::NotInPageCache); + element->invalidateStyleAndLayerComposition(); } double AnimationBase::duration() const @@ -106,137 +105,164 @@ bool AnimationBase::playStatePlaying() const return m_animation->playState() == AnimPlayStatePlaying; } -bool AnimationBase::animationsMatch(const Animation* anim) const +bool AnimationBase::animationsMatch(const Animation& animation) const { - return m_animation->animationsMatch(anim); + return m_animation->animationsMatch(animation); } #if !LOG_DISABLED -static const char* nameForState(AnimationBase::AnimState state) +static const char* nameForState(AnimationBase::AnimationState state) { switch (state) { - case AnimationBase::AnimationStateNew: return "New"; - case AnimationBase::AnimationStateStartWaitTimer: return "StartWaitTimer"; - case AnimationBase::AnimationStateStartWaitStyleAvailable: return "StartWaitStyleAvailable"; - case AnimationBase::AnimationStateStartWaitResponse: return "StartWaitResponse"; - case AnimationBase::AnimationStateLooping: return "Looping"; - case AnimationBase::AnimationStateEnding: return "Ending"; - case AnimationBase::AnimationStatePausedNew: return "PausedNew"; - case AnimationBase::AnimationStatePausedWaitTimer: return "PausedWaitTimer"; - case AnimationBase::AnimationStatePausedWaitStyleAvailable: return "PausedWaitStyleAvailable"; - case AnimationBase::AnimationStatePausedWaitResponse: return "PausedWaitResponse"; - case AnimationBase::AnimationStatePausedRun: return "PausedRun"; - case AnimationBase::AnimationStateDone: return "Done"; - case AnimationBase::AnimationStateFillingForwards: return "FillingForwards"; + case AnimationBase::AnimationState::New: return "New"; + case AnimationBase::AnimationState::StartWaitTimer: return "StartWaitTimer"; + case AnimationBase::AnimationState::StartWaitStyleAvailable: return "StartWaitStyleAvailable"; + case AnimationBase::AnimationState::StartWaitResponse: return "StartWaitResponse"; + case AnimationBase::AnimationState::Looping: return "Looping"; + case AnimationBase::AnimationState::Ending: return "Ending"; + case AnimationBase::AnimationState::PausedNew: return "PausedNew"; + case AnimationBase::AnimationState::PausedWaitTimer: return "PausedWaitTimer"; + case AnimationBase::AnimationState::PausedWaitStyleAvailable: return "PausedWaitStyleAvailable"; + case AnimationBase::AnimationState::PausedWaitResponse: return "PausedWaitResponse"; + case AnimationBase::AnimationState::PausedRun: return "PausedRun"; + case AnimationBase::AnimationState::Done: return "Done"; + case AnimationBase::AnimationState::FillingForwards: return "FillingForwards"; + } + return ""; +} + +static const char* nameForStateInput(AnimationBase::AnimationStateInput input) +{ + switch (input) { + case AnimationBase::AnimationStateInput::MakeNew: return "MakeNew"; + case AnimationBase::AnimationStateInput::StartAnimation: return "StartAnimation"; + case AnimationBase::AnimationStateInput::RestartAnimation: return "RestartAnimation"; + case AnimationBase::AnimationStateInput::StartTimerFired: return "StartTimerFired"; + case AnimationBase::AnimationStateInput::StyleAvailable: return "StyleAvailable"; + case AnimationBase::AnimationStateInput::StartTimeSet: return "StartTimeSet"; + case AnimationBase::AnimationStateInput::LoopTimerFired: return "LoopTimerFired"; + case AnimationBase::AnimationStateInput::EndTimerFired: return "EndTimerFired"; + case AnimationBase::AnimationStateInput::PauseOverride: return "PauseOverride"; + case AnimationBase::AnimationStateInput::ResumeOverride: return "ResumeOverride"; + case AnimationBase::AnimationStateInput::PlayStateRunning: return "PlayStateRunning"; + case AnimationBase::AnimationStateInput::PlayStatePaused: return "PlayStatePaused"; + case AnimationBase::AnimationStateInput::EndAnimation: return "EndAnimation"; } return ""; } #endif -void AnimationBase::updateStateMachine(AnimStateInput input, double param) +void AnimationBase::updateStateMachine(AnimationStateInput input, double param) { - if (!m_compAnim) + if (!m_compositeAnimation) return; - // If we get AnimationStateInputRestartAnimation then we force a new animation, regardless of state. - if (input == AnimationStateInputMakeNew) { - if (m_animState == AnimationStateStartWaitStyleAvailable) - m_compAnim->animationController()->removeFromAnimationsWaitingForStyle(this); - LOG(Animations, "%p AnimationState %s -> New", this, nameForState(m_animState)); - m_animState = AnimationStateNew; - m_startTime = 0; - m_pauseTime = -1; + // If we get AnimationStateInput::RestartAnimation then we force a new animation, regardless of state. + if (input == AnimationStateInput::MakeNew) { + if (m_animationState == AnimationState::StartWaitStyleAvailable) + m_compositeAnimation->animationController().removeFromAnimationsWaitingForStyle(this); + LOG(Animations, "%p AnimationState %s -> New", this, nameForState(m_animationState)); + m_animationState = AnimationState::New; + m_startTime = std::nullopt; + m_pauseTime = std::nullopt; m_requestedStartTime = 0; - m_nextIterationDuration = -1; + m_nextIterationDuration = std::nullopt; endAnimation(); return; } - if (input == AnimationStateInputRestartAnimation) { - if (m_animState == AnimationStateStartWaitStyleAvailable) - m_compAnim->animationController()->removeFromAnimationsWaitingForStyle(this); - LOG(Animations, "%p AnimationState %s -> New", this, nameForState(m_animState)); - m_animState = AnimationStateNew; - m_startTime = 0; - m_pauseTime = -1; + if (input == AnimationStateInput::RestartAnimation) { + if (m_animationState == AnimationState::StartWaitStyleAvailable) + m_compositeAnimation->animationController().removeFromAnimationsWaitingForStyle(this); + LOG(Animations, "%p AnimationState %s -> New", this, nameForState(m_animationState)); + m_animationState = AnimationState::New; + m_startTime = std::nullopt; + m_pauseTime = std::nullopt; m_requestedStartTime = 0; - m_nextIterationDuration = -1; + m_nextIterationDuration = std::nullopt; endAnimation(); if (!paused()) - updateStateMachine(AnimationStateInputStartAnimation, -1); + updateStateMachine(AnimationStateInput::StartAnimation, -1); return; } - if (input == AnimationStateInputEndAnimation) { - if (m_animState == AnimationStateStartWaitStyleAvailable) - m_compAnim->animationController()->removeFromAnimationsWaitingForStyle(this); - LOG(Animations, "%p AnimationState %s -> Done", this, nameForState(m_animState)); - m_animState = AnimationStateDone; + if (input == AnimationStateInput::EndAnimation) { + if (m_animationState == AnimationState::StartWaitStyleAvailable) + m_compositeAnimation->animationController().removeFromAnimationsWaitingForStyle(this); + LOG(Animations, "%p AnimationState %s -> Done", this, nameForState(m_animationState)); + m_animationState = AnimationState::Done; endAnimation(); return; } - if (input == AnimationStateInputPauseOverride) { - if (m_animState == AnimationStateStartWaitResponse) { - // If we are in AnimationStateStartWaitResponse, the animation will get canceled before + if (input == AnimationStateInput::PauseOverride) { + if (m_animationState == AnimationState::StartWaitResponse) { + // If we are in AnimationState::StartWaitResponse, the animation will get canceled before // we get a response, so move to the next state. endAnimation(); - updateStateMachine(AnimationStateInputStartTimeSet, beginAnimationUpdateTime()); + updateStateMachine(AnimationStateInput::StartTimeSet, beginAnimationUpdateTime()); } return; } - if (input == AnimationStateInputResumeOverride) { - if (m_animState == AnimationStateLooping || m_animState == AnimationStateEnding) { + if (input == AnimationStateInput::ResumeOverride) { + if (m_animationState == AnimationState::Looping || m_animationState == AnimationState::Ending) { // Start the animation - startAnimation(beginAnimationUpdateTime() - m_startTime); + startAnimation(beginAnimationUpdateTime() - m_startTime.value_or(0)); } return; } // Execute state machine - switch (m_animState) { - case AnimationStateNew: - ASSERT(input == AnimationStateInputStartAnimation || input == AnimationStateInputPlayStateRunning || input == AnimationStateInputPlayStatePaused); - if (input == AnimationStateInputStartAnimation || input == AnimationStateInputPlayStateRunning) { + switch (m_animationState) { + case AnimationState::New: + ASSERT(input == AnimationStateInput::StartAnimation || input == AnimationStateInput::PlayStateRunning || input == AnimationStateInput::PlayStatePaused); + + if (input == AnimationStateInput::StartAnimation || input == AnimationStateInput::PlayStateRunning) { m_requestedStartTime = beginAnimationUpdateTime(); - LOG(Animations, "%p AnimationState %s -> StartWaitTimer", this, nameForState(m_animState)); - m_animState = AnimationStateStartWaitTimer; + LOG(Animations, "%p AnimationState %s -> StartWaitTimer", this, nameForState(m_animationState)); + m_animationState = AnimationState::StartWaitTimer; } else { // We are pausing before we even started. - LOG(Animations, "%p AnimationState %s -> AnimationStatePausedNew", this, nameForState(m_animState)); - m_animState = AnimationStatePausedNew; + LOG(Animations, "%p AnimationState %s -> AnimationState::PausedNew", this, nameForState(m_animationState)); + m_animationState = AnimationState::PausedNew; + m_pauseTime = std::nullopt; } + +#if ENABLE(CSS_ANIMATIONS_LEVEL_2) + if (m_animation->trigger() && m_animation->trigger()->isScrollAnimationTrigger()) + m_compositeAnimation->animationController().addToAnimationsDependentOnScroll(this); +#endif break; - case AnimationStateStartWaitTimer: - ASSERT(input == AnimationStateInputStartTimerFired || input == AnimationStateInputPlayStatePaused); + case AnimationState::StartWaitTimer: + ASSERT(input == AnimationStateInput::StartTimerFired || input == AnimationStateInput::PlayStatePaused); - if (input == AnimationStateInputStartTimerFired) { + if (input == AnimationStateInput::StartTimerFired) { ASSERT(param >= 0); // Start timer has fired, tell the animation to start and wait for it to respond with start time - LOG(Animations, "%p AnimationState %s -> StartWaitStyleAvailable", this, nameForState(m_animState)); - m_animState = AnimationStateStartWaitStyleAvailable; - m_compAnim->animationController()->addToAnimationsWaitingForStyle(this); + LOG(Animations, "%p AnimationState %s -> StartWaitStyleAvailable (time is %f)", this, nameForState(m_animationState), param); + m_animationState = AnimationState::StartWaitStyleAvailable; + m_compositeAnimation->animationController().addToAnimationsWaitingForStyle(this); // Trigger a render so we can start the animation if (m_object && m_object->element()) - m_compAnim->animationController()->addElementChangeToDispatch(*m_object->element()); + m_compositeAnimation->animationController().addElementChangeToDispatch(*m_object->element()); } else { ASSERT(!paused()); // We're waiting for the start timer to fire and we got a pause. Cancel the timer, pause and wait m_pauseTime = beginAnimationUpdateTime(); - LOG(Animations, "%p AnimationState %s -> PausedWaitTimer", this, nameForState(m_animState)); - m_animState = AnimationStatePausedWaitTimer; + LOG(Animations, "%p AnimationState %s -> PausedWaitTimer", this, nameForState(m_animationState)); + m_animationState = AnimationState::PausedWaitTimer; } break; - case AnimationStateStartWaitStyleAvailable: - ASSERT(input == AnimationStateInputStyleAvailable || input == AnimationStateInputPlayStatePaused); + case AnimationState::StartWaitStyleAvailable: + ASSERT(input == AnimationStateInput::StyleAvailable || input == AnimationStateInput::PlayStatePaused); - if (input == AnimationStateInputStyleAvailable) { + if (input == AnimationStateInput::StyleAvailable) { // Start timer has fired, tell the animation to start and wait for it to respond with start time - LOG(Animations, "%p AnimationState %s -> StartWaitResponse", this, nameForState(m_animState)); - m_animState = AnimationStateStartWaitResponse; + LOG(Animations, "%p AnimationState %s -> StartWaitResponse (time is %f)", this, nameForState(m_animationState), param); + m_animationState = AnimationState::StartWaitResponse; overrideAnimations(); @@ -244,10 +270,10 @@ void AnimationBase::updateStateMachine(AnimStateInput input, double param) if (overridden()) { // We won't try to start accelerated animations if we are overridden and // just move on to the next state. - LOG(Animations, "%p AnimationState %s -> StartWaitResponse", this, nameForState(m_animState)); - m_animState = AnimationStateStartWaitResponse; + LOG(Animations, "%p AnimationState %s -> StartWaitResponse", this, nameForState(m_animationState)); + m_animationState = AnimationState::StartWaitResponse; m_isAccelerated = false; - updateStateMachine(AnimationStateInputStartTimeSet, beginAnimationUpdateTime()); + updateStateMachine(AnimationStateInput::StartTimeSet, beginAnimationUpdateTime()); } else { double timeOffset = 0; // If the value for 'animation-delay' is negative then the animation appears to have started in the past. @@ -255,27 +281,29 @@ void AnimationBase::updateStateMachine(AnimStateInput input, double param) timeOffset = -m_animation->delay(); bool started = startAnimation(timeOffset); - m_compAnim->animationController()->addToAnimationsWaitingForStartTimeResponse(this, started); + m_compositeAnimation->animationController().addToAnimationsWaitingForStartTimeResponse(this, started); m_isAccelerated = started; } } else { // We're waiting for the style to be available and we got a pause. Pause and wait m_pauseTime = beginAnimationUpdateTime(); - LOG(Animations, "%p AnimationState %s -> PausedWaitStyleAvailable", this, nameForState(m_animState)); - m_animState = AnimationStatePausedWaitStyleAvailable; + LOG(Animations, "%p AnimationState %s -> PausedWaitStyleAvailable", this, nameForState(m_animationState)); + m_animationState = AnimationState::PausedWaitStyleAvailable; } break; - case AnimationStateStartWaitResponse: - ASSERT(input == AnimationStateInputStartTimeSet || input == AnimationStateInputPlayStatePaused); + case AnimationState::StartWaitResponse: + ASSERT(input == AnimationStateInput::StartTimeSet || input == AnimationStateInput::PlayStatePaused); + + if (input == AnimationStateInput::StartTimeSet) { + ASSERT(param > -0.001); // Sometimes Core Animation gives us a beginTime slightly into the future. + LOG(Animations, "%p AnimationState %s -> StartTimeSet (time is %f)", this, nameForState(m_animationState), param); - if (input == AnimationStateInputStartTimeSet) { - ASSERT(param >= 0); // We have a start time, set it, unless the startTime is already set - if (m_startTime <= 0) { + if (!m_startTime) { m_startTime = param; // If the value for 'animation-delay' is negative then the animation appears to have started in the past. if (m_animation->delay() < 0) - m_startTime += m_animation->delay(); + m_startTime = m_startTime.value() + m_animation->delay(); } // Now that we know the start time, fire the start event. @@ -286,21 +314,23 @@ void AnimationBase::updateStateMachine(AnimStateInput input, double param) // Dispatch updateStyleIfNeeded so we can start the animation if (m_object && m_object->element()) - m_compAnim->animationController()->addElementChangeToDispatch(*m_object->element()); + m_compositeAnimation->animationController().addElementChangeToDispatch(*m_object->element()); } else { // We are pausing while waiting for a start response. Cancel the animation and wait. When // we unpause, we will act as though the start timer just fired m_pauseTime = beginAnimationUpdateTime(); - pauseAnimation(beginAnimationUpdateTime() - m_startTime); - LOG(Animations, "%p AnimationState %s -> PausedWaitResponse", this, nameForState(m_animState)); - m_animState = AnimationStatePausedWaitResponse; + pauseAnimation(beginAnimationUpdateTime() - m_startTime.value_or(0)); + LOG(Animations, "%p AnimationState %s -> PausedWaitResponse", this, nameForState(m_animationState)); + m_animationState = AnimationState::PausedWaitResponse; } break; - case AnimationStateLooping: - ASSERT(input == AnimationStateInputLoopTimerFired || input == AnimationStateInputPlayStatePaused); + case AnimationState::Looping: + ASSERT(input == AnimationStateInput::LoopTimerFired || input == AnimationStateInput::PlayStatePaused); - if (input == AnimationStateInputLoopTimerFired) { + if (input == AnimationStateInput::LoopTimerFired) { ASSERT(param >= 0); + LOG(Animations, "%p AnimationState %s -> LoopTimerFired (time is %f)", this, nameForState(m_animationState), param); + // Loop timer fired, loop again or end. onAnimationIteration(param); @@ -309,178 +339,198 @@ void AnimationBase::updateStateMachine(AnimStateInput input, double param) } else { // We are pausing while running. Cancel the animation and wait m_pauseTime = beginAnimationUpdateTime(); - pauseAnimation(beginAnimationUpdateTime() - m_startTime); - LOG(Animations, "%p AnimationState %s -> PausedRun", this, nameForState(m_animState)); - m_animState = AnimationStatePausedRun; + pauseAnimation(beginAnimationUpdateTime() - m_startTime.value_or(0)); + LOG(Animations, "%p AnimationState %s -> PausedRun", this, nameForState(m_animationState)); + m_animationState = AnimationState::PausedRun; } break; - case AnimationStateEnding: + case AnimationState::Ending: #if !LOG_DISABLED - if (input != AnimationStateInputEndTimerFired && input != AnimationStateInputPlayStatePaused) - LOG_ERROR("State is AnimationStateEnding, but input is not AnimationStateInputEndTimerFired or AnimationStateInputPlayStatePaused. It is %d.", input); + if (input != AnimationStateInput::EndTimerFired && input != AnimationStateInput::PlayStatePaused) + LOG_ERROR("State is AnimationState::Ending, but input is not AnimationStateInput::EndTimerFired or AnimationStateInput::PlayStatePaused. It is %s.", nameForStateInput(input)); #endif - if (input == AnimationStateInputEndTimerFired) { - + if (input == AnimationStateInput::EndTimerFired) { ASSERT(param >= 0); // End timer fired, finish up onAnimationEnd(param); - LOG(Animations, "%p AnimationState %s -> Done", this, nameForState(m_animState)); - m_animState = AnimationStateDone; + LOG(Animations, "%p AnimationState %s -> Done (time is %f)", this, nameForState(m_animationState), param); + m_animationState = AnimationState::Done; if (m_object) { if (m_animation->fillsForwards()) { - LOG(Animations, "%p AnimationState %s -> FillingForwards", this, nameForState(m_animState)); - m_animState = AnimationStateFillingForwards; + LOG(Animations, "%p AnimationState %s -> FillingForwards", this, nameForState(m_animationState)); + m_animationState = AnimationState::FillingForwards; } else resumeOverriddenAnimations(); // Fire off another style change so we can set the final value if (m_object->element()) - m_compAnim->animationController()->addElementChangeToDispatch(*m_object->element()); + m_compositeAnimation->animationController().addElementChangeToDispatch(*m_object->element()); } } else { // We are pausing while running. Cancel the animation and wait m_pauseTime = beginAnimationUpdateTime(); - pauseAnimation(beginAnimationUpdateTime() - m_startTime); - LOG(Animations, "%p AnimationState %s -> PausedRun", this, nameForState(m_animState)); - m_animState = AnimationStatePausedRun; + pauseAnimation(beginAnimationUpdateTime() - m_startTime.value_or(0)); + LOG(Animations, "%p AnimationState %s -> PausedRun", this, nameForState(m_animationState)); + m_animationState = AnimationState::PausedRun; } // |this| may be deleted here break; - case AnimationStatePausedWaitTimer: - ASSERT(input == AnimationStateInputPlayStateRunning); + case AnimationState::PausedWaitTimer: + ASSERT(input == AnimationStateInput::PlayStateRunning); ASSERT(paused()); // Update the times - m_startTime += beginAnimationUpdateTime() - m_pauseTime; - m_pauseTime = -1; + m_startTime = m_startTime.value() + beginAnimationUpdateTime() - m_pauseTime.value_or(0); + m_pauseTime = std::nullopt; // we were waiting for the start timer to fire, go back and wait again - LOG(Animations, "%p AnimationState %s -> New", this, nameForState(m_animState)); - m_animState = AnimationStateNew; - updateStateMachine(AnimationStateInputStartAnimation, 0); + LOG(Animations, "%p AnimationState %s -> New", this, nameForState(m_animationState)); + m_animationState = AnimationState::New; + updateStateMachine(AnimationStateInput::StartAnimation, 0); break; - case AnimationStatePausedNew: - case AnimationStatePausedWaitResponse: - case AnimationStatePausedWaitStyleAvailable: - case AnimationStatePausedRun: + case AnimationState::PausedNew: + case AnimationState::PausedWaitResponse: + case AnimationState::PausedWaitStyleAvailable: + case AnimationState::PausedRun: // We treat these two cases the same. The only difference is that, when we are in - // AnimationStatePausedWaitResponse, we don't yet have a valid startTime, so we send 0 to startAnimation. - // When the AnimationStateInputStartTimeSet comes in and we were in AnimationStatePausedRun, we will notice + // AnimationState::PausedWaitResponse, we don't yet have a valid startTime, so we send 0 to startAnimation. + // When the AnimationStateInput::StartTimeSet comes in and we were in AnimationState::PausedRun, we will notice // that we have already set the startTime and will ignore it. - ASSERT(input == AnimationStateInputPlayStateRunning || input == AnimationStateInputStartTimeSet || input == AnimationStateInputStyleAvailable || input == AnimationStateInputStartAnimation); + ASSERT(input == AnimationStateInput::PlayStatePaused || input == AnimationStateInput::PlayStateRunning || input == AnimationStateInput::StartTimeSet || input == AnimationStateInput::StyleAvailable || input == AnimationStateInput::StartAnimation); ASSERT(paused()); - if (input == AnimationStateInputPlayStateRunning) { - if (m_animState == AnimationStatePausedNew) { + if (input == AnimationStateInput::PlayStateRunning) { + if (m_animationState == AnimationState::PausedNew) { // We were paused before we even started, and now we're supposed // to start, so jump back to the New state and reset. - LOG(Animations, "%p AnimationState %s -> AnimationStateNew", this, nameForState(m_animState)); - m_animState = AnimationStateNew; + LOG(Animations, "%p AnimationState %s -> AnimationState::New", this, nameForState(m_animationState)); + m_animationState = AnimationState::New; + m_pauseTime = std::nullopt; updateStateMachine(input, param); break; } // Update the times - if (m_animState == AnimationStatePausedRun) - m_startTime += beginAnimationUpdateTime() - m_pauseTime; + if (m_animationState == AnimationState::PausedRun) + m_startTime = m_startTime.value() + beginAnimationUpdateTime() - m_pauseTime.value_or(0); else m_startTime = 0; - m_pauseTime = -1; - if (m_animState == AnimationStatePausedWaitStyleAvailable) { - LOG(Animations, "%p AnimationState %s -> StartWaitStyleAvailable", this, nameForState(m_animState)); - m_animState = AnimationStateStartWaitStyleAvailable; + m_pauseTime = std::nullopt; + + if (m_animationState == AnimationState::PausedWaitStyleAvailable) { + LOG(Animations, "%p AnimationState %s -> StartWaitStyleAvailable", this, nameForState(m_animationState)); + m_animationState = AnimationState::StartWaitStyleAvailable; } else { // We were either running or waiting for a begin time response from the animation. // Either way we need to restart the animation (possibly with an offset if we // had already been running) and wait for it to start. - LOG(Animations, "%p AnimationState %s -> StartWaitResponse", this, nameForState(m_animState)); - m_animState = AnimationStateStartWaitResponse; + LOG(Animations, "%p AnimationState %s -> StartWaitResponse", this, nameForState(m_animationState)); + m_animationState = AnimationState::StartWaitResponse; // Start the animation if (overridden()) { // We won't try to start accelerated animations if we are overridden and // just move on to the next state. - updateStateMachine(AnimationStateInputStartTimeSet, beginAnimationUpdateTime()); + updateStateMachine(AnimationStateInput::StartTimeSet, beginAnimationUpdateTime()); m_isAccelerated = true; } else { - bool started = startAnimation(beginAnimationUpdateTime() - m_startTime); - m_compAnim->animationController()->addToAnimationsWaitingForStartTimeResponse(this, started); + bool started = startAnimation(beginAnimationUpdateTime() - m_startTime.value_or(0)); + m_compositeAnimation->animationController().addToAnimationsWaitingForStartTimeResponse(this, started); m_isAccelerated = started; } } break; } - if (input == AnimationStateInputStartTimeSet) { - ASSERT(m_animState == AnimationStatePausedWaitResponse); + if (input == AnimationStateInput::StartTimeSet) { + ASSERT(m_animationState == AnimationState::PausedWaitResponse); // We are paused but we got the callback that notifies us that an accelerated animation started. // We ignore the start time and just move into the paused-run state. - LOG(Animations, "%p AnimationState %s -> PausedRun", this, nameForState(m_animState)); - m_animState = AnimationStatePausedRun; - ASSERT(m_startTime == 0); + LOG(Animations, "%p AnimationState %s -> PausedRun (time is %f)", this, nameForState(m_animationState), param); + m_animationState = AnimationState::PausedRun; + ASSERT(!m_startTime); m_startTime = param; - m_pauseTime += m_startTime; + m_pauseTime = m_pauseTime.value_or(0) + param; break; } - ASSERT(m_animState == AnimationStatePausedWaitStyleAvailable); + ASSERT(m_animationState == AnimationState::PausedNew || m_animationState == AnimationState::PausedWaitStyleAvailable); // We are paused but we got the callback that notifies us that style has been updated. - // We move to the AnimationStatePausedWaitResponse state - LOG(Animations, "%p AnimationState %s -> PausedWaitResponse", this, nameForState(m_animState)); - m_animState = AnimationStatePausedWaitResponse; + // We move to the AnimationState::PausedWaitResponse state + LOG(Animations, "%p AnimationState %s -> PausedWaitResponse", this, nameForState(m_animationState)); + m_animationState = AnimationState::PausedWaitResponse; overrideAnimations(); break; - case AnimationStateFillingForwards: - case AnimationStateDone: + case AnimationState::FillingForwards: + case AnimationState::Done: // We're done. Stay in this state until we are deleted break; } } - + void AnimationBase::fireAnimationEventsIfNeeded() { - if (!m_compAnim) + if (!m_compositeAnimation) return; // If we are waiting for the delay time to expire and it has, go to the next state - if (m_animState != AnimationStateStartWaitTimer && m_animState != AnimationStateLooping && m_animState != AnimationStateEnding) + if (m_animationState != AnimationState::StartWaitTimer && m_animationState != AnimationState::Looping && m_animationState != AnimationState::Ending) return; // We have to make sure to keep a ref to the this pointer, because it could get destroyed // during an animation callback that might get called. Since the owner is a CompositeAnimation // and it ref counts this object, we will keep a ref to that instead. That way the AnimationBase // can still access the resources of its CompositeAnimation as needed. - Ref<AnimationBase> protect(*this); - Ref<CompositeAnimation> protectCompositeAnimation(*m_compAnim); + Ref<AnimationBase> protectedThis(*this); + Ref<CompositeAnimation> protectCompositeAnimation(*m_compositeAnimation); // Check for start timeout - if (m_animState == AnimationStateStartWaitTimer) { + if (m_animationState == AnimationState::StartWaitTimer) { +#if ENABLE(CSS_ANIMATIONS_LEVEL_2) + if (m_animation->trigger() && m_animation->trigger()->isScrollAnimationTrigger()) { + if (m_object) { + float offset = m_compositeAnimation->animationController().scrollPosition(); + auto& scrollTrigger = downcast<ScrollAnimationTrigger>(*m_animation->trigger()); + if (offset > scrollTrigger.startValue().value()) + updateStateMachine(AnimationStateInput::StartTimerFired, 0); + } + + return; + } +#endif if (beginAnimationUpdateTime() - m_requestedStartTime >= m_animation->delay()) - updateStateMachine(AnimationStateInputStartTimerFired, 0); + updateStateMachine(AnimationStateInput::StartTimerFired, 0); return; } - - double elapsedDuration = beginAnimationUpdateTime() - m_startTime; + + double elapsedDuration = beginAnimationUpdateTime() - m_startTime.value_or(0); +#if ENABLE(CSS_ANIMATIONS_LEVEL_2) + // If we are a triggered animation that depends on scroll, our elapsed + // time is determined by the scroll position. + if (m_animation->trigger() && m_animation->trigger()->isScrollAnimationTrigger()) + elapsedDuration = getElapsedTime(); +#endif + // FIXME: we need to ensure that elapsedDuration is never < 0. If it is, this suggests that // we had a recalcStyle() outside of beginAnimationUpdate()/endAnimationUpdate(). // Also check in getTimeToNextEvent(). elapsedDuration = std::max(elapsedDuration, 0.0); // Check for end timeout - if (m_totalDuration >= 0 && elapsedDuration >= m_totalDuration) { - // We may still be in AnimationStateLooping if we've managed to skip a + if (m_totalDuration && elapsedDuration >= m_totalDuration.value()) { + // We may still be in AnimationState::Looping if we've managed to skip a // whole iteration, in which case we should jump to the end state. - LOG(Animations, "%p AnimationState %s -> Ending", this, nameForState(m_animState)); - m_animState = AnimationStateEnding; + LOG(Animations, "%p AnimationState %s -> Ending", this, nameForState(m_animationState)); + m_animationState = AnimationState::Ending; // Fire an end event - updateStateMachine(AnimationStateInputEndTimerFired, m_totalDuration); + updateStateMachine(AnimationStateInput::EndTimerFired, m_totalDuration.value()); } else { // Check for iteration timeout - if (m_nextIterationDuration < 0) { + if (!m_nextIterationDuration) { // Hasn't been set yet, set it double durationLeft = m_animation->duration() - fmod(elapsedDuration, m_animation->duration()); m_nextIterationDuration = elapsedDuration + durationLeft; @@ -488,40 +538,51 @@ void AnimationBase::fireAnimationEventsIfNeeded() if (elapsedDuration >= m_nextIterationDuration) { // Set to the next iteration - double previous = m_nextIterationDuration; + double previous = m_nextIterationDuration.value(); double durationLeft = m_animation->duration() - fmod(elapsedDuration, m_animation->duration()); m_nextIterationDuration = elapsedDuration + durationLeft; // Send the event - updateStateMachine(AnimationStateInputLoopTimerFired, previous); + updateStateMachine(AnimationStateInput::LoopTimerFired, previous); } } } void AnimationBase::updatePlayState(EAnimPlayState playState) { - if (!m_compAnim) + if (!m_compositeAnimation) return; // When we get here, we can have one of 4 desired states: running, paused, suspended, paused & suspended. // The state machine can be in one of two states: running, paused. // Set the state machine to the desired state. - bool pause = playState == AnimPlayStatePaused || m_compAnim->isSuspended(); + bool pause = playState == AnimPlayStatePaused || m_compositeAnimation->isSuspended(); if (pause == paused() && !isNew()) return; - updateStateMachine(pause ? AnimationStateInputPlayStatePaused : AnimationStateInputPlayStateRunning, -1); + updateStateMachine(pause ? AnimationStateInput::PlayStatePaused : AnimationStateInput::PlayStateRunning, -1); } double AnimationBase::timeToNextService() { // Returns the time at which next service is required. -1 means no service is required. 0 means // service is required now, and > 0 means service is required that many seconds in the future. - if (paused() || isNew() || m_animState == AnimationStateFillingForwards) + if (paused() || isNew() || postActive() || fillingForwards()) return -1; - if (m_animState == AnimationStateStartWaitTimer) { + if (m_animationState == AnimationState::StartWaitTimer) { +#if ENABLE(CSS_ANIMATIONS_LEVEL_2) + if (m_animation->trigger()->isScrollAnimationTrigger()) { + if (m_object) { + float currentScrollPosition = m_object->view().frameView().scrollPositionForFixedPosition().y().toFloat(); + auto& scrollTrigger = downcast<ScrollAnimationTrigger>(*m_animation->trigger()); + if (currentScrollPosition >= scrollTrigger.startValue().value() && (!scrollTrigger.hasEndValue() || currentScrollPosition <= scrollTrigger.endValue().value())) + return 0; + } + return -1; + } +#endif double timeFromNow = m_animation->delay() - (beginAnimationUpdateTime() - m_requestedStartTime); return std::max(timeFromNow, 0.0); } @@ -566,39 +627,45 @@ double AnimationBase::fractionalTime(double scale, double elapsedTime, double of return fractionalTime; } -double AnimationBase::progress(double scale, double offset, const TimingFunction* tf) const +double AnimationBase::progress(double scale, double offset, const TimingFunction* timingFunction) const { if (preActive()) return 0; + if (postActive()) + return 1; + double elapsedTime = getElapsedTime(); - double dur = m_animation->duration(); + double duration = m_animation->duration(); if (m_animation->iterationCount() > 0) - dur *= m_animation->iterationCount(); + duration *= m_animation->iterationCount(); - if (postActive() || !m_animation->duration()) - return 1.0; + if (fillingForwards()) + elapsedTime = duration; - if (m_animation->iterationCount() > 0 && elapsedTime >= dur) { - const int integralIterationCount = static_cast<int>(m_animation->iterationCount()); - const bool iterationCountHasFractional = m_animation->iterationCount() - integralIterationCount; - return (integralIterationCount % 2 || iterationCountHasFractional) ? 1.0 : 0.0; - } + double fractionalTime = this->fractionalTime(scale, elapsedTime, offset); - const double fractionalTime = this->fractionalTime(scale, elapsedTime, offset); + if (m_animation->iterationCount() > 0 && elapsedTime >= duration) { + if (WTF::isIntegral(fractionalTime)) + return fractionalTime; + } - if (!tf) - tf = m_animation->timingFunction().get(); + if (!timingFunction) + timingFunction = m_animation->timingFunction(); - switch (tf->type()) { + switch (timingFunction->type()) { case TimingFunction::CubicBezierFunction: { - const CubicBezierTimingFunction* function = static_cast<const CubicBezierTimingFunction*>(tf); - return solveCubicBezierFunction(function->x1(), function->y1(), function->x2(), function->y2(), fractionalTime, m_animation->duration()); + auto& function = *static_cast<const CubicBezierTimingFunction*>(timingFunction); + return solveCubicBezierFunction(function.x1(), function.y1(), function.x2(), function.y2(), fractionalTime, m_animation->duration()); } case TimingFunction::StepsFunction: { - const StepsTimingFunction* stepsTimingFunction = static_cast<const StepsTimingFunction*>(tf); - return solveStepsFunction(stepsTimingFunction->numberOfSteps(), stepsTimingFunction->stepAtStart(), fractionalTime); + auto& function = *static_cast<const StepsTimingFunction*>(timingFunction); + return solveStepsFunction(function.numberOfSteps(), function.stepAtStart(), fractionalTime); + } + case TimingFunction::SpringFunction: { + auto& function = *static_cast<const SpringTimingFunction*>(timingFunction); + return solveSpringFunction(function.mass(), function.stiffness(), function.damping(), function.initialVelocity(), fractionalTime, m_animation->duration()); } case TimingFunction::LinearFunction: return fractionalTime; @@ -611,16 +678,16 @@ double AnimationBase::progress(double scale, double offset, const TimingFunction void AnimationBase::getTimeToNextEvent(double& time, bool& isLooping) const { // Decide when the end or loop event needs to fire - const double elapsedDuration = std::max(beginAnimationUpdateTime() - m_startTime, 0.0); + const double elapsedDuration = std::max(beginAnimationUpdateTime() - m_startTime.value_or(0), 0.0); double durationLeft = 0; - double nextIterationTime = m_totalDuration; + double nextIterationTime = m_totalDuration.value_or(0); - if (m_totalDuration < 0 || elapsedDuration < m_totalDuration) { + if (!m_totalDuration || elapsedDuration < m_totalDuration.value()) { durationLeft = m_animation->duration() > 0 ? (m_animation->duration() - fmod(elapsedDuration, m_animation->duration())) : 0; nextIterationTime = elapsedDuration + durationLeft; } - if (m_totalDuration < 0 || nextIterationTime < m_totalDuration) { + if (!m_totalDuration || nextIterationTime < m_totalDuration.value()) { // We are not at the end yet ASSERT(nextIterationTime > 0); isLooping = true; @@ -637,52 +704,70 @@ void AnimationBase::goIntoEndingOrLoopingState() double t; bool isLooping; getTimeToNextEvent(t, isLooping); - LOG(Animations, "%p AnimationState %s -> %s", this, nameForState(m_animState), isLooping ? "Looping" : "Ending"); - m_animState = isLooping ? AnimationStateLooping : AnimationStateEnding; + LOG(Animations, "%p AnimationState %s -> %s", this, nameForState(m_animationState), isLooping ? "Looping" : "Ending"); + m_animationState = isLooping ? AnimationState::Looping : AnimationState::Ending; } void AnimationBase::freezeAtTime(double t) { - if (!m_compAnim) + if (!m_compositeAnimation) return; if (!m_startTime) { // If we haven't started yet, make it as if we started. - LOG(Animations, "%p AnimationState %s -> StartWaitResponse", this, nameForState(m_animState)); - m_animState = AnimationStateStartWaitResponse; + LOG(Animations, "%p AnimationState %s -> StartWaitResponse", this, nameForState(m_animationState)); + m_animationState = AnimationState::StartWaitResponse; onAnimationStartResponse(monotonicallyIncreasingTime()); } - ASSERT(m_startTime); // if m_startTime is zero, we haven't started yet, so we'll get a bad pause time. + ASSERT(m_startTime); // If m_startTime is zero, we haven't started yet, so we'll get a bad pause time. if (t <= m_animation->delay()) - m_pauseTime = m_startTime; + m_pauseTime = m_startTime.value_or(0); else - m_pauseTime = m_startTime + t - m_animation->delay(); + m_pauseTime = m_startTime.value_or(0) + t - m_animation->delay(); -#if USE(ACCELERATED_COMPOSITING) if (m_object && m_object->isComposited()) - toRenderBoxModelObject(m_object)->suspendAnimations(m_pauseTime); -#endif + downcast<RenderBoxModelObject>(*m_object).suspendAnimations(m_pauseTime.value()); } double AnimationBase::beginAnimationUpdateTime() const { - if (!m_compAnim) + if (!m_compositeAnimation) return 0; - return m_compAnim->animationController()->beginAnimationUpdateTime(); + return m_compositeAnimation->animationController().beginAnimationUpdateTime(); } double AnimationBase::getElapsedTime() const { - if (paused()) - return m_pauseTime - m_startTime; - if (m_startTime <= 0) +#if ENABLE(CSS_ANIMATIONS_LEVEL_2) + if (m_animation->trigger() && m_animation->trigger()->isScrollAnimationTrigger()) { + auto& scrollTrigger = downcast<ScrollAnimationTrigger>(*m_animation->trigger()); + if (scrollTrigger.hasEndValue() && m_object) { + float offset = m_compositeAnimation->animationController().scrollPosition(); + float startValue = scrollTrigger.startValue().value(); + if (offset < startValue) + return 0; + float endValue = scrollTrigger.endValue().value(); + if (offset > endValue) + return m_animation->duration(); + return m_animation->duration() * (offset - startValue) / (endValue - startValue); + } + } +#endif + + if (paused()) { + double delayOffset = (!m_startTime && m_animation->delay() < 0) ? m_animation->delay() : 0; + return m_pauseTime.value_or(0) - m_startTime.value_or(0) - delayOffset; + } + + if (!m_startTime) return 0; - if (postActive()) - return 1; - return beginAnimationUpdateTime() - m_startTime; + if (postActive() || fillingForwards()) + return m_totalDuration.value_or(0); + + return beginAnimationUpdateTime() - m_startTime.value_or(0); } void AnimationBase::setElapsedTime(double time) @@ -701,4 +786,77 @@ void AnimationBase::pause() // FIXME: implement this method } +static bool containsRotation(const Vector<RefPtr<TransformOperation>>& operations) +{ + for (const auto& operation : operations) { + if (operation->type() == TransformOperation::ROTATE) + return true; + } + return false; +} + +bool AnimationBase::computeTransformedExtentViaTransformList(const FloatRect& rendererBox, const RenderStyle& style, LayoutRect& bounds) const +{ + FloatRect floatBounds = bounds; + FloatPoint transformOrigin; + + bool applyTransformOrigin = containsRotation(style.transform().operations()) || style.transform().affectedByTransformOrigin(); + if (applyTransformOrigin) { + float offsetX = style.transformOriginX().isPercent() ? rendererBox.x() : 0; + float offsetY = style.transformOriginY().isPercent() ? rendererBox.y() : 0; + + transformOrigin.setX(floatValueForLength(style.transformOriginX(), rendererBox.width()) + offsetX); + transformOrigin.setY(floatValueForLength(style.transformOriginY(), rendererBox.height()) + offsetY); + // Ignore transformOriginZ because we'll bail if we encounter any 3D transforms. + + floatBounds.moveBy(-transformOrigin); + } + + for (const auto& operation : style.transform().operations()) { + if (operation->type() == TransformOperation::ROTATE) { + // For now, just treat this as a full rotation. This could take angle into account to reduce inflation. + floatBounds = boundsOfRotatingRect(floatBounds); + } else { + TransformationMatrix transform; + operation->apply(transform, rendererBox.size()); + if (!transform.isAffine()) + return false; + + if (operation->type() == TransformOperation::MATRIX || operation->type() == TransformOperation::MATRIX_3D) { + TransformationMatrix::Decomposed2Type toDecomp; + transform.decompose2(toDecomp); + // Any rotation prevents us from using a simple start/end rect union. + if (toDecomp.angle) + return false; + } + + floatBounds = transform.mapRect(floatBounds); + } + } + + if (applyTransformOrigin) + floatBounds.moveBy(transformOrigin); + + bounds = LayoutRect(floatBounds); + return true; +} + +bool AnimationBase::computeTransformedExtentViaMatrix(const FloatRect& rendererBox, const RenderStyle& style, LayoutRect& bounds) const +{ + TransformationMatrix transform; + style.applyTransform(transform, rendererBox, RenderStyle::IncludeTransformOrigin); + if (!transform.isAffine()) + return false; + + TransformationMatrix::Decomposed2Type fromDecomp; + transform.decompose2(fromDecomp); + // Any rotation prevents us from using a simple start/end rect union. + if (fromDecomp.angle) + return false; + + bounds = LayoutRect(transform.mapRect(bounds)); + return true; + +} + } // namespace WebCore diff --git a/Source/WebCore/page/animation/AnimationBase.h b/Source/WebCore/page/animation/AnimationBase.h index 51673374d..f3387d2ef 100644 --- a/Source/WebCore/page/animation/AnimationBase.h +++ b/Source/WebCore/page/animation/AnimationBase.h @@ -10,7 +10,7 @@ * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. - * 3. Neither the name of Apple Computer, Inc. ("Apple") nor the names of + * 3. Neither the name of Apple Inc. ("Apple") nor the names of * its contributors may be used to endorse or promote products derived * from this software without specific prior written permission. * @@ -26,23 +26,19 @@ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ -#ifndef AnimationBase_h -#define AnimationBase_h +#pragma once #include "Animation.h" #include "CSSPropertyNames.h" #include "RenderStyleConstants.h" -#include <wtf/HashMap.h> -#include <wtf/HashSet.h> -#include <wtf/RefCounted.h> #include <wtf/text/AtomicString.h> namespace WebCore { -class AnimationBase; -class AnimationController; class CompositeAnimation; class Element; +class FloatRect; +class LayoutRect; class RenderElement; class RenderStyle; class TimingFunction; @@ -50,7 +46,7 @@ class TimingFunction; class AnimationBase : public RefCounted<AnimationBase> { friend class CompositeAnimation; friend class CSSPropertyAnimation; - + WTF_MAKE_FAST_ALLOCATED; public: AnimationBase(const Animation& transition, RenderElement*, CompositeAnimation*); virtual ~AnimationBase() { } @@ -58,9 +54,9 @@ public: RenderElement* renderer() const { return m_object; } void clear() { - endAnimation(); - m_object = 0; - m_compAnim = 0; + endAnimation(); + m_object = nullptr; + m_compositeAnimation = nullptr; } double duration() const; @@ -68,106 +64,129 @@ public: // Animations and Transitions go through the states below. When entering the STARTED state // the animation is started. This may or may not require deferred response from the animator. // If so, we stay in this state until that response is received (and it returns the start time). - // Otherwise, we use the current time as the start time and go immediately to AnimationStateLooping - // or AnimationStateEnding. - enum AnimState { - AnimationStateNew, // animation just created, animation not running yet - AnimationStateStartWaitTimer, // start timer running, waiting for fire - AnimationStateStartWaitStyleAvailable, // waiting for style setup so we can start animations - AnimationStateStartWaitResponse, // animation started, waiting for response - AnimationStateLooping, // response received, animation running, loop timer running, waiting for fire - AnimationStateEnding, // received, animation running, end timer running, waiting for fire - AnimationStatePausedNew, // in pause mode when animation was created - AnimationStatePausedWaitTimer, // in pause mode when animation started - AnimationStatePausedWaitStyleAvailable, // in pause mode when waiting for style setup - AnimationStatePausedWaitResponse, // animation paused when in STARTING state - AnimationStatePausedRun, // animation paused when in LOOPING or ENDING state - AnimationStateDone, // end timer fired, animation finished and removed - AnimationStateFillingForwards // animation has ended and is retaining its final value + // Otherwise, we use the current time as the start time and go immediately to AnimationState::Looping + // or AnimationState::Ending. + enum class AnimationState { + New, // animation just created, animation not running yet + StartWaitTimer, // start timer running, waiting for fire + StartWaitStyleAvailable, // waiting for style setup so we can start animations + StartWaitResponse, // animation started, waiting for response + Looping, // response received, animation running, loop timer running, waiting for fire + Ending, // received, animation running, end timer running, waiting for fire + PausedNew, // in pause mode when animation was created + PausedWaitTimer, // in pause mode when animation started + PausedWaitStyleAvailable, // in pause mode when waiting for style setup + PausedWaitResponse, // animation paused when in STARTING state + PausedRun, // animation paused when in LOOPING or ENDING state + Done, // end timer fired, animation finished and removed + FillingForwards // animation has ended and is retaining its final value }; - enum AnimStateInput { - AnimationStateInputMakeNew, // reset back to new from any state - AnimationStateInputStartAnimation, // animation requests a start - AnimationStateInputRestartAnimation, // force a restart from any state - AnimationStateInputStartTimerFired, // start timer fired - AnimationStateInputStyleAvailable, // style is setup, ready to start animating - AnimationStateInputStartTimeSet, // m_startTime was set - AnimationStateInputLoopTimerFired, // loop timer fired - AnimationStateInputEndTimerFired, // end timer fired - AnimationStateInputPauseOverride, // pause an animation due to override - AnimationStateInputResumeOverride, // resume an overridden animation - AnimationStateInputPlayStateRunning, // play state paused -> running - AnimationStateInputPlayStatePaused, // play state running -> paused - AnimationStateInputEndAnimation // force an end from any state + enum class AnimationStateInput { + MakeNew, // reset back to new from any state + StartAnimation, // animation requests a start + RestartAnimation, // force a restart from any state + StartTimerFired, // start timer fired + StyleAvailable, // style is setup, ready to start animating + StartTimeSet, // m_startTime was set + LoopTimerFired, // loop timer fired + EndTimerFired, // end timer fired + PauseOverride, // pause an animation due to override + ResumeOverride, // resume an overridden animation + PlayStateRunning, // play state paused -> running + PlayStatePaused, // play state running -> paused + EndAnimation // force an end from any state }; - // Called when animation is in AnimationStateNew to start animation - void updateStateMachine(AnimStateInput, double param); + // Called when animation is in AnimationState::New to start animation + void updateStateMachine(AnimationStateInput, double param); // Animation has actually started, at passed time void onAnimationStartResponse(double startTime) { - updateStateMachine(AnimationBase::AnimationStateInputStartTimeSet, startTime); + updateStateMachine(AnimationStateInput::StartTimeSet, startTime); } // Called to change to or from paused state void updatePlayState(EAnimPlayState); bool playStatePlaying() const; - bool waitingToStart() const { return m_animState == AnimationStateNew || m_animState == AnimationStateStartWaitTimer || m_animState == AnimationStatePausedNew; } + bool waitingToStart() const { return m_animationState == AnimationState::New || m_animationState == AnimationState::StartWaitTimer || m_animationState == AnimationState::PausedNew; } bool preActive() const { - return m_animState == AnimationStateNew || m_animState == AnimationStateStartWaitTimer || m_animState == AnimationStateStartWaitStyleAvailable || m_animState == AnimationStateStartWaitResponse; + return m_animationState == AnimationState::New || m_animationState == AnimationState::StartWaitTimer || m_animationState == AnimationState::StartWaitStyleAvailable || m_animationState == AnimationState::StartWaitResponse; } - bool postActive() const { return m_animState == AnimationStateDone; } + bool postActive() const { return m_animationState == AnimationState::Done; } + bool fillingForwards() const { return m_animationState == AnimationState::FillingForwards; } bool active() const { return !postActive() && !preActive(); } bool running() const { return !isNew() && !postActive(); } - bool paused() const { return m_pauseTime >= 0 || m_animState == AnimationStatePausedNew; } - bool isNew() const { return m_animState == AnimationStateNew || m_animState == AnimationStatePausedNew; } - bool waitingForStartTime() const { return m_animState == AnimationStateStartWaitResponse; } - bool waitingForStyleAvailable() const { return m_animState == AnimationStateStartWaitStyleAvailable; } + bool paused() const { return m_pauseTime || m_animationState == AnimationState::PausedNew; } + bool inPausedState() const { return m_animationState >= AnimationState::PausedNew && m_animationState <= AnimationState::PausedRun; } + bool isNew() const { return m_animationState == AnimationState::New || m_animationState == AnimationState::PausedNew; } + bool waitingForStartTime() const { return m_animationState == AnimationState::StartWaitResponse; } + bool waitingForStyleAvailable() const { return m_animationState == AnimationState::StartWaitStyleAvailable; } + + bool isAccelerated() const { return m_isAccelerated; } virtual double timeToNextService(); - double progress(double scale, double offset, const TimingFunction*) const; + double progress(double scale = 1, double offset = 0, const TimingFunction* = nullptr) const; - virtual void animate(CompositeAnimation*, RenderElement*, const RenderStyle* /*currentStyle*/, RenderStyle* /*targetStyle*/, RefPtr<RenderStyle>& /*animatedStyle*/) = 0; - virtual void getAnimatedStyle(RefPtr<RenderStyle>& /*animatedStyle*/) = 0; + // Returns true if the animation state changed. + virtual bool animate(CompositeAnimation*, RenderElement*, const RenderStyle* /*currentStyle*/, const RenderStyle* /*targetStyle*/, std::unique_ptr<RenderStyle>& /*animatedStyle*/, bool& didBlendStyle) = 0; + virtual void getAnimatedStyle(std::unique_ptr<RenderStyle>& /*animatedStyle*/) = 0; + + virtual bool computeExtentOfTransformAnimation(LayoutRect&) const = 0; virtual bool shouldFireEvents() const { return false; } void fireAnimationEventsIfNeeded(); - bool animationsMatch(const Animation*) const; + bool animationsMatch(const Animation&) const; - void setAnimation(const Animation& animation) { m_animation = const_cast<Animation*>(&animation); } + const Animation& animation() const { return m_animation; } + void setAnimation(const Animation& animation) { m_animation = const_cast<Animation&>(animation); } // Return true if this animation is overridden. This will only be the case for // ImplicitAnimations and is used to determine whether or not we should force // set the start time. If an animation is overridden, it will probably not get - // back the AnimationStateInputStartTimeSet input. + // back the AnimationStateInput::StartTimeSet input. virtual bool overridden() const { return false; } // Does this animation/transition involve the given property? virtual bool affectsProperty(CSSPropertyID /*property*/) const { return false; } - bool isAnimatingProperty(CSSPropertyID property, bool acceleratedOnly, bool isRunningNow) const + enum RunningStates { + Delaying = 1 << 0, + Paused = 1 << 1, + Running = 1 << 2, + }; + typedef unsigned RunningState; + bool isAnimatingProperty(CSSPropertyID property, bool acceleratedOnly, RunningState runningState) const { if (acceleratedOnly && !m_isAccelerated) return false; - - if (isRunningNow) - return (!waitingToStart() && !postActive()) && affectsProperty(property); - return !postActive() && affectsProperty(property); + if (!affectsProperty(property)) + return false; + + if ((runningState & Delaying) && preActive()) + return true; + + if ((runningState & Paused) && inPausedState()) + return true; + + if ((runningState & Running) && !inPausedState() && (m_animationState >= AnimationState::StartWaitStyleAvailable && m_animationState < AnimationState::Done)) + return true; + + return false; } - // FIXME: rename this using the "lists match" terminology. - bool isTransformFunctionListValid() const { return m_transformFunctionListValid; } -#if ENABLE(CSS_FILTERS) + bool transformFunctionListsMatch() const { return m_transformFunctionListsMatch; } bool filterFunctionListsMatch() const { return m_filterFunctionListsMatch; } +#if ENABLE(FILTERS_LEVEL_2) + bool backdropFilterFunctionListsMatch() const { return m_backdropFilterFunctionListsMatch; } #endif // Freeze the animation; used by DumpRenderTree. @@ -186,16 +205,14 @@ public: void styleAvailable() { ASSERT(waitingForStyleAvailable()); - updateStateMachine(AnimationBase::AnimationStateInputStyleAvailable, -1); + updateStateMachine(AnimationStateInput::StyleAvailable, -1); } - const Animation& animation() const { return *m_animation; } - protected: virtual void overrideAnimations() { } virtual void resumeOverriddenAnimations() { } - CompositeAnimation* compositeAnimation() { return m_compAnim; } + CompositeAnimation* compositeAnimation() { return m_compositeAnimation; } // These are called when the corresponding timer fires so subclasses can do any extra work virtual void onAnimationStart(double /*elapsedTime*/) { } @@ -211,7 +228,7 @@ protected: void goIntoEndingOrLoopingState(); - bool isAccelerated() const { return m_isAccelerated; } + AnimationState state() const { return m_animationState; } static void setNeedsStyleRecalc(Element*); @@ -219,26 +236,27 @@ protected: double fractionalTime(double scale, double elapsedTime, double offset) const; - AnimState m_animState; - - bool m_isAccelerated; - bool m_transformFunctionListValid; -#if ENABLE(CSS_FILTERS) - bool m_filterFunctionListsMatch; -#endif - double m_startTime; - double m_pauseTime; - double m_requestedStartTime; - - double m_totalDuration; - double m_nextIterationDuration; + // These return true if we can easily compute a bounding box by applying the style's transform to the bounds rect. + bool computeTransformedExtentViaTransformList(const FloatRect& rendererBox, const RenderStyle&, LayoutRect& bounds) const; + bool computeTransformedExtentViaMatrix(const FloatRect& rendererBox, const RenderStyle&, LayoutRect& bounds) const; RenderElement* m_object; - - RefPtr<Animation> m_animation; - CompositeAnimation* m_compAnim; + CompositeAnimation* m_compositeAnimation; // Ideally this would be a reference, but it has to be cleared if an animation is destroyed inside an event callback. + Ref<Animation> m_animation; + + std::optional<double> m_startTime; + std::optional<double> m_pauseTime; + double m_requestedStartTime { 0 }; + std::optional<double> m_totalDuration; + std::optional<double> m_nextIterationDuration; + + AnimationState m_animationState { AnimationState::New }; + bool m_isAccelerated { false }; + bool m_transformFunctionListsMatch { false }; + bool m_filterFunctionListsMatch { false }; +#if ENABLE(FILTERS_LEVEL_2) + bool m_backdropFilterFunctionListsMatch { false }; +#endif }; } // namespace WebCore - -#endif // AnimationBase_h diff --git a/Source/WebCore/page/animation/AnimationController.cpp b/Source/WebCore/page/animation/AnimationController.cpp deleted file mode 100644 index 5b8c90b8a..000000000 --- a/Source/WebCore/page/animation/AnimationController.cpp +++ /dev/null @@ -1,645 +0,0 @@ -/* - * Copyright (C) 2007, 2008, 2009 Apple 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: - * - * 1. Redistributions of source code must retain the above copyright - * notice, this list of conditions and the following disclaimer. - * 2. Redistributions in binary form must reproduce the above copyright - * notice, this list of conditions and the following disclaimer in the - * documentation and/or other materials provided with the distribution. - * 3. Neither the name of Apple Computer, Inc. ("Apple") nor the names of - * its contributors may be used to endorse or promote products derived - * from this software without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY APPLE AND ITS CONTRIBUTORS "AS IS" AND ANY - * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED - * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE - * DISCLAIMED. IN NO EVENT SHALL APPLE OR ITS CONTRIBUTORS BE LIABLE FOR ANY - * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES - * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; - * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND - * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT - * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF - * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - */ - -#include "config.h" -#include "AnimationController.h" - -#include "AnimationBase.h" -#include "AnimationControllerPrivate.h" -#include "CSSParser.h" -#include "CSSPropertyAnimation.h" -#include "CompositeAnimation.h" -#include "EventNames.h" -#include "Frame.h" -#include "FrameView.h" -#include "Logging.h" -#include "PseudoElement.h" -#include "RenderView.h" -#include "TransitionEvent.h" -#include "WebKitAnimationEvent.h" -#include "WebKitTransitionEvent.h" -#include <wtf/CurrentTime.h> - -namespace WebCore { - -static const double cAnimationTimerDelay = 0.025; -static const double cBeginAnimationUpdateTimeNotSet = -1; - -AnimationControllerPrivate::AnimationControllerPrivate(Frame& frame) - : m_animationTimer(this, &AnimationControllerPrivate::animationTimerFired) - , m_updateStyleIfNeededDispatcher(this, &AnimationControllerPrivate::updateStyleIfNeededDispatcherFired) - , m_frame(frame) - , m_beginAnimationUpdateTime(cBeginAnimationUpdateTimeNotSet) - , m_animationsWaitingForStyle() - , m_animationsWaitingForStartTimeResponse() - , m_waitingForAsyncStartNotification(false) - , m_isSuspended(false) - , m_allowsNewAnimationsWhileSuspended(false) -{ -} - -AnimationControllerPrivate::~AnimationControllerPrivate() -{ -} - -CompositeAnimation& AnimationControllerPrivate::ensureCompositeAnimation(RenderElement* renderer) -{ - auto result = m_compositeAnimations.add(renderer, nullptr); - if (result.isNewEntry) - result.iterator->value = CompositeAnimation::create(this); - return *result.iterator->value; -} - -bool AnimationControllerPrivate::clear(RenderElement* renderer) -{ - // Return false if we didn't do anything OR we are suspended (so we don't try to - // do a setNeedsStyleRecalc() when suspended). - RefPtr<CompositeAnimation> animation = m_compositeAnimations.take(renderer); - if (!animation) - return false; - animation->clearRenderer(); - return animation->isSuspended(); -} - -double AnimationControllerPrivate::updateAnimations(SetChanged callSetChanged/* = DoNotCallSetChanged*/) -{ - double timeToNextService = -1; - bool calledSetChanged = false; - - auto end = m_compositeAnimations.end(); - for (auto it = m_compositeAnimations.begin(); it != end; ++it) { - CompositeAnimation& animation = *it->value; - if (!animation.isSuspended() && animation.hasAnimations()) { - double t = animation.timeToNextService(); - if (t != -1 && (t < timeToNextService || timeToNextService == -1)) - timeToNextService = t; - if (!timeToNextService) { - if (callSetChanged != CallSetChanged) - break; - Element* element = it->key->element(); - ASSERT(element); - ASSERT(!element->document().inPageCache()); - element->setNeedsStyleRecalc(SyntheticStyleChange); - calledSetChanged = true; - } - } - } - - if (calledSetChanged) - m_frame.document()->updateStyleIfNeeded(); - - return timeToNextService; -} - -void AnimationControllerPrivate::updateAnimationTimerForRenderer(RenderElement* renderer) -{ - double timeToNextService = 0; - - const CompositeAnimation* compositeAnimation = m_compositeAnimations.get(renderer); - if (!compositeAnimation->isSuspended() && compositeAnimation->hasAnimations()) - timeToNextService = compositeAnimation->timeToNextService(); - - if (m_animationTimer.isActive() && (m_animationTimer.repeatInterval() || m_animationTimer.nextFireInterval() <= timeToNextService)) - return; - - m_animationTimer.startOneShot(timeToNextService); -} - -void AnimationControllerPrivate::updateAnimationTimer(SetChanged callSetChanged/* = DoNotCallSetChanged*/) -{ - double timeToNextService = updateAnimations(callSetChanged); - - LOG(Animations, "updateAnimationTimer: timeToNextService is %.2f", timeToNextService); - - // If we want service immediately, we start a repeating timer to reduce the overhead of starting - if (!timeToNextService) { - if (!m_animationTimer.isActive() || m_animationTimer.repeatInterval() == 0) - m_animationTimer.startRepeating(cAnimationTimerDelay); - return; - } - - // If we don't need service, we want to make sure the timer is no longer running - if (timeToNextService < 0) { - if (m_animationTimer.isActive()) - m_animationTimer.stop(); - return; - } - - // Otherwise, we want to start a one-shot timer so we get here again - m_animationTimer.startOneShot(timeToNextService); -} - -void AnimationControllerPrivate::updateStyleIfNeededDispatcherFired(Timer<AnimationControllerPrivate>&) -{ - fireEventsAndUpdateStyle(); -} - -void AnimationControllerPrivate::fireEventsAndUpdateStyle() -{ - // Protect the frame from getting destroyed in the event handler - Ref<Frame> protector(m_frame); - - bool updateStyle = !m_eventsToDispatch.isEmpty() || !m_elementChangesToDispatch.isEmpty(); - - // fire all the events - Vector<EventToDispatch> eventsToDispatch = std::move(m_eventsToDispatch); - Vector<EventToDispatch>::const_iterator eventsToDispatchEnd = eventsToDispatch.end(); - for (Vector<EventToDispatch>::const_iterator it = eventsToDispatch.begin(); it != eventsToDispatchEnd; ++it) { - Element* element = it->element.get(); - if (it->eventType == eventNames().transitionendEvent) - element->dispatchEvent(TransitionEvent::create(it->eventType, it->name, it->elapsedTime, PseudoElement::pseudoElementNameForEvents(element->pseudoId()))); - else - element->dispatchEvent(WebKitAnimationEvent::create(it->eventType, it->name, it->elapsedTime)); - } - - for (unsigned i = 0, size = m_elementChangesToDispatch.size(); i < size; ++i) - m_elementChangesToDispatch[i]->setNeedsStyleRecalc(SyntheticStyleChange); - - m_elementChangesToDispatch.clear(); - - if (updateStyle) - m_frame.document()->updateStyleIfNeeded(); -} - -void AnimationControllerPrivate::startUpdateStyleIfNeededDispatcher() -{ - if (!m_updateStyleIfNeededDispatcher.isActive()) - m_updateStyleIfNeededDispatcher.startOneShot(0); -} - -void AnimationControllerPrivate::addEventToDispatch(PassRefPtr<Element> element, const AtomicString& eventType, const String& name, double elapsedTime) -{ - m_eventsToDispatch.grow(m_eventsToDispatch.size()+1); - EventToDispatch& event = m_eventsToDispatch[m_eventsToDispatch.size()-1]; - event.element = element; - event.eventType = eventType; - event.name = name; - event.elapsedTime = elapsedTime; - - startUpdateStyleIfNeededDispatcher(); -} - -void AnimationControllerPrivate::addElementChangeToDispatch(PassRef<Element> element) -{ - m_elementChangesToDispatch.append(std::move(element)); - ASSERT(!m_elementChangesToDispatch.last()->document().inPageCache()); - startUpdateStyleIfNeededDispatcher(); -} - -#if ENABLE(REQUEST_ANIMATION_FRAME) -void AnimationControllerPrivate::animationFrameCallbackFired() -{ - double timeToNextService = updateAnimations(CallSetChanged); - - if (timeToNextService >= 0) - m_frame.document()->view()->scheduleAnimation(); -} -#endif - -void AnimationControllerPrivate::animationTimerFired(Timer<AnimationControllerPrivate>&) -{ - // Make sure animationUpdateTime is updated, so that it is current even if no - // styleChange has happened (e.g. accelerated animations) - setBeginAnimationUpdateTime(cBeginAnimationUpdateTimeNotSet); - - // When the timer fires, all we do is call setChanged on all DOM nodes with running animations and then do an immediate - // updateStyleIfNeeded. It will then call back to us with new information. - updateAnimationTimer(CallSetChanged); - - // Fire events right away, to avoid a flash of unanimated style after an animation completes, and before - // the 'end' event fires. - fireEventsAndUpdateStyle(); -} - -bool AnimationControllerPrivate::isRunningAnimationOnRenderer(RenderElement* renderer, CSSPropertyID property, bool isRunningNow) const -{ - const CompositeAnimation* animation = m_compositeAnimations.get(renderer); - return animation && animation->isAnimatingProperty(property, false, isRunningNow); -} - -bool AnimationControllerPrivate::isRunningAcceleratedAnimationOnRenderer(RenderElement* renderer, CSSPropertyID property, bool isRunningNow) const -{ - const CompositeAnimation* animation = m_compositeAnimations.get(renderer); - return animation && animation->isAnimatingProperty(property, true, isRunningNow); -} - -void AnimationControllerPrivate::suspendAnimations() -{ - if (isSuspended()) - return; - - suspendAnimationsForDocument(m_frame.document()); - - // Traverse subframes - for (Frame* child = m_frame.tree().firstChild(); child; child = child->tree().nextSibling()) - child->animation().suspendAnimations(); - - m_isSuspended = true; -} - -void AnimationControllerPrivate::resumeAnimations() -{ - if (!isSuspended()) - return; - - resumeAnimationsForDocument(m_frame.document()); - - // Traverse subframes - for (Frame* child = m_frame.tree().firstChild(); child; child = child->tree().nextSibling()) - child->animation().resumeAnimations(); - - m_isSuspended = false; -} - -void AnimationControllerPrivate::suspendAnimationsForDocument(Document* document) -{ - setBeginAnimationUpdateTime(cBeginAnimationUpdateTimeNotSet); - - for (auto it = m_compositeAnimations.begin(), end = m_compositeAnimations.end(); it != end; ++it) { - if (&it->key->document() == document) - it->value->suspendAnimations(); - } - - updateAnimationTimer(); -} - -void AnimationControllerPrivate::resumeAnimationsForDocument(Document* document) -{ - setBeginAnimationUpdateTime(cBeginAnimationUpdateTimeNotSet); - - for (auto it = m_compositeAnimations.begin(), end = m_compositeAnimations.end(); it != end; ++it) { - if (&it->key->document() == document) - it->value->resumeAnimations(); - } - - updateAnimationTimer(); -} - -void AnimationControllerPrivate::startAnimationsIfNotSuspended(Document* document) -{ - if (!isSuspended() || allowsNewAnimationsWhileSuspended()) - resumeAnimationsForDocument(document); -} - -void AnimationControllerPrivate::setAllowsNewAnimationsWhileSuspended(bool allowed) -{ - m_allowsNewAnimationsWhileSuspended = allowed; -} - -bool AnimationControllerPrivate::pauseAnimationAtTime(RenderElement* renderer, const AtomicString& name, double t) -{ - if (!renderer) - return false; - - CompositeAnimation& compositeAnimation = ensureCompositeAnimation(renderer); - if (compositeAnimation.pauseAnimationAtTime(name, t)) { - renderer->element()->setNeedsStyleRecalc(SyntheticStyleChange); - startUpdateStyleIfNeededDispatcher(); - return true; - } - - return false; -} - -bool AnimationControllerPrivate::pauseTransitionAtTime(RenderElement* renderer, const String& property, double t) -{ - if (!renderer) - return false; - - CompositeAnimation& compositeAnimation = ensureCompositeAnimation(renderer); - if (compositeAnimation.pauseTransitionAtTime(cssPropertyID(property), t)) { - renderer->element()->setNeedsStyleRecalc(SyntheticStyleChange); - startUpdateStyleIfNeededDispatcher(); - return true; - } - - return false; -} - -double AnimationControllerPrivate::beginAnimationUpdateTime() -{ - if (m_beginAnimationUpdateTime == cBeginAnimationUpdateTimeNotSet) - m_beginAnimationUpdateTime = monotonicallyIncreasingTime(); - return m_beginAnimationUpdateTime; -} - -void AnimationControllerPrivate::endAnimationUpdate() -{ - styleAvailable(); - if (!m_waitingForAsyncStartNotification) - startTimeResponse(beginAnimationUpdateTime()); -} - -void AnimationControllerPrivate::receivedStartTimeResponse(double time) -{ - m_waitingForAsyncStartNotification = false; - startTimeResponse(time); -} - -PassRefPtr<RenderStyle> AnimationControllerPrivate::getAnimatedStyleForRenderer(RenderElement* renderer) -{ - if (!renderer) - return 0; - - const CompositeAnimation* rendererAnimations = m_compositeAnimations.get(renderer); - if (!rendererAnimations) - return &renderer->style(); - - RefPtr<RenderStyle> animatingStyle = rendererAnimations->getAnimatedStyle(); - if (!animatingStyle) - animatingStyle = &renderer->style(); - - return animatingStyle.release(); -} - -unsigned AnimationControllerPrivate::numberOfActiveAnimations(Document* document) const -{ - unsigned count = 0; - - for (auto it = m_compositeAnimations.begin(), end = m_compositeAnimations.end(); it != end; ++it) { - if (&it->key->document() == document) - count += it->value->numberOfActiveAnimations(); - } - - return count; -} - -void AnimationControllerPrivate::addToAnimationsWaitingForStyle(AnimationBase* animation) -{ - // Make sure this animation is not in the start time waiters - m_animationsWaitingForStartTimeResponse.remove(animation); - - m_animationsWaitingForStyle.add(animation); -} - -void AnimationControllerPrivate::removeFromAnimationsWaitingForStyle(AnimationBase* animationToRemove) -{ - m_animationsWaitingForStyle.remove(animationToRemove); -} - -void AnimationControllerPrivate::styleAvailable() -{ - // Go through list of waiters and send them on their way - for (const auto& waitingAnimation : m_animationsWaitingForStyle) - waitingAnimation->styleAvailable(); - - m_animationsWaitingForStyle.clear(); -} - -void AnimationControllerPrivate::addToAnimationsWaitingForStartTimeResponse(AnimationBase* animation, bool willGetResponse) -{ - // If willGetResponse is true, it means this animation is actually waiting for a response - // (which will come in as a call to notifyAnimationStarted()). - // In that case we don't need to add it to this list. We just set a waitingForAResponse flag - // which says we are waiting for the response. If willGetResponse is false, this animation - // is not waiting for a response for itself, but rather for a notifyXXXStarted() call for - // another animation to which it will sync. - // - // When endAnimationUpdate() is called we check to see if the waitingForAResponse flag is - // true. If so, we just return and will do our work when the first notifyXXXStarted() call - // comes in. If it is false, we will not be getting a notifyXXXStarted() call, so we will - // do our work right away. In both cases we call the onAnimationStartResponse() method - // on each animation. In the first case we send in the time we got from notifyXXXStarted(). - // In the second case, we just pass in the beginAnimationUpdateTime(). - // - // This will synchronize all software and accelerated animations started in the same - // updateStyleIfNeeded cycle. - // - - if (willGetResponse) - m_waitingForAsyncStartNotification = true; - - m_animationsWaitingForStartTimeResponse.add(animation); -} - -void AnimationControllerPrivate::removeFromAnimationsWaitingForStartTimeResponse(AnimationBase* animationToRemove) -{ - m_animationsWaitingForStartTimeResponse.remove(animationToRemove); - - if (m_animationsWaitingForStartTimeResponse.isEmpty()) - m_waitingForAsyncStartNotification = false; -} - -void AnimationControllerPrivate::startTimeResponse(double time) -{ - // Go through list of waiters and send them on their way - - for (const auto& animation : m_animationsWaitingForStartTimeResponse) - animation->onAnimationStartResponse(time); - - m_animationsWaitingForStartTimeResponse.clear(); - m_waitingForAsyncStartNotification = false; -} - -void AnimationControllerPrivate::animationWillBeRemoved(AnimationBase* animation) -{ - removeFromAnimationsWaitingForStyle(animation); - removeFromAnimationsWaitingForStartTimeResponse(animation); -} - -AnimationController::AnimationController(Frame& frame) - : m_data(std::make_unique<AnimationControllerPrivate>(frame)) - , m_beginAnimationUpdateCount(0) -{ -} - -AnimationController::~AnimationController() -{ -} - -void AnimationController::cancelAnimations(RenderElement* renderer) -{ - if (!m_data->hasAnimations()) - return; - - if (m_data->clear(renderer)) { - Element* element = renderer->element(); - ASSERT(!element || !element->document().inPageCache()); - if (element) - element->setNeedsStyleRecalc(SyntheticStyleChange); - } -} - -PassRef<RenderStyle> AnimationController::updateAnimations(RenderElement& renderer, PassRef<RenderStyle> newStyle) -{ - // Don't do anything if we're in the cache - if (renderer.document().inPageCache()) - return newStyle; - - RenderStyle* oldStyle = renderer.hasInitializedStyle() ? &renderer.style() : nullptr; - - if ((!oldStyle || (!oldStyle->animations() && !oldStyle->transitions())) && (!newStyle.get().animations() && !newStyle.get().transitions())) - return newStyle; - - // Don't run transitions when printing. - if (renderer.view().printing()) - return newStyle; - - // Fetch our current set of implicit animations from a hashtable. We then compare them - // against the animations in the style and make sure we're in sync. If destination values - // have changed, we reset the animation. We then do a blend to get new values and we return - // a new style. - - // We don't support anonymous pseudo elements like :first-line or :first-letter. - ASSERT(renderer.element()); - - Ref<RenderStyle> newStyleBeforeAnimation(std::move(newStyle)); - - CompositeAnimation& rendererAnimations = m_data->ensureCompositeAnimation(&renderer); - auto blendedStyle = rendererAnimations.animate(renderer, oldStyle, newStyleBeforeAnimation.get()); - - if (renderer.parent() || newStyleBeforeAnimation->animations() || (oldStyle && oldStyle->animations())) { - m_data->updateAnimationTimerForRenderer(&renderer); -#if ENABLE(REQUEST_ANIMATION_FRAME) - renderer.view().frameView().scheduleAnimation(); -#endif - } - - if (&blendedStyle.get() != &newStyleBeforeAnimation.get()) { - // If the animations/transitions change opacity or transform, we need to update - // the style to impose the stacking rules. Note that this is also - // done in StyleResolver::adjustRenderStyle(). - if (blendedStyle.get().hasAutoZIndex() && (blendedStyle.get().opacity() < 1.0f || blendedStyle.get().hasTransform())) - blendedStyle.get().setZIndex(0); - } - return blendedStyle; -} - -PassRefPtr<RenderStyle> AnimationController::getAnimatedStyleForRenderer(RenderElement* renderer) -{ - return m_data->getAnimatedStyleForRenderer(renderer); -} - -void AnimationController::notifyAnimationStarted(RenderElement*, double startTime) -{ - m_data->receivedStartTimeResponse(startTime); -} - -bool AnimationController::pauseAnimationAtTime(RenderElement* renderer, const AtomicString& name, double t) -{ - return m_data->pauseAnimationAtTime(renderer, name, t); -} - -unsigned AnimationController::numberOfActiveAnimations(Document* document) const -{ - return m_data->numberOfActiveAnimations(document); -} - -bool AnimationController::pauseTransitionAtTime(RenderElement* renderer, const String& property, double t) -{ - return m_data->pauseTransitionAtTime(renderer, property, t); -} - -bool AnimationController::isRunningAnimationOnRenderer(RenderElement* renderer, CSSPropertyID property, bool isRunningNow) const -{ - return m_data->isRunningAnimationOnRenderer(renderer, property, isRunningNow); -} - -bool AnimationController::isRunningAcceleratedAnimationOnRenderer(RenderElement* renderer, CSSPropertyID property, bool isRunningNow) const -{ - return m_data->isRunningAcceleratedAnimationOnRenderer(renderer, property, isRunningNow); -} - -bool AnimationController::isSuspended() const -{ - return m_data->isSuspended(); -} - -void AnimationController::suspendAnimations() -{ - LOG(Animations, "controller is suspending animations"); - m_data->suspendAnimations(); -} - -void AnimationController::resumeAnimations() -{ - LOG(Animations, "controller is resuming animations"); - m_data->resumeAnimations(); -} - -bool AnimationController::allowsNewAnimationsWhileSuspended() const -{ - return m_data->allowsNewAnimationsWhileSuspended(); -} - -void AnimationController::setAllowsNewAnimationsWhileSuspended(bool allowed) -{ - m_data->setAllowsNewAnimationsWhileSuspended(allowed); -} - -#if ENABLE(REQUEST_ANIMATION_FRAME) -void AnimationController::serviceAnimations() -{ - m_data->animationFrameCallbackFired(); -} -#endif - -void AnimationController::suspendAnimationsForDocument(Document* document) -{ - LOG(Animations, "suspending animations for document %p", document); - m_data->suspendAnimationsForDocument(document); -} - -void AnimationController::resumeAnimationsForDocument(Document* document) -{ - LOG(Animations, "resuming animations for document %p", document); - m_data->resumeAnimationsForDocument(document); -} - -void AnimationController::startAnimationsIfNotSuspended(Document* document) -{ - LOG(Animations, "animations may start for document %p", document); - m_data->startAnimationsIfNotSuspended(document); -} - -void AnimationController::beginAnimationUpdate() -{ - if (!m_beginAnimationUpdateCount) - m_data->setBeginAnimationUpdateTime(cBeginAnimationUpdateTimeNotSet); - ++m_beginAnimationUpdateCount; -} - -void AnimationController::endAnimationUpdate() -{ - ASSERT(m_beginAnimationUpdateCount > 0); - --m_beginAnimationUpdateCount; - if (!m_beginAnimationUpdateCount) - m_data->endAnimationUpdate(); -} - -bool AnimationController::supportsAcceleratedAnimationOfProperty(CSSPropertyID property) -{ -#if USE(ACCELERATED_COMPOSITING) - return CSSPropertyAnimation::animationOfPropertyIsAccelerated(property); -#else - UNUSED_PARAM(property); - return false; -#endif -} - -} // namespace WebCore diff --git a/Source/WebCore/page/animation/CSSAnimationController.cpp b/Source/WebCore/page/animation/CSSAnimationController.cpp new file mode 100644 index 000000000..b71ed2e43 --- /dev/null +++ b/Source/WebCore/page/animation/CSSAnimationController.cpp @@ -0,0 +1,805 @@ +/* + * Copyright (C) 2007, 2008, 2009 Apple 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: + * + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * 3. Neither the name of Apple Inc. ("Apple") nor the names of + * its contributors may be used to endorse or promote products derived + * from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY APPLE AND ITS CONTRIBUTORS "AS IS" AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL APPLE OR ITS CONTRIBUTORS BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#include "config.h" +#include "CSSAnimationController.h" + +#include "AnimationBase.h" +#include "AnimationEvent.h" +#include "CSSAnimationControllerPrivate.h" +#include "CSSPropertyAnimation.h" +#include "CSSPropertyParser.h" +#include "CompositeAnimation.h" +#include "EventNames.h" +#include "Frame.h" +#include "FrameView.h" +#include "Logging.h" +#include "PseudoElement.h" +#include "RenderView.h" +#include "TransitionEvent.h" +#include "WebKitAnimationEvent.h" +#include "WebKitTransitionEvent.h" +#include <wtf/CurrentTime.h> + +namespace WebCore { + +// Allow a little more than 60fps to make sure we can at least hit that frame rate. +static const double cAnimationTimerDelay = 0.015; +static const double cBeginAnimationUpdateTimeNotSet = -1; + +class AnimationPrivateUpdateBlock { +public: + AnimationPrivateUpdateBlock(CSSAnimationControllerPrivate& animationController) + : m_animationController(animationController) + { + m_animationController.beginAnimationUpdate(); + } + + ~AnimationPrivateUpdateBlock() + { + m_animationController.endAnimationUpdate(); + } + + CSSAnimationControllerPrivate& m_animationController; +}; + +CSSAnimationControllerPrivate::CSSAnimationControllerPrivate(Frame& frame) + : m_animationTimer(*this, &CSSAnimationControllerPrivate::animationTimerFired) + , m_updateStyleIfNeededDispatcher(*this, &CSSAnimationControllerPrivate::updateStyleIfNeededDispatcherFired) + , m_frame(frame) + , m_beginAnimationUpdateTime(cBeginAnimationUpdateTimeNotSet) + , m_beginAnimationUpdateCount(0) + , m_waitingForAsyncStartNotification(false) + , m_isSuspended(false) + , m_allowsNewAnimationsWhileSuspended(false) +{ +} + +CSSAnimationControllerPrivate::~CSSAnimationControllerPrivate() +{ +} + +CompositeAnimation& CSSAnimationControllerPrivate::ensureCompositeAnimation(RenderElement& renderer) +{ + auto result = m_compositeAnimations.add(&renderer, nullptr); + if (result.isNewEntry) { + result.iterator->value = CompositeAnimation::create(*this); + renderer.setIsCSSAnimating(true); + } + + if (animationsAreSuspendedForDocument(&renderer.document())) + result.iterator->value->suspendAnimations(); + + return *result.iterator->value; +} + +bool CSSAnimationControllerPrivate::clear(RenderElement& renderer) +{ + LOG(Animations, "CSSAnimationControllerPrivate %p clear: %p", this, &renderer); + + ASSERT(renderer.isCSSAnimating()); + ASSERT(m_compositeAnimations.contains(&renderer)); + + Element* element = renderer.element(); + + m_eventsToDispatch.removeAllMatching([element] (const EventToDispatch& info) { + return info.element.ptr() == element; + }); + + m_elementChangesToDispatch.removeAllMatching([element](auto& currentElement) { + return currentElement.ptr() == element; + }); + + // Return false if we didn't do anything OR we are suspended (so we don't try to + // do a invalidateStyleForSubtree() when suspended). + RefPtr<CompositeAnimation> animation = m_compositeAnimations.take(&renderer); + ASSERT(animation); + renderer.setIsCSSAnimating(false); + animation->clearRenderer(); + return animation->isSuspended(); +} + +double CSSAnimationControllerPrivate::updateAnimations(SetChanged callSetChanged/* = DoNotCallSetChanged*/) +{ + AnimationPrivateUpdateBlock updateBlock(*this); + double timeToNextService = -1; + bool calledSetChanged = false; + + for (auto& compositeAnimation : m_compositeAnimations) { + CompositeAnimation& animation = *compositeAnimation.value; + if (!animation.isSuspended() && animation.hasAnimations()) { + double t = animation.timeToNextService(); + if (t != -1 && (t < timeToNextService || timeToNextService == -1)) + timeToNextService = t; + if (!timeToNextService) { + if (callSetChanged != CallSetChanged) + break; + Element* element = compositeAnimation.key->element(); + ASSERT(element); + ASSERT(element->document().pageCacheState() == Document::NotInPageCache); + element->invalidateStyleAndLayerComposition(); + calledSetChanged = true; + } + } + } + + if (calledSetChanged) + m_frame.document()->updateStyleIfNeeded(); + + return timeToNextService; +} + +void CSSAnimationControllerPrivate::updateAnimationTimerForRenderer(RenderElement& renderer) +{ + double timeToNextService = 0; + + const CompositeAnimation* compositeAnimation = m_compositeAnimations.get(&renderer); + if (!compositeAnimation->isSuspended() && compositeAnimation->hasAnimations()) + timeToNextService = compositeAnimation->timeToNextService(); + + if (m_animationTimer.isActive() && (m_animationTimer.repeatInterval() || m_animationTimer.nextFireInterval() <= timeToNextService)) + return; + + m_animationTimer.startOneShot(timeToNextService); +} + +void CSSAnimationControllerPrivate::updateAnimationTimer(SetChanged callSetChanged/* = DoNotCallSetChanged*/) +{ + double timeToNextService = updateAnimations(callSetChanged); + + LOG(Animations, "updateAnimationTimer: timeToNextService is %.2f", timeToNextService); + + // If we want service immediately, we start a repeating timer to reduce the overhead of starting + if (!timeToNextService) { + if (!m_animationTimer.isActive() || !m_animationTimer.repeatInterval()) + m_animationTimer.startRepeating(cAnimationTimerDelay); + return; + } + + // If we don't need service, we want to make sure the timer is no longer running + if (timeToNextService < 0) { + if (m_animationTimer.isActive()) + m_animationTimer.stop(); + return; + } + + // Otherwise, we want to start a one-shot timer so we get here again + m_animationTimer.startOneShot(timeToNextService); +} + +void CSSAnimationControllerPrivate::updateStyleIfNeededDispatcherFired() +{ + fireEventsAndUpdateStyle(); +} + +void CSSAnimationControllerPrivate::fireEventsAndUpdateStyle() +{ + // Protect the frame from getting destroyed in the event handler + Ref<Frame> protector(m_frame); + + bool updateStyle = !m_eventsToDispatch.isEmpty() || !m_elementChangesToDispatch.isEmpty(); + + // fire all the events + Vector<EventToDispatch> eventsToDispatch = WTFMove(m_eventsToDispatch); + for (auto& event : eventsToDispatch) { + Element& element = event.element; + if (event.eventType == eventNames().transitionendEvent) + element.dispatchEvent(TransitionEvent::create(event.eventType, event.name, event.elapsedTime, PseudoElement::pseudoElementNameForEvents(element.pseudoId()))); + else + element.dispatchEvent(AnimationEvent::create(event.eventType, event.name, event.elapsedTime)); + } + + for (auto& change : m_elementChangesToDispatch) + change->invalidateStyleAndLayerComposition(); + + m_elementChangesToDispatch.clear(); + + if (updateStyle) + m_frame.document()->updateStyleIfNeeded(); +} + +void CSSAnimationControllerPrivate::startUpdateStyleIfNeededDispatcher() +{ + if (!m_updateStyleIfNeededDispatcher.isActive()) + m_updateStyleIfNeededDispatcher.startOneShot(0); +} + +void CSSAnimationControllerPrivate::addEventToDispatch(Element& element, const AtomicString& eventType, const String& name, double elapsedTime) +{ + m_eventsToDispatch.append({ element, eventType, name, elapsedTime }); + startUpdateStyleIfNeededDispatcher(); +} + +void CSSAnimationControllerPrivate::addElementChangeToDispatch(Element& element) +{ + m_elementChangesToDispatch.append(element); + ASSERT(m_elementChangesToDispatch.last()->document().pageCacheState() == Document::NotInPageCache); + startUpdateStyleIfNeededDispatcher(); +} + +void CSSAnimationControllerPrivate::animationFrameCallbackFired() +{ + double timeToNextService = updateAnimations(CallSetChanged); + + if (timeToNextService >= 0) + m_frame.document()->view()->scheduleAnimation(); +} + +void CSSAnimationControllerPrivate::animationTimerFired() +{ + // We need to keep the frame alive, since it owns us. + Ref<Frame> protector(m_frame); + + // The animation timer might fire before the layout timer, in + // which case we might create some animations with incorrect + // values if we don't layout first. + if (m_requiresLayout) { + if (auto* frameView = m_frame.document()->view()) { + if (frameView->needsLayout()) + frameView->forceLayout(); + } + m_requiresLayout = false; + } + + // Make sure animationUpdateTime is updated, so that it is current even if no + // styleChange has happened (e.g. accelerated animations) + AnimationPrivateUpdateBlock updateBlock(*this); + + // When the timer fires, all we do is call setChanged on all DOM nodes with running animations and then do an immediate + // updateStyleIfNeeded. It will then call back to us with new information. + updateAnimationTimer(CallSetChanged); + + // Fire events right away, to avoid a flash of unanimated style after an animation completes, and before + // the 'end' event fires. + fireEventsAndUpdateStyle(); +} + +bool CSSAnimationControllerPrivate::isRunningAnimationOnRenderer(RenderElement& renderer, CSSPropertyID property, AnimationBase::RunningState runningState) const +{ + ASSERT(renderer.isCSSAnimating()); + ASSERT(m_compositeAnimations.contains(&renderer)); + const CompositeAnimation& animation = *m_compositeAnimations.get(&renderer); + return animation.isAnimatingProperty(property, false, runningState); +} + +bool CSSAnimationControllerPrivate::isRunningAcceleratedAnimationOnRenderer(RenderElement& renderer, CSSPropertyID property, AnimationBase::RunningState runningState) const +{ + ASSERT(renderer.isCSSAnimating()); + ASSERT(m_compositeAnimations.contains(&renderer)); + const CompositeAnimation& animation = *m_compositeAnimations.get(&renderer); + return animation.isAnimatingProperty(property, true, runningState); +} + +void CSSAnimationControllerPrivate::suspendAnimations() +{ + if (isSuspended()) + return; + + suspendAnimationsForDocument(m_frame.document()); + + // Traverse subframes + for (Frame* child = m_frame.tree().firstChild(); child; child = child->tree().nextSibling()) + child->animation().suspendAnimations(); + + m_isSuspended = true; +} + +void CSSAnimationControllerPrivate::resumeAnimations() +{ + if (!isSuspended()) + return; + + resumeAnimationsForDocument(m_frame.document()); + + // Traverse subframes + for (Frame* child = m_frame.tree().firstChild(); child; child = child->tree().nextSibling()) + child->animation().resumeAnimations(); + + m_isSuspended = false; +} + +bool CSSAnimationControllerPrivate::animationsAreSuspendedForDocument(Document* document) +{ + return isSuspended() || m_suspendedDocuments.contains(document); +} + +void CSSAnimationControllerPrivate::detachFromDocument(Document* document) +{ + m_suspendedDocuments.remove(document); +} + +void CSSAnimationControllerPrivate::suspendAnimationsForDocument(Document* document) +{ + if (animationsAreSuspendedForDocument(document)) + return; + + m_suspendedDocuments.add(document); + + AnimationPrivateUpdateBlock updateBlock(*this); + + for (auto& animation : m_compositeAnimations) { + if (&animation.key->document() == document) + animation.value->suspendAnimations(); + } + + updateAnimationTimer(); +} + +void CSSAnimationControllerPrivate::resumeAnimationsForDocument(Document* document) +{ + if (!animationsAreSuspendedForDocument(document)) + return; + + detachFromDocument(document); + + AnimationPrivateUpdateBlock updateBlock(*this); + + for (auto& animation : m_compositeAnimations) { + if (&animation.key->document() == document) + animation.value->resumeAnimations(); + } + + updateAnimationTimer(); +} + +void CSSAnimationControllerPrivate::startAnimationsIfNotSuspended(Document* document) +{ + if (!animationsAreSuspendedForDocument(document) || allowsNewAnimationsWhileSuspended()) + resumeAnimationsForDocument(document); +} + +void CSSAnimationControllerPrivate::setAllowsNewAnimationsWhileSuspended(bool allowed) +{ + m_allowsNewAnimationsWhileSuspended = allowed; +} + +bool CSSAnimationControllerPrivate::pauseAnimationAtTime(RenderElement* renderer, const AtomicString& name, double t) +{ + if (!renderer) + return false; + + CompositeAnimation& compositeAnimation = ensureCompositeAnimation(*renderer); + if (compositeAnimation.pauseAnimationAtTime(name, t)) { + renderer->element()->invalidateStyleAndLayerComposition(); + startUpdateStyleIfNeededDispatcher(); + return true; + } + + return false; +} + +bool CSSAnimationControllerPrivate::pauseTransitionAtTime(RenderElement* renderer, const String& property, double t) +{ + if (!renderer) + return false; + + CompositeAnimation& compositeAnimation = ensureCompositeAnimation(*renderer); + if (compositeAnimation.pauseTransitionAtTime(cssPropertyID(property), t)) { + renderer->element()->invalidateStyleAndLayerComposition(); + startUpdateStyleIfNeededDispatcher(); + return true; + } + + return false; +} + +double CSSAnimationControllerPrivate::beginAnimationUpdateTime() +{ + ASSERT(m_beginAnimationUpdateCount); + if (m_beginAnimationUpdateTime == cBeginAnimationUpdateTimeNotSet) + m_beginAnimationUpdateTime = monotonicallyIncreasingTime(); + + return m_beginAnimationUpdateTime; +} + +void CSSAnimationControllerPrivate::beginAnimationUpdate() +{ + if (!m_beginAnimationUpdateCount) + setBeginAnimationUpdateTime(cBeginAnimationUpdateTimeNotSet); + ++m_beginAnimationUpdateCount; +} + +void CSSAnimationControllerPrivate::endAnimationUpdate() +{ + ASSERT(m_beginAnimationUpdateCount > 0); + if (m_beginAnimationUpdateCount == 1) { + styleAvailable(); + if (!m_waitingForAsyncStartNotification) + startTimeResponse(beginAnimationUpdateTime()); + } + --m_beginAnimationUpdateCount; +} + +void CSSAnimationControllerPrivate::receivedStartTimeResponse(double time) +{ + LOG(Animations, "CSSAnimationControllerPrivate %p receivedStartTimeResponse %f", this, time); + + m_waitingForAsyncStartNotification = false; + startTimeResponse(time); +} + +std::unique_ptr<RenderStyle> CSSAnimationControllerPrivate::getAnimatedStyleForRenderer(RenderElement& renderer) +{ + AnimationPrivateUpdateBlock animationUpdateBlock(*this); + + ASSERT(renderer.isCSSAnimating()); + ASSERT(m_compositeAnimations.contains(&renderer)); + const CompositeAnimation& rendererAnimations = *m_compositeAnimations.get(&renderer); + std::unique_ptr<RenderStyle> animatingStyle = rendererAnimations.getAnimatedStyle(); + if (!animatingStyle) + animatingStyle = RenderStyle::clonePtr(renderer.style()); + + return animatingStyle; +} + +bool CSSAnimationControllerPrivate::computeExtentOfAnimation(RenderElement& renderer, LayoutRect& bounds) const +{ + ASSERT(renderer.isCSSAnimating()); + ASSERT(m_compositeAnimations.contains(&renderer)); + + const CompositeAnimation& rendererAnimations = *m_compositeAnimations.get(&renderer); + if (!rendererAnimations.isAnimatingProperty(CSSPropertyTransform, false, AnimationBase::Running | AnimationBase::Paused)) + return true; + + return rendererAnimations.computeExtentOfTransformAnimation(bounds); +} + +unsigned CSSAnimationControllerPrivate::numberOfActiveAnimations(Document* document) const +{ + unsigned count = 0; + + for (auto& animation : m_compositeAnimations) { + if (&animation.key->document() == document) + count += animation.value->numberOfActiveAnimations(); + } + + return count; +} + +void CSSAnimationControllerPrivate::addToAnimationsWaitingForStyle(AnimationBase* animation) +{ + // Make sure this animation is not in the start time waiters + m_animationsWaitingForStartTimeResponse.remove(animation); + + m_animationsWaitingForStyle.add(animation); +} + +void CSSAnimationControllerPrivate::removeFromAnimationsWaitingForStyle(AnimationBase* animationToRemove) +{ + m_animationsWaitingForStyle.remove(animationToRemove); +} + +void CSSAnimationControllerPrivate::styleAvailable() +{ + // Go through list of waiters and send them on their way + for (const auto& waitingAnimation : m_animationsWaitingForStyle) + waitingAnimation->styleAvailable(); + + m_animationsWaitingForStyle.clear(); +} + +void CSSAnimationControllerPrivate::addToAnimationsWaitingForStartTimeResponse(AnimationBase* animation, bool willGetResponse) +{ + // If willGetResponse is true, it means this animation is actually waiting for a response + // (which will come in as a call to notifyAnimationStarted()). + // In that case we don't need to add it to this list. We just set a waitingForAResponse flag + // which says we are waiting for the response. If willGetResponse is false, this animation + // is not waiting for a response for itself, but rather for a notifyXXXStarted() call for + // another animation to which it will sync. + // + // When endAnimationUpdate() is called we check to see if the waitingForAResponse flag is + // true. If so, we just return and will do our work when the first notifyXXXStarted() call + // comes in. If it is false, we will not be getting a notifyXXXStarted() call, so we will + // do our work right away. In both cases we call the onAnimationStartResponse() method + // on each animation. In the first case we send in the time we got from notifyXXXStarted(). + // In the second case, we just pass in the beginAnimationUpdateTime(). + // + // This will synchronize all software and accelerated animations started in the same + // updateStyleIfNeeded cycle. + // + + if (willGetResponse) + m_waitingForAsyncStartNotification = true; + + m_animationsWaitingForStartTimeResponse.add(animation); +} + +void CSSAnimationControllerPrivate::removeFromAnimationsWaitingForStartTimeResponse(AnimationBase* animationToRemove) +{ + m_animationsWaitingForStartTimeResponse.remove(animationToRemove); + + if (m_animationsWaitingForStartTimeResponse.isEmpty()) + m_waitingForAsyncStartNotification = false; +} + +void CSSAnimationControllerPrivate::startTimeResponse(double time) +{ + // Go through list of waiters and send them on their way + + for (const auto& animation : m_animationsWaitingForStartTimeResponse) + animation->onAnimationStartResponse(time); + + m_animationsWaitingForStartTimeResponse.clear(); + m_waitingForAsyncStartNotification = false; +} + +void CSSAnimationControllerPrivate::animationWillBeRemoved(AnimationBase* animation) +{ + LOG(Animations, "CSSAnimationControllerPrivate %p animationWillBeRemoved: %p", this, animation); + + removeFromAnimationsWaitingForStyle(animation); + removeFromAnimationsWaitingForStartTimeResponse(animation); +#if ENABLE(CSS_ANIMATIONS_LEVEL_2) + removeFromAnimationsDependentOnScroll(animation); +#endif + + bool anyAnimationsWaitingForAsyncStart = false; + for (auto& animation : m_animationsWaitingForStartTimeResponse) { + if (animation->waitingForStartTime() && animation->isAccelerated()) { + anyAnimationsWaitingForAsyncStart = true; + break; + } + } + + if (!anyAnimationsWaitingForAsyncStart) + m_waitingForAsyncStartNotification = false; +} + +#if ENABLE(CSS_ANIMATIONS_LEVEL_2) +void CSSAnimationControllerPrivate::addToAnimationsDependentOnScroll(AnimationBase* animation) +{ + m_animationsDependentOnScroll.add(animation); +} + +void CSSAnimationControllerPrivate::removeFromAnimationsDependentOnScroll(AnimationBase* animation) +{ + m_animationsDependentOnScroll.remove(animation); +} + +void CSSAnimationControllerPrivate::scrollWasUpdated() +{ + auto* view = m_frame.view(); + if (!view || !wantsScrollUpdates()) + return; + + m_scrollPosition = view->scrollPositionForFixedPosition().y().toFloat(); + + // FIXME: This is updating all the animations, rather than just the ones + // that are dependent on scroll. We to go from our AnimationBase to its CompositeAnimation + // so we can execute code similar to updateAnimations. + // https://bugs.webkit.org/show_bug.cgi?id=144170 + updateAnimations(CallSetChanged); +} +#endif + +CSSAnimationController::CSSAnimationController(Frame& frame) + : m_data(std::make_unique<CSSAnimationControllerPrivate>(frame)) +{ +} + +CSSAnimationController::~CSSAnimationController() +{ +} + +void CSSAnimationController::cancelAnimations(RenderElement& renderer) +{ + if (!renderer.isCSSAnimating()) + return; + + if (!m_data->clear(renderer)) + return; + + Element* element = renderer.element(); + if (!element || element->document().renderTreeBeingDestroyed()) + return; + ASSERT(element->document().pageCacheState() == Document::NotInPageCache); + element->invalidateStyleAndLayerComposition(); +} + +bool CSSAnimationController::updateAnimations(RenderElement& renderer, const RenderStyle& newStyle, std::unique_ptr<RenderStyle>& animatedStyle) +{ + auto* oldStyle = renderer.hasInitializedStyle() ? &renderer.style() : nullptr; + if ((!oldStyle || (!oldStyle->animations() && !oldStyle->transitions())) && (!newStyle.animations() && !newStyle.transitions())) + return false; + + if (renderer.document().pageCacheState() != Document::NotInPageCache) + return false; + + // Don't run transitions when printing. + if (renderer.view().printing()) + return false; + + // Fetch our current set of implicit animations from a hashtable. We then compare them + // against the animations in the style and make sure we're in sync. If destination values + // have changed, we reset the animation. We then do a blend to get new values and we return + // a new style. + + // We don't support anonymous pseudo elements like :first-line or :first-letter. + ASSERT(renderer.element()); + + CompositeAnimation& rendererAnimations = m_data->ensureCompositeAnimation(renderer); + bool animationStateChanged = rendererAnimations.animate(renderer, oldStyle, newStyle, animatedStyle); + + if (renderer.parent() || newStyle.animations() || (oldStyle && oldStyle->animations())) { + auto& frameView = renderer.view().frameView(); + if (rendererAnimations.hasAnimationThatDependsOnLayout()) + m_data->setRequiresLayout(); + m_data->updateAnimationTimerForRenderer(renderer); + frameView.scheduleAnimation(); + } + + return animationStateChanged; +} + +std::unique_ptr<RenderStyle> CSSAnimationController::getAnimatedStyleForRenderer(RenderElement& renderer) +{ + if (!renderer.isCSSAnimating()) + return RenderStyle::clonePtr(renderer.style()); + return m_data->getAnimatedStyleForRenderer(renderer); +} + +bool CSSAnimationController::computeExtentOfAnimation(RenderElement& renderer, LayoutRect& bounds) const +{ + if (!renderer.isCSSAnimating()) + return true; + + return m_data->computeExtentOfAnimation(renderer, bounds); +} + +void CSSAnimationController::notifyAnimationStarted(RenderElement& renderer, double startTime) +{ + LOG(Animations, "CSSAnimationController %p notifyAnimationStarted on renderer %p, time=%f", this, &renderer, startTime); + UNUSED_PARAM(renderer); + + AnimationUpdateBlock animationUpdateBlock(this); + m_data->receivedStartTimeResponse(startTime); +} + +bool CSSAnimationController::pauseAnimationAtTime(RenderElement* renderer, const AtomicString& name, double t) +{ + AnimationUpdateBlock animationUpdateBlock(this); + return m_data->pauseAnimationAtTime(renderer, name, t); +} + +unsigned CSSAnimationController::numberOfActiveAnimations(Document* document) const +{ + return m_data->numberOfActiveAnimations(document); +} + +bool CSSAnimationController::pauseTransitionAtTime(RenderElement* renderer, const String& property, double t) +{ + AnimationUpdateBlock animationUpdateBlock(this); + return m_data->pauseTransitionAtTime(renderer, property, t); +} + +bool CSSAnimationController::isRunningAnimationOnRenderer(RenderElement& renderer, CSSPropertyID property, AnimationBase::RunningState runningState) const +{ + return renderer.isCSSAnimating() && m_data->isRunningAnimationOnRenderer(renderer, property, runningState); +} + +bool CSSAnimationController::isRunningAcceleratedAnimationOnRenderer(RenderElement& renderer, CSSPropertyID property, AnimationBase::RunningState runningState) const +{ + return renderer.isCSSAnimating() && m_data->isRunningAcceleratedAnimationOnRenderer(renderer, property, runningState); +} + +bool CSSAnimationController::isSuspended() const +{ + return m_data->isSuspended(); +} + +void CSSAnimationController::suspendAnimations() +{ + LOG(Animations, "controller is suspending animations"); + m_data->suspendAnimations(); +} + +void CSSAnimationController::resumeAnimations() +{ + LOG(Animations, "controller is resuming animations"); + m_data->resumeAnimations(); +} + +bool CSSAnimationController::allowsNewAnimationsWhileSuspended() const +{ + return m_data->allowsNewAnimationsWhileSuspended(); +} + +void CSSAnimationController::setAllowsNewAnimationsWhileSuspended(bool allowed) +{ + m_data->setAllowsNewAnimationsWhileSuspended(allowed); +} + +void CSSAnimationController::serviceAnimations() +{ + m_data->animationFrameCallbackFired(); +} + +bool CSSAnimationController::animationsAreSuspendedForDocument(Document* document) +{ + return m_data->animationsAreSuspendedForDocument(document); +} + +void CSSAnimationController::detachFromDocument(Document* document) +{ + return m_data->detachFromDocument(document); +} + +void CSSAnimationController::suspendAnimationsForDocument(Document* document) +{ + LOG(Animations, "suspending animations for document %p", document); + m_data->suspendAnimationsForDocument(document); +} + +void CSSAnimationController::resumeAnimationsForDocument(Document* document) +{ + LOG(Animations, "resuming animations for document %p", document); + AnimationUpdateBlock animationUpdateBlock(this); + m_data->resumeAnimationsForDocument(document); +} + +void CSSAnimationController::startAnimationsIfNotSuspended(Document* document) +{ + LOG(Animations, "animations may start for document %p", document); + + AnimationUpdateBlock animationUpdateBlock(this); + m_data->startAnimationsIfNotSuspended(document); +} + +void CSSAnimationController::beginAnimationUpdate() +{ + m_data->beginAnimationUpdate(); +} + +void CSSAnimationController::endAnimationUpdate() +{ + m_data->endAnimationUpdate(); +} + +bool CSSAnimationController::supportsAcceleratedAnimationOfProperty(CSSPropertyID property) +{ + return CSSPropertyAnimation::animationOfPropertyIsAccelerated(property); +} + +#if ENABLE(CSS_ANIMATIONS_LEVEL_2) +bool CSSAnimationController::wantsScrollUpdates() const +{ + return m_data->wantsScrollUpdates(); +} + +void CSSAnimationController::scrollWasUpdated() +{ + m_data->scrollWasUpdated(); +} +#endif + +bool CSSAnimationController::hasAnimations() const +{ + return m_data->hasAnimations(); +} + +} // namespace WebCore diff --git a/Source/WebCore/page/animation/AnimationController.h b/Source/WebCore/page/animation/CSSAnimationController.h index c29af5d82..d473cd173 100644 --- a/Source/WebCore/page/animation/AnimationController.h +++ b/Source/WebCore/page/animation/CSSAnimationController.h @@ -10,7 +10,7 @@ * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. - * 3. Neither the name of Apple Computer, Inc. ("Apple") nor the names of + * 3. Neither the name of Apple Inc. ("Apple") nor the names of * its contributors may be used to endorse or promote products derived * from this software without specific prior written permission. * @@ -26,69 +26,80 @@ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ -#ifndef AnimationController_h -#define AnimationController_h +#pragma once +#include "AnimationBase.h" #include "CSSPropertyNames.h" #include <wtf/Forward.h> -#include <wtf/OwnPtr.h> namespace WebCore { -class AnimationBase; -class AnimationControllerPrivate; +class CSSAnimationControllerPrivate; class Document; class Element; class Frame; +class LayoutRect; class RenderElement; class RenderStyle; -class AnimationController { +class CSSAnimationController { + WTF_MAKE_FAST_ALLOCATED; public: - explicit AnimationController(Frame&); - ~AnimationController(); + explicit CSSAnimationController(Frame&); + ~CSSAnimationController(); - void cancelAnimations(RenderElement*); - PassRef<RenderStyle> updateAnimations(RenderElement&, PassRef<RenderStyle> newStyle); - PassRefPtr<RenderStyle> getAnimatedStyleForRenderer(RenderElement*); + void cancelAnimations(RenderElement&); + bool updateAnimations(RenderElement&, const RenderStyle& newStyle, std::unique_ptr<RenderStyle>& animatedStyle); + std::unique_ptr<RenderStyle> getAnimatedStyleForRenderer(RenderElement&); + + // 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 + // transform animation but we were unable to cheaply compute its affect on the extent. + bool computeExtentOfAnimation(RenderElement&, LayoutRect&) const; // This is called when an accelerated animation or transition has actually started to animate. - void notifyAnimationStarted(RenderElement*, double startTime); + void notifyAnimationStarted(RenderElement&, double startTime); - bool pauseAnimationAtTime(RenderElement*, const AtomicString& name, double t); // To be used only for testing - bool pauseTransitionAtTime(RenderElement*, const String& property, double t); // To be used only for testing - unsigned numberOfActiveAnimations(Document*) const; // To be used only for testing + WEBCORE_EXPORT bool pauseAnimationAtTime(RenderElement*, const AtomicString& name, double t); // To be used only for testing + WEBCORE_EXPORT bool pauseTransitionAtTime(RenderElement*, const String& property, double t); // To be used only for testing + WEBCORE_EXPORT unsigned numberOfActiveAnimations(Document*) const; // To be used only for testing - bool isRunningAnimationOnRenderer(RenderElement*, CSSPropertyID, bool isRunningNow = true) const; - bool isRunningAcceleratedAnimationOnRenderer(RenderElement*, CSSPropertyID, bool isRunningNow = true) const; + bool isRunningAnimationOnRenderer(RenderElement&, CSSPropertyID, AnimationBase::RunningState) const; + bool isRunningAcceleratedAnimationOnRenderer(RenderElement&, CSSPropertyID, AnimationBase::RunningState) const; - bool isSuspended() const; - void suspendAnimations(); - void resumeAnimations(); -#if ENABLE(REQUEST_ANIMATION_FRAME) + WEBCORE_EXPORT bool isSuspended() const; + WEBCORE_EXPORT void suspendAnimations(); + WEBCORE_EXPORT void resumeAnimations(); void serviceAnimations(); -#endif - void suspendAnimationsForDocument(Document*); - void resumeAnimationsForDocument(Document*); + WEBCORE_EXPORT void suspendAnimationsForDocument(Document*); + WEBCORE_EXPORT void resumeAnimationsForDocument(Document*); + WEBCORE_EXPORT bool animationsAreSuspendedForDocument(Document*); + void detachFromDocument(Document*); void startAnimationsIfNotSuspended(Document*); void beginAnimationUpdate(); void endAnimationUpdate(); - bool allowsNewAnimationsWhileSuspended() const; - void setAllowsNewAnimationsWhileSuspended(bool); + WEBCORE_EXPORT bool allowsNewAnimationsWhileSuspended() const; + WEBCORE_EXPORT void setAllowsNewAnimationsWhileSuspended(bool); static bool supportsAcceleratedAnimationOfProperty(CSSPropertyID); +#if ENABLE(CSS_ANIMATIONS_LEVEL_2) + bool wantsScrollUpdates() const; + void scrollWasUpdated(); +#endif + + bool hasAnimations() const; + private: - const std::unique_ptr<AnimationControllerPrivate> m_data; - int m_beginAnimationUpdateCount; + const std::unique_ptr<CSSAnimationControllerPrivate> m_data; }; class AnimationUpdateBlock { public: - AnimationUpdateBlock(AnimationController* animationController) + AnimationUpdateBlock(CSSAnimationController* animationController) : m_animationController(animationController) { if (m_animationController) @@ -101,9 +112,7 @@ public: m_animationController->endAnimationUpdate(); } - AnimationController* m_animationController; + CSSAnimationController* m_animationController; }; } // namespace WebCore - -#endif // AnimationController_h diff --git a/Source/WebCore/page/animation/AnimationControllerPrivate.h b/Source/WebCore/page/animation/CSSAnimationControllerPrivate.h index f03092280..c4996c331 100644 --- a/Source/WebCore/page/animation/AnimationControllerPrivate.h +++ b/Source/WebCore/page/animation/CSSAnimationControllerPrivate.h @@ -10,7 +10,7 @@ * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. - * 3. Neither the name of Apple Computer, Inc. ("Apple") nor the names of + * 3. Neither the name of Apple Inc. ("Apple") nor the names of * its contributors may be used to endorse or promote products derived * from this software without specific prior written permission. * @@ -26,76 +26,68 @@ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ -#ifndef AnimationControllerPrivate_h -#define AnimationControllerPrivate_h +#pragma once -#include "CSSPropertyNames.h" +#include "AnimationBase.h" #include "Timer.h" #include <wtf/HashMap.h> #include <wtf/HashSet.h> -#include <wtf/PassRefPtr.h> -#include <wtf/RefPtr.h> #include <wtf/Vector.h> -#include <wtf/text/AtomicString.h> -#include <wtf/text/WTFString.h> namespace WebCore { -class AnimationBase; class CompositeAnimation; class Document; -class Element; class Frame; -class RenderElement; -class RenderStyle; -enum SetChanged { - DoNotCallSetChanged = 0, - CallSetChanged = 1 -}; +enum SetChanged { DoNotCallSetChanged, CallSetChanged }; -class AnimationControllerPrivate { - WTF_MAKE_NONCOPYABLE(AnimationControllerPrivate); WTF_MAKE_FAST_ALLOCATED; +class CSSAnimationControllerPrivate { + WTF_MAKE_FAST_ALLOCATED; public: - explicit AnimationControllerPrivate(Frame&); - ~AnimationControllerPrivate(); + explicit CSSAnimationControllerPrivate(Frame&); + ~CSSAnimationControllerPrivate(); // Returns the time until the next animation needs to be serviced, or -1 if there are none. double updateAnimations(SetChanged callSetChanged = DoNotCallSetChanged); void updateAnimationTimer(SetChanged callSetChanged = DoNotCallSetChanged); - CompositeAnimation& ensureCompositeAnimation(RenderElement*); - bool clear(RenderElement*); + CompositeAnimation& ensureCompositeAnimation(RenderElement&); + bool clear(RenderElement&); - void updateStyleIfNeededDispatcherFired(Timer<AnimationControllerPrivate>&); + void updateStyleIfNeededDispatcherFired(); void startUpdateStyleIfNeededDispatcher(); - void addEventToDispatch(PassRefPtr<Element> element, const AtomicString& eventType, const String& name, double elapsedTime); - void addElementChangeToDispatch(PassRef<Element>); + void addEventToDispatch(Element&, const AtomicString& eventType, const String& name, double elapsedTime); + void addElementChangeToDispatch(Element&); bool hasAnimations() const { return !m_compositeAnimations.isEmpty(); } bool isSuspended() const { return m_isSuspended; } void suspendAnimations(); void resumeAnimations(); -#if ENABLE(REQUEST_ANIMATION_FRAME) void animationFrameCallbackFired(); -#endif void suspendAnimationsForDocument(Document*); void resumeAnimationsForDocument(Document*); + bool animationsAreSuspendedForDocument(Document*); void startAnimationsIfNotSuspended(Document*); + void detachFromDocument(Document*); - bool isRunningAnimationOnRenderer(RenderElement*, CSSPropertyID, bool isRunningNow) const; - bool isRunningAcceleratedAnimationOnRenderer(RenderElement*, CSSPropertyID, bool isRunningNow) const; + bool isRunningAnimationOnRenderer(RenderElement&, CSSPropertyID, AnimationBase::RunningState) const; + bool isRunningAcceleratedAnimationOnRenderer(RenderElement&, CSSPropertyID, AnimationBase::RunningState) const; bool pauseAnimationAtTime(RenderElement*, const AtomicString& name, double t); bool pauseTransitionAtTime(RenderElement*, const String& property, double t); unsigned numberOfActiveAnimations(Document*) const; - PassRefPtr<RenderStyle> getAnimatedStyleForRenderer(RenderElement* renderer); + std::unique_ptr<RenderStyle> getAnimatedStyleForRenderer(RenderElement&); + + bool computeExtentOfAnimation(RenderElement&, LayoutRect&) const; double beginAnimationUpdateTime(); void setBeginAnimationUpdateTime(double t) { m_beginAnimationUpdateTime = t; } + + void beginAnimationUpdate(); void endAnimationUpdate(); void receivedStartTimeResponse(double); @@ -107,48 +99,65 @@ public: void animationWillBeRemoved(AnimationBase*); - void updateAnimationTimerForRenderer(RenderElement*); + void updateAnimationTimerForRenderer(RenderElement&); bool allowsNewAnimationsWhileSuspended() const { return m_allowsNewAnimationsWhileSuspended; } void setAllowsNewAnimationsWhileSuspended(bool); + void setRequiresLayout() { m_requiresLayout = true; } + +#if ENABLE(CSS_ANIMATIONS_LEVEL_2) + bool wantsScrollUpdates() const { return !m_animationsDependentOnScroll.isEmpty(); } + void addToAnimationsDependentOnScroll(AnimationBase*); + void removeFromAnimationsDependentOnScroll(AnimationBase*); + + void scrollWasUpdated(); + float scrollPosition() const { return m_scrollPosition; } +#endif + private: - void animationTimerFired(Timer<AnimationControllerPrivate>&); + void animationTimerFired(); void styleAvailable(); void fireEventsAndUpdateStyle(); void startTimeResponse(double t); HashMap<RenderElement*, RefPtr<CompositeAnimation>> m_compositeAnimations; - Timer<AnimationControllerPrivate> m_animationTimer; - Timer<AnimationControllerPrivate> m_updateStyleIfNeededDispatcher; + Timer m_animationTimer; + Timer m_updateStyleIfNeededDispatcher; Frame& m_frame; - - class EventToDispatch { - public: - RefPtr<Element> element; + + struct EventToDispatch { + Ref<Element> element; AtomicString eventType; String name; double elapsedTime; }; - Vector<EventToDispatch> m_eventsToDispatch; Vector<Ref<Element>> m_elementChangesToDispatch; - + HashSet<Document*> m_suspendedDocuments; + double m_beginAnimationUpdateTime; - typedef HashSet<RefPtr<AnimationBase>> WaitingAnimationsSet; - WaitingAnimationsSet m_animationsWaitingForStyle; - WaitingAnimationsSet m_animationsWaitingForStartTimeResponse; + using AnimationsSet = HashSet<RefPtr<AnimationBase>>; + AnimationsSet m_animationsWaitingForStyle; + AnimationsSet m_animationsWaitingForStartTimeResponse; + + int m_beginAnimationUpdateCount; + bool m_waitingForAsyncStartNotification; bool m_isSuspended; + bool m_requiresLayout { false }; // Used to flag whether we should revert to previous buggy // behavior of allowing new transitions and animations to // run even when this object is suspended. bool m_allowsNewAnimationsWhileSuspended; + +#if ENABLE(CSS_ANIMATIONS_LEVEL_2) + AnimationsSet m_animationsDependentOnScroll; + float m_scrollPosition { 0 }; +#endif }; } // namespace WebCore - -#endif // AnimationControllerPrivate_h diff --git a/Source/WebCore/page/animation/CSSPropertyAnimation.cpp b/Source/WebCore/page/animation/CSSPropertyAnimation.cpp index 291129e93..98b87c947 100644 --- a/Source/WebCore/page/animation/CSSPropertyAnimation.cpp +++ b/Source/WebCore/page/animation/CSSPropertyAnimation.cpp @@ -1,5 +1,5 @@ /* - * Copyright (C) 2007, 2008, 2009, 2013 Apple Inc. All rights reserved. + * Copyright (C) 2007, 2008, 2009, 2013, 2016 Apple Inc. All rights reserved. * Copyright (C) 2012, 2013 Adobe Systems Incorporated. All rights reserved. * * Redistribution and use in source and binary forms, with or without @@ -11,7 +11,7 @@ * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. - * 3. Neither the name of Apple Computer, Inc. ("Apple") nor the names of + * 3. Neither the name of Apple Inc. ("Apple") nor the names of * its contributors may be used to endorse or promote products derived * from this software without specific prior written permission. * @@ -41,7 +41,9 @@ #include "CachedImage.h" #include "ClipPathOperation.h" #include "FloatConversion.h" +#include "FontTaggedSettings.h" #include "IdentityTransformOperation.h" +#include "Logging.h" #include "Matrix3DTransformOperation.h" #include "MatrixTransformOperation.h" #include "RenderBox.h" @@ -50,9 +52,13 @@ #include "StyleGeneratedImage.h" #include "StylePropertyShorthand.h" #include "StyleResolver.h" +#include "TextStream.h" #include <algorithm> +#include <memory> #include <wtf/MathExtras.h> +#include <wtf/NeverDestroyed.h> #include <wtf/Noncopyable.h> +#include <wtf/PointerComparison.h> #include <wtf/RefCounted.h> namespace WebCore { @@ -62,11 +68,6 @@ static inline int blendFunc(const AnimationBase*, int from, int to, double progr return blend(from, to, progress); } -static inline unsigned blendFunc(const AnimationBase*, unsigned from, unsigned to, double progress) -{ - return blend(from, to, progress); -} - static inline double blendFunc(const AnimationBase*, double from, double to, double progress) { return blend(from, to, progress); @@ -84,13 +85,12 @@ static inline Color blendFunc(const AnimationBase*, const Color& from, const Col static inline Length blendFunc(const AnimationBase*, const Length& from, const Length& to, double progress) { - return to.blend(from, narrowPrecisionToFloat(progress)); + return blend(from, to, progress); } static inline LengthSize blendFunc(const AnimationBase* anim, const LengthSize& from, const LengthSize& to, double progress) { - return LengthSize(blendFunc(anim, from.width(), to.width(), progress), - blendFunc(anim, from.height(), to.height(), progress)); + return { blendFunc(anim, from.width, to.width, progress), blendFunc(anim, from.height, to.height, progress) }; } static inline ShadowStyle blendFunc(const AnimationBase* anim, ShadowStyle from, ShadowStyle to, double progress) @@ -104,28 +104,28 @@ static inline ShadowStyle blendFunc(const AnimationBase* anim, ShadowStyle from, return result > 0 ? Normal : Inset; } -static inline PassOwnPtr<ShadowData> blendFunc(const AnimationBase* anim, const ShadowData* from, const ShadowData* to, double progress) +static inline std::unique_ptr<ShadowData> blendFunc(const AnimationBase* anim, const ShadowData* from, const ShadowData* to, double progress) { ASSERT(from && to); if (from->style() != to->style()) - return adoptPtr(new ShadowData(*to)); - - return adoptPtr(new ShadowData(blend(from->location(), to->location(), progress), - blend(from->radius(), to->radius(), progress), - blend(from->spread(), to->spread(), progress), - blendFunc(anim, from->style(), to->style(), progress), - from->isWebkitBoxShadow(), - blend(from->color(), to->color(), progress))); + return std::make_unique<ShadowData>(*to); + + return std::make_unique<ShadowData>(blend(from->location(), to->location(), progress), + blend(from->radius(), to->radius(), progress), + blend(from->spread(), to->spread(), progress), + blendFunc(anim, from->style(), to->style(), progress), + from->isWebkitBoxShadow(), + blend(from->color(), to->color(), progress)); } -static inline TransformOperations blendFunc(const AnimationBase* anim, const TransformOperations& from, const TransformOperations& to, double progress) +static inline TransformOperations blendFunc(const AnimationBase* animation, const TransformOperations& from, const TransformOperations& to, double progress) { - if (anim->isTransformFunctionListValid()) + if (animation->transformFunctionListsMatch()) return to.blendByMatchingOperations(from, progress); - return to.blendByUsingMatrixInterpolation(from, progress, anim->renderer()->isBox() ? toRenderBox(anim->renderer())->borderBoxRect().size() : LayoutSize()); + return to.blendByUsingMatrixInterpolation(from, progress, is<RenderBox>(*animation->renderer()) ? downcast<RenderBox>(*animation->renderer()).borderBoxRect().size() : LayoutSize()); } -static inline PassRefPtr<ClipPathOperation> blendFunc(const AnimationBase*, ClipPathOperation* from, ClipPathOperation* to, double progress) +static inline RefPtr<ClipPathOperation> blendFunc(const AnimationBase*, ClipPathOperation* from, ClipPathOperation* to, double progress) { if (!from || !to) return to; @@ -134,44 +134,40 @@ static inline PassRefPtr<ClipPathOperation> blendFunc(const AnimationBase*, Clip if (from->type() != ClipPathOperation::Shape || to->type() != ClipPathOperation::Shape) return to; - const BasicShape* fromShape = static_cast<ShapeClipPathOperation*>(from)->basicShape(); - const BasicShape* toShape = static_cast<ShapeClipPathOperation*>(to)->basicShape(); + const BasicShape& fromShape = downcast<ShapeClipPathOperation>(*from).basicShape(); + const BasicShape& toShape = downcast<ShapeClipPathOperation>(*to).basicShape(); - if (!fromShape->canBlend(toShape)) + if (!fromShape.canBlend(toShape)) return to; - return ShapeClipPathOperation::create(toShape->blend(fromShape, progress)); + return ShapeClipPathOperation::create(toShape.blend(fromShape, progress)); } -#if ENABLE(CSS_SHAPES) -static inline PassRefPtr<ShapeValue> blendFunc(const AnimationBase*, ShapeValue* from, ShapeValue* to, double progress) +static inline RefPtr<ShapeValue> blendFunc(const AnimationBase*, ShapeValue* from, ShapeValue* to, double progress) { if (!from || !to) return to; - // FIXME Bug 102723: Shape-inside should be able to animate a value of 'outside-shape' when shape-outside is set to a BasicShape - if (from->type() != ShapeValue::Shape || to->type() != ShapeValue::Shape) + if (from->type() != ShapeValue::Type::Shape || to->type() != ShapeValue::Type::Shape) return to; - if (from->layoutBox() != to->layoutBox()) + if (from->cssBox() != to->cssBox()) return to; - const BasicShape* fromShape = from->shape(); - const BasicShape* toShape = to->shape(); + const BasicShape& fromShape = *from->shape(); + const BasicShape& toShape = *to->shape(); - if (!fromShape->canBlend(toShape)) + if (!fromShape.canBlend(toShape)) return to; - return ShapeValue::createShapeValue(toShape->blend(fromShape, progress), to->layoutBox()); + return ShapeValue::create(toShape.blend(fromShape, progress), to->cssBox()); } -#endif -#if ENABLE(CSS_FILTERS) -static inline PassRefPtr<FilterOperation> blendFunc(const AnimationBase* anim, FilterOperation* fromOp, FilterOperation* toOp, double progress, bool blendToPassthrough = false) +static inline RefPtr<FilterOperation> blendFunc(const AnimationBase* animation, FilterOperation* fromOp, FilterOperation* toOp, double progress, bool blendToPassthrough = false) { ASSERT(toOp); if (toOp->blendingNeedsRendererSize()) { - LayoutSize size = anim->renderer()->isBox() ? toRenderBox(anim->renderer())->borderBoxRect().size() : LayoutSize(); + LayoutSize size = is<RenderBox>(*animation->renderer()) ? downcast<RenderBox>(*animation->renderer()).borderBoxRect().size() : LayoutSize(); return toOp->blend(fromOp, progress, size, blendToPassthrough); } return toOp->blend(fromOp, progress, blendToPassthrough); @@ -200,12 +196,18 @@ static inline FilterOperations blendFilterOperations(const AnimationBase* anim, return result; } -static inline FilterOperations blendFunc(const AnimationBase* anim, const FilterOperations& from, const FilterOperations& to, double progress) +static inline FilterOperations blendFunc(const AnimationBase* anim, const FilterOperations& from, const FilterOperations& to, double progress, bool animatingBackdropFilter = false) { FilterOperations result; // If we have a filter function list, use that to do a per-function animation. +#if ENABLE(FILTERS_LEVEL_2) + if ((!animatingBackdropFilter && anim->filterFunctionListsMatch()) || (animatingBackdropFilter && anim->backdropFilterFunctionListsMatch())) +#else + UNUSED_PARAM(animatingBackdropFilter); if (anim->filterFunctionListsMatch()) +#endif + result = blendFilterOperations(anim, from, to, progress); else { // If the filter function lists don't match, we could try to cross-fade, but don't yet have a way to represent that in CSS. @@ -216,20 +218,18 @@ static inline FilterOperations blendFunc(const AnimationBase* anim, const Filter return result; } -static inline PassRefPtr<StyleImage> blendFilter(const AnimationBase* anim, CachedImage* image, const FilterOperations& from, const FilterOperations& to, double progress) +static inline RefPtr<StyleImage> blendFilter(const AnimationBase* anim, CachedImage* image, const FilterOperations& from, const FilterOperations& to, double progress) { ASSERT(image); FilterOperations filterResult = blendFilterOperations(anim, from, to, progress); - RefPtr<StyleCachedImage> styledImage = StyleCachedImage::create(image); - auto imageValue = CSSImageValue::create(image->url(), styledImage.get()); - auto filterValue = ComputedStyleExtractor::valueForFilter(&anim->renderer()->style(), filterResult, DoNotAdjustPixelValues); + auto imageValue = CSSImageValue::create(*image); + auto filterValue = ComputedStyleExtractor::valueForFilter(anim->renderer()->style(), filterResult, DoNotAdjustPixelValues); - auto result = CSSFilterImageValue::create(std::move(imageValue), std::move(filterValue)); + auto result = CSSFilterImageValue::create(WTFMove(imageValue), WTFMove(filterValue)); result.get().setFilterOperations(filterResult); - return StyleGeneratedImage::create(std::move(result)); + return StyleGeneratedImage::create(WTFMove(result)); } -#endif // ENABLE(CSS_FILTERS) static inline EVisibility blendFunc(const AnimationBase* anim, EVisibility from, EVisibility to, double progress) { @@ -252,12 +252,12 @@ static inline LengthBox blendFunc(const AnimationBase* anim, const LengthBox& fr return result; } -#if ENABLE(SVG) -static inline SVGLength blendFunc(const AnimationBase*, const SVGLength& from, const SVGLength& to, double progress) +static inline SVGLengthValue blendFunc(const AnimationBase*, const SVGLengthValue& from, const SVGLengthValue& to, double progress) { return to.blend(from, narrowPrecisionToFloat(progress)); } -static inline Vector<SVGLength> blendFunc(const AnimationBase*, const Vector<SVGLength>& from, const Vector<SVGLength>& to, double progress) + +static inline Vector<SVGLengthValue> blendFunc(const AnimationBase*, const Vector<SVGLengthValue>& from, const Vector<SVGLengthValue>& to, double progress) { size_t fromLength = from.size(); size_t toLength = to.size(); @@ -272,14 +272,13 @@ static inline Vector<SVGLength> blendFunc(const AnimationBase*, const Vector<SVG else resultLength = fromLength * toLength; } - Vector<SVGLength> result(resultLength); + Vector<SVGLengthValue> result(resultLength); for (size_t i = 0; i < resultLength; ++i) result[i] = to[i % toLength].blend(from[i % fromLength], narrowPrecisionToFloat(progress)); return result; } -#endif -static inline PassRefPtr<StyleImage> crossfadeBlend(const AnimationBase*, StyleCachedImage* fromStyleImage, StyleCachedImage* toStyleImage, double progress) +static inline RefPtr<StyleImage> crossfadeBlend(const AnimationBase*, StyleCachedImage* fromStyleImage, StyleCachedImage* toStyleImage, double progress) { // If progress is at one of the extremes, we want getComputedStyle to show the image, // not a completed cross-fade, so we hand back one of the existing images. @@ -287,69 +286,69 @@ static inline PassRefPtr<StyleImage> crossfadeBlend(const AnimationBase*, StyleC return fromStyleImage; if (progress == 1) return toStyleImage; + if (!fromStyleImage->cachedImage() || !toStyleImage->cachedImage()) + return toStyleImage; - auto fromImageValue = CSSImageValue::create(fromStyleImage->cachedImage()->url(), fromStyleImage); - auto toImageValue = CSSImageValue::create(toStyleImage->cachedImage()->url(), toStyleImage); + auto fromImageValue = CSSImageValue::create(*fromStyleImage->cachedImage()); + auto toImageValue = CSSImageValue::create(*toStyleImage->cachedImage()); + auto percentageValue = CSSPrimitiveValue::create(progress, CSSPrimitiveValue::CSS_NUMBER); - auto crossfadeValue = CSSCrossfadeValue::create(std::move(fromImageValue), std::move(toImageValue)); - crossfadeValue.get().setPercentage(CSSPrimitiveValue::create(progress, CSSPrimitiveValue::CSS_NUMBER)); - return StyleGeneratedImage::create(std::move(crossfadeValue)); + auto crossfadeValue = CSSCrossfadeValue::create(WTFMove(fromImageValue), WTFMove(toImageValue), WTFMove(percentageValue)); + return StyleGeneratedImage::create(WTFMove(crossfadeValue)); } -static inline PassRefPtr<StyleImage> blendFunc(const AnimationBase* anim, StyleImage* from, StyleImage* to, double progress) +static inline RefPtr<StyleImage> blendFunc(const AnimationBase* anim, StyleImage* from, StyleImage* to, double progress) { if (!from || !to) return to; // Animation between two generated images. Cross fade for all other cases. - if (from->isGeneratedImage() && to->isGeneratedImage()) { - CSSImageGeneratorValue& fromGenerated = toStyleGeneratedImage(from)->imageValue(); - CSSImageGeneratorValue& toGenerated = toStyleGeneratedImage(to)->imageValue(); + if (is<StyleGeneratedImage>(*from) && is<StyleGeneratedImage>(*to)) { + CSSImageGeneratorValue& fromGenerated = downcast<StyleGeneratedImage>(*from).imageValue(); + CSSImageGeneratorValue& toGenerated = downcast<StyleGeneratedImage>(*to).imageValue(); -#if ENABLE(CSS_FILTERS) - if (fromGenerated.isFilterImageValue() && toGenerated.isFilterImageValue()) { + if (is<CSSFilterImageValue>(fromGenerated) && is<CSSFilterImageValue>(toGenerated)) { // Animation of generated images just possible if input images are equal. // Otherwise fall back to cross fade animation. - CSSFilterImageValue& fromFilter = toCSSFilterImageValue(fromGenerated); - CSSFilterImageValue& toFilter = toCSSFilterImageValue(toGenerated); + CSSFilterImageValue& fromFilter = downcast<CSSFilterImageValue>(fromGenerated); + CSSFilterImageValue& toFilter = downcast<CSSFilterImageValue>(toGenerated); if (fromFilter.equalInputImages(toFilter) && fromFilter.cachedImage()) return blendFilter(anim, fromFilter.cachedImage(), fromFilter.filterOperations(), toFilter.filterOperations(), progress); } -#endif - if (fromGenerated.isCrossfadeValue() && toGenerated.isCrossfadeValue()) { - CSSCrossfadeValue& fromCrossfade = toCSSCrossfadeValue(fromGenerated); - CSSCrossfadeValue& toCrossfade = toCSSCrossfadeValue(toGenerated); - if (fromCrossfade.equalInputImages(toCrossfade)) - return StyleGeneratedImage::create(*toCrossfade.blend(fromCrossfade, progress)); + if (is<CSSCrossfadeValue>(fromGenerated) && is<CSSCrossfadeValue>(toGenerated)) { + CSSCrossfadeValue& fromCrossfade = downcast<CSSCrossfadeValue>(fromGenerated); + CSSCrossfadeValue& toCrossfade = downcast<CSSCrossfadeValue>(toGenerated); + if (fromCrossfade.equalInputImages(toCrossfade)) { + if (auto crossfadeBlend = toCrossfade.blend(fromCrossfade, progress)) + return StyleGeneratedImage::create(*crossfadeBlend); + } } // FIXME: Add support for animation between two *gradient() functions. // https://bugs.webkit.org/show_bug.cgi?id=119956 -#if ENABLE(CSS_FILTERS) - } else if (from->isGeneratedImage() && to->isCachedImage()) { - CSSImageGeneratorValue& fromGenerated = toStyleGeneratedImage(from)->imageValue(); - if (fromGenerated.isFilterImageValue()) { - CSSFilterImageValue& fromFilter = toCSSFilterImageValue(fromGenerated); - if (fromFilter.cachedImage() && static_cast<StyleCachedImage*>(to)->cachedImage() == fromFilter.cachedImage()) + } else if (is<StyleGeneratedImage>(*from) && is<StyleCachedImage>(*to)) { + CSSImageGeneratorValue& fromGenerated = downcast<StyleGeneratedImage>(*from).imageValue(); + if (is<CSSFilterImageValue>(fromGenerated)) { + CSSFilterImageValue& fromFilter = downcast<CSSFilterImageValue>(fromGenerated); + if (fromFilter.cachedImage() && downcast<StyleCachedImage>(*to).cachedImage() == fromFilter.cachedImage()) return blendFilter(anim, fromFilter.cachedImage(), fromFilter.filterOperations(), FilterOperations(), progress); } // FIXME: Add interpolation between cross-fade and image source. - } else if (from->isCachedImage() && to->isGeneratedImage()) { - CSSImageGeneratorValue& toGenerated = toStyleGeneratedImage(to)->imageValue(); - if (toGenerated.isFilterImageValue()) { - CSSFilterImageValue& toFilter = toCSSFilterImageValue(toGenerated); - if (toFilter.cachedImage() && static_cast<StyleCachedImage*>(from)->cachedImage() == toFilter.cachedImage()) + } else if (is<StyleCachedImage>(*from) && is<StyleGeneratedImage>(*to)) { + CSSImageGeneratorValue& toGenerated = downcast<StyleGeneratedImage>(*to).imageValue(); + if (is<CSSFilterImageValue>(toGenerated)) { + CSSFilterImageValue& toFilter = downcast<CSSFilterImageValue>(toGenerated); + if (toFilter.cachedImage() && downcast<StyleCachedImage>(*from).cachedImage() == toFilter.cachedImage()) return blendFilter(anim, toFilter.cachedImage(), FilterOperations(), toFilter.filterOperations(), progress); } -#endif // FIXME: Add interpolation between image source and cross-fade. } // FIXME: Add support cross fade between cached and generated images. // https://bugs.webkit.org/show_bug.cgi?id=78293 - if (from->isCachedImage() && to->isCachedImage()) - return crossfadeBlend(anim, static_cast<StyleCachedImage*>(from), static_cast<StyleCachedImage*>(to), progress); + if (is<StyleCachedImage>(*from) && is<StyleCachedImage>(*to)) + return crossfadeBlend(anim, downcast<StyleCachedImage>(from), downcast<StyleCachedImage>(to), progress); return to; } @@ -367,11 +366,31 @@ static inline NinePieceImage blendFunc(const AnimationBase* anim, const NinePiec if (from.image()->imageSize(anim->renderer(), 1.0) != to.image()->imageSize(anim->renderer(), 1.0)) return to; - RefPtr<StyleImage> newContentImage = blendFunc(anim, from.image(), to.image(), progress); + return NinePieceImage(blendFunc(anim, from.image(), to.image(), progress), + from.imageSlices(), from.fill(), from.borderSlices(), from.outset(), from.horizontalRule(), from.verticalRule()); +} + +#if ENABLE(VARIATION_FONTS) - return NinePieceImage(newContentImage, from.imageSlices(), from.fill(), from.borderSlices(), from.outset(), from.horizontalRule(), from.verticalRule()); +static inline FontVariationSettings blendFunc(const AnimationBase* anim, const FontVariationSettings& from, const FontVariationSettings& to, double progress) +{ + if (from.size() != to.size()) + return FontVariationSettings(); + FontVariationSettings result; + unsigned size = from.size(); + for (unsigned i = 0; i < size; ++i) { + auto& fromItem = from.at(i); + auto& toItem = to.at(i); + if (fromItem.tag() != toItem.tag()) + return FontVariationSettings(); + float interpolated = blendFunc(anim, fromItem.value(), toItem.value(), progress); + result.insert({ fromItem.tag(), interpolated }); + } + return result; } +#endif + class AnimationPropertyWrapperBase { WTF_MAKE_NONCOPYABLE(AnimationPropertyWrapperBase); WTF_MAKE_FAST_ALLOCATED; @@ -386,12 +405,14 @@ public: virtual bool isShorthandWrapper() const { return false; } virtual bool equals(const RenderStyle* a, const RenderStyle* b) const = 0; virtual void blend(const AnimationBase*, RenderStyle*, const RenderStyle*, const RenderStyle*, double) const = 0; + +#if !LOG_DISABLED + virtual void logBlend(const RenderStyle* a, const RenderStyle* b, const RenderStyle* result, double) const = 0; +#endif CSSPropertyID property() const { return m_prop; } -#if USE(ACCELERATED_COMPOSITING) virtual bool animationIsAccelerated() const { return false; } -#endif private: CSSPropertyID m_prop; @@ -399,6 +420,7 @@ private: template <typename T> class PropertyWrapperGetter : public AnimationPropertyWrapperBase { + WTF_MAKE_FAST_ALLOCATED; public: PropertyWrapperGetter(CSSPropertyID prop, T (RenderStyle::*getter)() const) : AnimationPropertyWrapperBase(prop) @@ -406,23 +428,34 @@ public: { } - virtual bool equals(const RenderStyle* a, const RenderStyle* b) const + bool equals(const RenderStyle* a, const RenderStyle* b) const override { - // If the style pointers are the same, don't bother doing the test. - // If either is null, return false. If both are null, return true. - if ((!a && !b) || a == b) + if (a == b) return true; if (!a || !b) return false; return (a->*m_getter)() == (b->*m_getter)(); } + T value(const RenderStyle* a) const + { + return (a->*m_getter)(); + } + +#if !LOG_DISABLED + void logBlend(const RenderStyle* a, const RenderStyle* b, const RenderStyle* result, double progress) const final + { + LOG_WITH_STREAM(Animations, stream << " blending " << getPropertyName(property()) << " from " << value(a) << " to " << value(b) << " at " << TextStream::FormatNumberRespectingIntegers(progress) << " -> " << value(result)); + } +#endif + protected: T (RenderStyle::*m_getter)() const; }; template <typename T> class PropertyWrapper : public PropertyWrapperGetter<T> { + WTF_MAKE_FAST_ALLOCATED; public: PropertyWrapper(CSSPropertyID prop, T (RenderStyle::*getter)() const, void (RenderStyle::*setter)(T)) : PropertyWrapperGetter<T>(prop, getter) @@ -430,7 +463,7 @@ public: { } - virtual void blend(const AnimationBase* anim, RenderStyle* dst, const RenderStyle* a, const RenderStyle* b, double progress) const + void blend(const AnimationBase* anim, RenderStyle* dst, const RenderStyle* a, const RenderStyle* b, double progress) const override { (dst->*m_setter)(blendFunc(anim, (a->*PropertyWrapperGetter<T>::m_getter)(), (b->*PropertyWrapperGetter<T>::m_getter)(), progress)); } @@ -441,69 +474,131 @@ protected: template <typename T> class RefCountedPropertyWrapper : public PropertyWrapperGetter<T*> { + WTF_MAKE_FAST_ALLOCATED; public: - RefCountedPropertyWrapper(CSSPropertyID prop, T* (RenderStyle::*getter)() const, void (RenderStyle::*setter)(PassRefPtr<T>)) + RefCountedPropertyWrapper(CSSPropertyID prop, T* (RenderStyle::*getter)() const, void (RenderStyle::*setter)(RefPtr<T>&&)) : PropertyWrapperGetter<T*>(prop, getter) , m_setter(setter) { } - virtual void blend(const AnimationBase* anim, RenderStyle* dst, const RenderStyle* a, const RenderStyle* b, double progress) const + void blend(const AnimationBase* anim, RenderStyle* dst, const RenderStyle* a, const RenderStyle* b, double progress) const override { (dst->*m_setter)(blendFunc(anim, (a->*PropertyWrapperGetter<T*>::m_getter)(), (b->*PropertyWrapperGetter<T*>::m_getter)(), progress)); } protected: - void (RenderStyle::*m_setter)(PassRefPtr<T>); + void (RenderStyle::*m_setter)(RefPtr<T>&&); }; template <typename T> class LengthPropertyWrapper : public PropertyWrapperGetter<const T&> { + WTF_MAKE_FAST_ALLOCATED; public: - LengthPropertyWrapper(CSSPropertyID prop, const T& (RenderStyle::*getter)() const, void (RenderStyle::*setter)(T)) + LengthPropertyWrapper(CSSPropertyID prop, const T& (RenderStyle::*getter)() const, void (RenderStyle::*setter)(T&&)) : PropertyWrapperGetter<const T&>(prop, getter) , m_setter(setter) { } - virtual void blend(const AnimationBase* anim, RenderStyle* dst, const RenderStyle* a, const RenderStyle* b, double progress) const + void blend(const AnimationBase* anim, RenderStyle* dst, const RenderStyle* a, const RenderStyle* b, double progress) const override { (dst->*m_setter)(blendFunc(anim, (a->*PropertyWrapperGetter<const T&>::m_getter)(), (b->*PropertyWrapperGetter<const T&>::m_getter)(), progress)); } protected: - void (RenderStyle::*m_setter)(T); + void (RenderStyle::*m_setter)(T&&); }; class PropertyWrapperClipPath : public RefCountedPropertyWrapper<ClipPathOperation> { + WTF_MAKE_FAST_ALLOCATED; public: - PropertyWrapperClipPath(CSSPropertyID prop, ClipPathOperation* (RenderStyle::*getter)() const, void (RenderStyle::*setter)(PassRefPtr<ClipPathOperation>)) + PropertyWrapperClipPath(CSSPropertyID prop, ClipPathOperation* (RenderStyle::*getter)() const, void (RenderStyle::*setter)(RefPtr<ClipPathOperation>&&)) : RefCountedPropertyWrapper<ClipPathOperation>(prop, getter, setter) { } + + bool equals(const RenderStyle* a, const RenderStyle* b) const override + { + // If the style pointers are the same, don't bother doing the test. + // If either is null, return false. If both are null, return true. + if (a == b) + return true; + if (!a || !b) + return false; + + ClipPathOperation* clipPathA = (a->*m_getter)(); + ClipPathOperation* clipPathB = (b->*m_getter)(); + if (clipPathA == clipPathB) + return true; + if (!clipPathA || !clipPathB) + return false; + return *clipPathA == *clipPathB; + } +}; + +#if ENABLE(VARIATION_FONTS) +class PropertyWrapperFontVariationSettings : public PropertyWrapper<FontVariationSettings> { + WTF_MAKE_FAST_ALLOCATED; +public: + PropertyWrapperFontVariationSettings(CSSPropertyID prop, FontVariationSettings (RenderStyle::*getter)() const, void (RenderStyle::*setter)(FontVariationSettings)) + : PropertyWrapper<FontVariationSettings>(prop, getter, setter) + { + } + + bool equals(const RenderStyle* a, const RenderStyle* b) const override + { + // If the style pointers are the same, don't bother doing the test. + // If either is null, return false. If both are null, return true. + if (a == b) + return true; + if (!a || !b) + return false; + + const FontVariationSettings& variationSettingsA = (a->*m_getter)(); + const FontVariationSettings& variationSettingsB = (b->*m_getter)(); + return variationSettingsA == variationSettingsB; + } }; +#endif -#if ENABLE(CSS_SHAPES) class PropertyWrapperShape : public RefCountedPropertyWrapper<ShapeValue> { + WTF_MAKE_FAST_ALLOCATED; public: - PropertyWrapperShape(CSSPropertyID prop, ShapeValue* (RenderStyle::*getter)() const, void (RenderStyle::*setter)(PassRefPtr<ShapeValue>)) + PropertyWrapperShape(CSSPropertyID prop, ShapeValue* (RenderStyle::*getter)() const, void (RenderStyle::*setter)(RefPtr<ShapeValue>&&)) : RefCountedPropertyWrapper<ShapeValue>(prop, getter, setter) { } + + bool equals(const RenderStyle* a, const RenderStyle* b) const override + { + // If the style pointers are the same, don't bother doing the test. + // If either is null, return false. If both are null, return true. + if (a == b) + return true; + if (!a || !b) + return false; + + ShapeValue* shapeA = (a->*m_getter)(); + ShapeValue* shapeB = (b->*m_getter)(); + if (shapeA == shapeB) + return true; + if (!shapeA || !shapeB) + return false; + return *shapeA == *shapeB; + } }; -#endif class StyleImagePropertyWrapper : public RefCountedPropertyWrapper<StyleImage> { + WTF_MAKE_FAST_ALLOCATED; public: - StyleImagePropertyWrapper(CSSPropertyID prop, StyleImage* (RenderStyle::*getter)() const, void (RenderStyle::*setter)(PassRefPtr<StyleImage>)) + StyleImagePropertyWrapper(CSSPropertyID prop, StyleImage* (RenderStyle::*getter)() const, void (RenderStyle::*setter)(RefPtr<StyleImage>&&)) : RefCountedPropertyWrapper<StyleImage>(prop, getter, setter) { } - virtual bool equals(const RenderStyle* a, const RenderStyle* b) const + bool equals(const RenderStyle* a, const RenderStyle* b) const override { - // If the style pointers are the same, don't bother doing the test. - // If either is null, return false. If both are null, return true. if (a == b) return true; if (!a || !b) @@ -511,67 +606,82 @@ public: StyleImage* imageA = (a->*m_getter)(); StyleImage* imageB = (b->*m_getter)(); - return StyleImage::imagesEquivalent(imageA, imageB); + return arePointingToEqualData(imageA, imageB); } }; -class PropertyWrapperColor : public PropertyWrapperGetter<Color> { +class PropertyWrapperColor : public PropertyWrapperGetter<const Color&> { + WTF_MAKE_FAST_ALLOCATED; public: - PropertyWrapperColor(CSSPropertyID prop, Color (RenderStyle::*getter)() const, void (RenderStyle::*setter)(const Color&)) - : PropertyWrapperGetter<Color>(prop, getter) + PropertyWrapperColor(CSSPropertyID prop, const Color& (RenderStyle::*getter)() const, void (RenderStyle::*setter)(const Color&)) + : PropertyWrapperGetter<const Color&>(prop, getter) , m_setter(setter) { } - virtual void blend(const AnimationBase* anim, RenderStyle* dst, const RenderStyle* a, const RenderStyle* b, double progress) const + void blend(const AnimationBase* anim, RenderStyle* dst, const RenderStyle* a, const RenderStyle* b, double progress) const override { - (dst->*m_setter)(blendFunc(anim, (a->*PropertyWrapperGetter<Color>::m_getter)(), (b->*PropertyWrapperGetter<Color>::m_getter)(), progress)); + (dst->*m_setter)(blendFunc(anim, (a->*PropertyWrapperGetter<const Color&>::m_getter)(), (b->*PropertyWrapperGetter<const Color&>::m_getter)(), progress)); } protected: void (RenderStyle::*m_setter)(const Color&); }; - -#if USE(ACCELERATED_COMPOSITING) class PropertyWrapperAcceleratedOpacity : public PropertyWrapper<float> { + WTF_MAKE_FAST_ALLOCATED; public: PropertyWrapperAcceleratedOpacity() : PropertyWrapper<float>(CSSPropertyOpacity, &RenderStyle::opacity, &RenderStyle::setOpacity) { } - virtual bool animationIsAccelerated() const { return true; } + bool animationIsAccelerated() const override { return true; } - virtual void blend(const AnimationBase* anim, RenderStyle* dst, const RenderStyle* a, const RenderStyle* b, double progress) const + void blend(const AnimationBase* anim, RenderStyle* dst, const RenderStyle* a, const RenderStyle* b, double progress) const override { - float fromOpacity = a->opacity(); - - // This makes sure we put the object being animated into a RenderLayer during the animation - dst->setOpacity(blendFunc(anim, (fromOpacity == 1) ? 0.999999f : fromOpacity, b->opacity(), progress)); + dst->setOpacity(blendFunc(anim, a->opacity(), b->opacity(), progress)); } }; class PropertyWrapperAcceleratedTransform : public PropertyWrapper<const TransformOperations&> { + WTF_MAKE_FAST_ALLOCATED; public: PropertyWrapperAcceleratedTransform() - : PropertyWrapper<const TransformOperations&>(CSSPropertyWebkitTransform, &RenderStyle::transform, &RenderStyle::setTransform) + : PropertyWrapper<const TransformOperations&>(CSSPropertyTransform, &RenderStyle::transform, &RenderStyle::setTransform) { } - virtual bool animationIsAccelerated() const { return true; } + bool animationIsAccelerated() const override { return true; } - virtual void blend(const AnimationBase* anim, RenderStyle* dst, const RenderStyle* a, const RenderStyle* b, double progress) const + void blend(const AnimationBase* anim, RenderStyle* dst, const RenderStyle* a, const RenderStyle* b, double progress) const override { dst->setTransform(blendFunc(anim, a->transform(), b->transform(), progress)); } }; -#if ENABLE(CSS_FILTERS) class PropertyWrapperAcceleratedFilter : public PropertyWrapper<const FilterOperations&> { + WTF_MAKE_FAST_ALLOCATED; public: PropertyWrapperAcceleratedFilter() - : PropertyWrapper<const FilterOperations&>(CSSPropertyWebkitFilter, &RenderStyle::filter, &RenderStyle::setFilter) + : PropertyWrapper<const FilterOperations&>(CSSPropertyFilter, &RenderStyle::filter, &RenderStyle::setFilter) + { + } + + bool animationIsAccelerated() const override { return true; } + + void blend(const AnimationBase* anim, RenderStyle* dst, const RenderStyle* a, const RenderStyle* b, double progress) const override + { + dst->setFilter(blendFunc(anim, a->filter(), b->filter(), progress)); + } +}; + +#if ENABLE(FILTERS_LEVEL_2) +class PropertyWrapperAcceleratedBackdropFilter : public PropertyWrapper<const FilterOperations&> { + WTF_MAKE_FAST_ALLOCATED; +public: + PropertyWrapperAcceleratedBackdropFilter() + : PropertyWrapper<const FilterOperations&>(CSSPropertyWebkitBackdropFilter, &RenderStyle::backdropFilter, &RenderStyle::setBackdropFilter) { } @@ -579,11 +689,10 @@ public: virtual void blend(const AnimationBase* anim, RenderStyle* dst, const RenderStyle* a, const RenderStyle* b, double progress) const { - dst->setFilter(blendFunc(anim, a->filter(), b->filter(), progress)); + dst->setBackdropFilter(blendFunc(anim, a->backdropFilter(), b->backdropFilter(), progress, true)); } }; #endif -#endif // USE(ACCELERATED_COMPOSITING) static inline size_t shadowListLength(const ShadowData* shadow) { @@ -595,32 +704,37 @@ static inline size_t shadowListLength(const ShadowData* shadow) static inline const ShadowData* shadowForBlending(const ShadowData* srcShadow, const ShadowData* otherShadow) { - DEFINE_STATIC_LOCAL(ShadowData, defaultShadowData, (IntPoint(), 0, 0, Normal, false, Color::transparent)); - DEFINE_STATIC_LOCAL(ShadowData, defaultInsetShadowData, (IntPoint(), 0, 0, Inset, false, Color::transparent)); - - DEFINE_STATIC_LOCAL(ShadowData, defaultWebKitBoxShadowData, (IntPoint(), 0, 0, Normal, true, Color::transparent)); - DEFINE_STATIC_LOCAL(ShadowData, defaultInsetWebKitBoxShadowData, (IntPoint(), 0, 0, Inset, true, Color::transparent)); + static NeverDestroyed<ShadowData> defaultShadowData(IntPoint(), 0, 0, Normal, false, Color::transparent); + static NeverDestroyed<ShadowData> defaultInsetShadowData(IntPoint(), 0, 0, Inset, false, Color::transparent); + static NeverDestroyed<ShadowData> defaultWebKitBoxShadowData(IntPoint(), 0, 0, Normal, true, Color::transparent); + static NeverDestroyed<ShadowData> defaultInsetWebKitBoxShadowData(IntPoint(), 0, 0, Inset, true, Color::transparent); if (srcShadow) return srcShadow; if (otherShadow->style() == Inset) - return otherShadow->isWebkitBoxShadow() ? &defaultInsetWebKitBoxShadowData : &defaultInsetShadowData; + return otherShadow->isWebkitBoxShadow() ? &defaultInsetWebKitBoxShadowData.get() : &defaultInsetShadowData.get(); - return otherShadow->isWebkitBoxShadow() ? &defaultWebKitBoxShadowData : &defaultShadowData; + return otherShadow->isWebkitBoxShadow() ? &defaultWebKitBoxShadowData.get() : &defaultShadowData.get(); } class PropertyWrapperShadow : public AnimationPropertyWrapperBase { + WTF_MAKE_FAST_ALLOCATED; public: - PropertyWrapperShadow(CSSPropertyID prop, const ShadowData* (RenderStyle::*getter)() const, void (RenderStyle::*setter)(PassOwnPtr<ShadowData>, bool)) + PropertyWrapperShadow(CSSPropertyID prop, const ShadowData* (RenderStyle::*getter)() const, void (RenderStyle::*setter)(std::unique_ptr<ShadowData>, bool)) : AnimationPropertyWrapperBase(prop) , m_getter(getter) , m_setter(setter) { } - virtual bool equals(const RenderStyle* a, const RenderStyle* b) const + bool equals(const RenderStyle* a, const RenderStyle* b) const override { + if (a == b) + return true; + if (!a || !b) + return false; + const ShadowData* shadowA = (a->*m_getter)(); const ShadowData* shadowB = (b->*m_getter)(); @@ -643,7 +757,7 @@ public: return true; } - virtual void blend(const AnimationBase* anim, RenderStyle* dst, const RenderStyle* a, const RenderStyle* b, double progress) const + void blend(const AnimationBase* anim, RenderStyle* dst, const RenderStyle* a, const RenderStyle* b, double progress) const override { const ShadowData* shadowA = (a->*m_getter)(); const ShadowData* shadowB = (b->*m_getter)(); @@ -659,23 +773,31 @@ public: (dst->*m_setter)(blendMismatchedShadowLists(anim, progress, shadowA, shadowB, fromLength, toLength), false); } +#if !LOG_DISABLED + void logBlend(const RenderStyle*, const RenderStyle*, const RenderStyle*, double progress) const final + { + // FIXME: better logging. + LOG_WITH_STREAM(Animations, stream << " blending ShadowData at " << TextStream::FormatNumberRespectingIntegers(progress)); + } +#endif + private: - PassOwnPtr<ShadowData> blendSimpleOrMatchedShadowLists(const AnimationBase* anim, double progress, const ShadowData* shadowA, const ShadowData* shadowB) const + std::unique_ptr<ShadowData> blendSimpleOrMatchedShadowLists(const AnimationBase* anim, double progress, const ShadowData* shadowA, const ShadowData* shadowB) const { - OwnPtr<ShadowData> newShadowData; + std::unique_ptr<ShadowData> newShadowData; ShadowData* lastShadow = 0; while (shadowA || shadowB) { const ShadowData* srcShadow = shadowForBlending(shadowA, shadowB); const ShadowData* dstShadow = shadowForBlending(shadowB, shadowA); - OwnPtr<ShadowData> blendedShadow = blendFunc(anim, srcShadow, dstShadow, progress); + std::unique_ptr<ShadowData> blendedShadow = blendFunc(anim, srcShadow, dstShadow, progress); ShadowData* blendedShadowPtr = blendedShadow.get(); if (!lastShadow) - newShadowData = blendedShadow.release(); + newShadowData = WTFMove(blendedShadow); else - lastShadow->setNext(blendedShadow.release()); + lastShadow->setNext(WTFMove(blendedShadow)); lastShadow = blendedShadowPtr; @@ -683,10 +805,10 @@ private: shadowB = shadowB ? shadowB->next() : 0; } - return newShadowData.release(); + return newShadowData; } - PassOwnPtr<ShadowData> blendMismatchedShadowLists(const AnimationBase* anim, double progress, const ShadowData* shadowA, const ShadowData* shadowB, int fromLength, int toLength) const + std::unique_ptr<ShadowData> blendMismatchedShadowLists(const AnimationBase* anim, double progress, const ShadowData* shadowA, const ShadowData* shadowB, int fromLength, int toLength) const { // The shadows in ShadowData are stored in reverse order, so when animating mismatched lists, // reverse them and match from the end. @@ -702,7 +824,7 @@ private: shadowB = shadowB->next(); } - OwnPtr<ShadowData> newShadowData; + std::unique_ptr<ShadowData> newShadowData; int maxLength = std::max(fromLength, toLength); for (int i = 0; i < maxLength; ++i) { @@ -712,32 +834,38 @@ private: const ShadowData* srcShadow = shadowForBlending(fromShadow, toShadow); const ShadowData* dstShadow = shadowForBlending(toShadow, fromShadow); - OwnPtr<ShadowData> blendedShadow = blendFunc(anim, srcShadow, dstShadow, progress); + std::unique_ptr<ShadowData> blendedShadow = blendFunc(anim, srcShadow, dstShadow, progress); // Insert at the start of the list to preserve the order. - blendedShadow->setNext(newShadowData.release()); - newShadowData = blendedShadow.release(); + blendedShadow->setNext(WTFMove(newShadowData)); + newShadowData = WTFMove(blendedShadow); } - return newShadowData.release(); + return newShadowData; } const ShadowData* (RenderStyle::*m_getter)() const; - void (RenderStyle::*m_setter)(PassOwnPtr<ShadowData>, bool); + void (RenderStyle::*m_setter)(std::unique_ptr<ShadowData>, bool); }; class PropertyWrapperMaybeInvalidColor : public AnimationPropertyWrapperBase { + WTF_MAKE_FAST_ALLOCATED; public: - PropertyWrapperMaybeInvalidColor(CSSPropertyID prop, Color (RenderStyle::*getter)() const, void (RenderStyle::*setter)(const Color&)) + PropertyWrapperMaybeInvalidColor(CSSPropertyID prop, const Color& (RenderStyle::*getter)() const, void (RenderStyle::*setter)(const Color&)) : AnimationPropertyWrapperBase(prop) , m_getter(getter) , m_setter(setter) { } - virtual bool equals(const RenderStyle* a, const RenderStyle* b) const + bool equals(const RenderStyle* a, const RenderStyle* b) const override { - Color fromColor = (a->*m_getter)(); - Color toColor = (b->*m_getter)(); + if (a == b) + return true; + if (!a || !b) + return false; + + Color fromColor = value(a); + Color toColor = value(b); if (!fromColor.isValid() && !toColor.isValid()) return true; @@ -750,10 +878,10 @@ public: return fromColor == toColor; } - virtual void blend(const AnimationBase* anim, RenderStyle* dst, const RenderStyle* a, const RenderStyle* b, double progress) const + void blend(const AnimationBase* anim, RenderStyle* dst, const RenderStyle* a, const RenderStyle* b, double progress) const override { - Color fromColor = (a->*m_getter)(); - Color toColor = (b->*m_getter)(); + Color fromColor = value(a); + Color toColor = value(b); if (!fromColor.isValid() && !toColor.isValid()) return; @@ -765,46 +893,69 @@ public: (dst->*m_setter)(blendFunc(anim, fromColor, toColor, progress)); } + Color value(const RenderStyle* a) const + { + return (a->*m_getter)(); + } + +#if !LOG_DISABLED + void logBlend(const RenderStyle* a, const RenderStyle* b, const RenderStyle* result, double progress) const final + { + // FIXME: better logging. + LOG_WITH_STREAM(Animations, stream << " blending " << getPropertyName(property()) << " from " << value(a) << " to " << value(b) << " at " << TextStream::FormatNumberRespectingIntegers(progress) << " -> " << value(result)); + } +#endif + private: - Color (RenderStyle::*m_getter)() const; + const Color& (RenderStyle::*m_getter)() const; void (RenderStyle::*m_setter)(const Color&); }; enum MaybeInvalidColorTag { MaybeInvalidColor }; class PropertyWrapperVisitedAffectedColor : public AnimationPropertyWrapperBase { + WTF_MAKE_FAST_ALLOCATED; public: - PropertyWrapperVisitedAffectedColor(CSSPropertyID prop, Color (RenderStyle::*getter)() const, void (RenderStyle::*setter)(const Color&), - Color (RenderStyle::*visitedGetter)() const, void (RenderStyle::*visitedSetter)(const Color&)) + PropertyWrapperVisitedAffectedColor(CSSPropertyID prop, const Color& (RenderStyle::*getter)() const, void (RenderStyle::*setter)(const Color&), + const Color& (RenderStyle::*visitedGetter)() const, void (RenderStyle::*visitedSetter)(const Color&)) : AnimationPropertyWrapperBase(prop) - , m_wrapper(adoptPtr(new PropertyWrapperColor(prop, getter, setter))) - , m_visitedWrapper(adoptPtr(new PropertyWrapperColor(prop, visitedGetter, visitedSetter))) + , m_wrapper(std::make_unique<PropertyWrapperColor>(prop, getter, setter)) + , m_visitedWrapper(std::make_unique<PropertyWrapperColor>(prop, visitedGetter, visitedSetter)) { } - PropertyWrapperVisitedAffectedColor(CSSPropertyID prop, MaybeInvalidColorTag, Color (RenderStyle::*getter)() const, void (RenderStyle::*setter)(const Color&), - Color (RenderStyle::*visitedGetter)() const, void (RenderStyle::*visitedSetter)(const Color&)) + PropertyWrapperVisitedAffectedColor(CSSPropertyID prop, MaybeInvalidColorTag, const Color& (RenderStyle::*getter)() const, void (RenderStyle::*setter)(const Color&), + const Color& (RenderStyle::*visitedGetter)() const, void (RenderStyle::*visitedSetter)(const Color&)) : AnimationPropertyWrapperBase(prop) - , m_wrapper(adoptPtr(new PropertyWrapperMaybeInvalidColor(prop, getter, setter))) - , m_visitedWrapper(adoptPtr(new PropertyWrapperMaybeInvalidColor(prop, visitedGetter, visitedSetter))) + , m_wrapper(std::make_unique<PropertyWrapperMaybeInvalidColor>(prop, getter, setter)) + , m_visitedWrapper(std::make_unique<PropertyWrapperMaybeInvalidColor>(prop, visitedGetter, visitedSetter)) { } - virtual bool equals(const RenderStyle* a, const RenderStyle* b) const + bool equals(const RenderStyle* a, const RenderStyle* b) const override { return m_wrapper->equals(a, b) && m_visitedWrapper->equals(a, b); } - virtual void blend(const AnimationBase* anim, RenderStyle* dst, const RenderStyle* a, const RenderStyle* b, double progress) const + void blend(const AnimationBase* anim, RenderStyle* dst, const RenderStyle* a, const RenderStyle* b, double progress) const override { m_wrapper->blend(anim, dst, a, b, progress); m_visitedWrapper->blend(anim, dst, a, b, progress); } +#if !LOG_DISABLED + void logBlend(const RenderStyle* a, const RenderStyle* b, const RenderStyle* result, double progress) const final + { + m_wrapper->logBlend(a, b, result, progress); + m_visitedWrapper->logBlend(a, b, result, progress); + } +#endif + private: - OwnPtr<AnimationPropertyWrapperBase> m_wrapper; - OwnPtr<AnimationPropertyWrapperBase> m_visitedWrapper; + std::unique_ptr<AnimationPropertyWrapperBase> m_wrapper; + std::unique_ptr<AnimationPropertyWrapperBase> m_visitedWrapper; }; // Wrapper base class for an animatable property in a FillLayer class FillLayerAnimationPropertyWrapperBase { + WTF_MAKE_FAST_ALLOCATED; public: FillLayerAnimationPropertyWrapperBase() { @@ -818,6 +969,7 @@ public: template <typename T> class FillLayerPropertyWrapperGetter : public FillLayerAnimationPropertyWrapperBase { + WTF_MAKE_FAST_ALLOCATED; WTF_MAKE_NONCOPYABLE(FillLayerPropertyWrapperGetter); public: FillLayerPropertyWrapperGetter(T (FillLayer::*getter)() const) @@ -825,13 +977,11 @@ public: { } - virtual bool equals(const FillLayer* a, const FillLayer* b) const + bool equals(const FillLayer* a, const FillLayer* b) const override { - // If the style pointers are the same, don't bother doing the test. - // If either is null, return false. If both are null, return true. - if ((!a && !b) || a == b) - return true; - if (!a || !b) + if (a == b) + return true; + if (!a || !b) return false; return (a->*m_getter)() == (b->*m_getter)(); } @@ -842,6 +992,7 @@ protected: template <typename T> class FillLayerPropertyWrapper : public FillLayerPropertyWrapperGetter<const T&> { + WTF_MAKE_FAST_ALLOCATED; public: FillLayerPropertyWrapper(const T& (FillLayer::*getter)() const, void (FillLayer::*setter)(T)) : FillLayerPropertyWrapperGetter<const T&>(getter) @@ -849,7 +1000,7 @@ public: { } - virtual void blend(const AnimationBase* anim, FillLayer* dst, const FillLayer* a, const FillLayer* b, double progress) const + void blend(const AnimationBase* anim, FillLayer* dst, const FillLayer* a, const FillLayer* b, double progress) const override { (dst->*m_setter)(blendFunc(anim, (a->*FillLayerPropertyWrapperGetter<const T&>::m_getter)(), (b->*FillLayerPropertyWrapperGetter<const T&>::m_getter)(), progress)); } @@ -860,33 +1011,33 @@ protected: template <typename T> class FillLayerRefCountedPropertyWrapper : public FillLayerPropertyWrapperGetter<T*> { + WTF_MAKE_FAST_ALLOCATED; public: - FillLayerRefCountedPropertyWrapper(T* (FillLayer::*getter)() const, void (FillLayer::*setter)(PassRefPtr<T>)) + FillLayerRefCountedPropertyWrapper(T* (FillLayer::*getter)() const, void (FillLayer::*setter)(RefPtr<T>&&)) : FillLayerPropertyWrapperGetter<T*>(getter) , m_setter(setter) { } - virtual void blend(const AnimationBase* anim, FillLayer* dst, const FillLayer* a, const FillLayer* b, double progress) const + void blend(const AnimationBase* anim, FillLayer* dst, const FillLayer* a, const FillLayer* b, double progress) const override { (dst->*m_setter)(blendFunc(anim, (a->*FillLayerPropertyWrapperGetter<T*>::m_getter)(), (b->*FillLayerPropertyWrapperGetter<T*>::m_getter)(), progress)); } protected: - void (FillLayer::*m_setter)(PassRefPtr<T>); + void (FillLayer::*m_setter)(RefPtr<T>&&); }; class FillLayerStyleImagePropertyWrapper : public FillLayerRefCountedPropertyWrapper<StyleImage> { + WTF_MAKE_FAST_ALLOCATED; public: - FillLayerStyleImagePropertyWrapper(StyleImage* (FillLayer::*getter)() const, void (FillLayer::*setter)(PassRefPtr<StyleImage>)) + FillLayerStyleImagePropertyWrapper(StyleImage* (FillLayer::*getter)() const, void (FillLayer::*setter)(RefPtr<StyleImage>&&)) : FillLayerRefCountedPropertyWrapper<StyleImage>(getter, setter) { } - virtual bool equals(const FillLayer* a, const FillLayer* b) const + bool equals(const FillLayer* a, const FillLayer* b) const override { - // If the style pointers are the same, don't bother doing the test. - // If either is null, return false. If both are null, return true. if (a == b) return true; if (!a || !b) @@ -894,14 +1045,15 @@ public: StyleImage* imageA = (a->*m_getter)(); StyleImage* imageB = (b->*m_getter)(); - return StyleImage::imagesEquivalent(imageA, imageB); + return arePointingToEqualData(imageA, imageB); } }; class FillLayersPropertyWrapper : public AnimationPropertyWrapperBase { + WTF_MAKE_FAST_ALLOCATED; public: - typedef const FillLayer* (RenderStyle::*LayersGetter)() const; - typedef FillLayer* (RenderStyle::*LayersAccessor)(); + typedef const FillLayer& (RenderStyle::*LayersGetter)() const; + typedef FillLayer& (RenderStyle::*LayersAccessor)(); FillLayersPropertyWrapper(CSSPropertyID prop, LayersGetter getter, LayersAccessor accessor) : AnimationPropertyWrapperBase(prop) @@ -911,29 +1063,34 @@ public: switch (prop) { case CSSPropertyBackgroundPositionX: case CSSPropertyWebkitMaskPositionX: - m_fillLayerPropertyWrapper = new FillLayerPropertyWrapper<Length>(&FillLayer::xPosition, &FillLayer::setXPosition); + m_fillLayerPropertyWrapper = std::make_unique<FillLayerPropertyWrapper<Length>>(&FillLayer::xPosition, &FillLayer::setXPosition); break; case CSSPropertyBackgroundPositionY: case CSSPropertyWebkitMaskPositionY: - m_fillLayerPropertyWrapper = new FillLayerPropertyWrapper<Length>(&FillLayer::yPosition, &FillLayer::setYPosition); + m_fillLayerPropertyWrapper = std::make_unique<FillLayerPropertyWrapper<Length>>(&FillLayer::yPosition, &FillLayer::setYPosition); break; case CSSPropertyBackgroundSize: case CSSPropertyWebkitBackgroundSize: case CSSPropertyWebkitMaskSize: - m_fillLayerPropertyWrapper = new FillLayerPropertyWrapper<LengthSize>(&FillLayer::sizeLength, &FillLayer::setSizeLength); + m_fillLayerPropertyWrapper = std::make_unique<FillLayerPropertyWrapper<LengthSize>>(&FillLayer::sizeLength, &FillLayer::setSizeLength); break; case CSSPropertyBackgroundImage: - m_fillLayerPropertyWrapper = new FillLayerStyleImagePropertyWrapper(&FillLayer::image, &FillLayer::setImage); + m_fillLayerPropertyWrapper = std::make_unique<FillLayerStyleImagePropertyWrapper>(&FillLayer::image, &FillLayer::setImage); break; default: break; } } - virtual bool equals(const RenderStyle* a, const RenderStyle* b) const + bool equals(const RenderStyle* a, const RenderStyle* b) const override { - const FillLayer* fromLayer = (a->*m_layersGetter)(); - const FillLayer* toLayer = (b->*m_layersGetter)(); + if (a == b) + return true; + if (!a || !b) + return false; + + auto* fromLayer = &(a->*m_layersGetter)(); + auto* toLayer = &(b->*m_layersGetter)(); while (fromLayer && toLayer) { if (!m_fillLayerPropertyWrapper->equals(fromLayer, toLayer)) @@ -946,11 +1103,11 @@ public: return true; } - virtual void blend(const AnimationBase* anim, RenderStyle* dst, const RenderStyle* a, const RenderStyle* b, double progress) const + void blend(const AnimationBase* anim, RenderStyle* dst, const RenderStyle* a, const RenderStyle* b, double progress) const override { - const FillLayer* aLayer = (a->*m_layersGetter)(); - const FillLayer* bLayer = (b->*m_layersGetter)(); - FillLayer* dstLayer = (dst->*m_layersAccessor)(); + auto* aLayer = &(a->*m_layersGetter)(); + auto* bLayer = &(b->*m_layersGetter)(); + auto* dstLayer = &(dst->*m_layersAccessor)(); while (aLayer && bLayer && dstLayer) { m_fillLayerPropertyWrapper->blend(anim, dstLayer, aLayer, bLayer, progress); @@ -960,57 +1117,77 @@ public: } } +#if !LOG_DISABLED + void logBlend(const RenderStyle*, const RenderStyle*, const RenderStyle*, double progress) const final + { + // FIXME: better logging. + LOG_WITH_STREAM(Animations, stream << " blending FillLayers at " << TextStream::FormatNumberRespectingIntegers(progress)); + } +#endif + private: - FillLayerAnimationPropertyWrapperBase* m_fillLayerPropertyWrapper; + std::unique_ptr<FillLayerAnimationPropertyWrapperBase> m_fillLayerPropertyWrapper; LayersGetter m_layersGetter; LayersAccessor m_layersAccessor; }; class ShorthandPropertyWrapper : public AnimationPropertyWrapperBase { + WTF_MAKE_FAST_ALLOCATED; public: ShorthandPropertyWrapper(CSSPropertyID property, Vector<AnimationPropertyWrapperBase*> longhandWrappers) : AnimationPropertyWrapperBase(property) + , m_propertyWrappers(WTFMove(longhandWrappers)) { - m_propertyWrappers.swap(longhandWrappers); } - virtual bool isShorthandWrapper() const { return true; } + bool isShorthandWrapper() const override { return true; } - virtual bool equals(const RenderStyle* a, const RenderStyle* b) const + bool equals(const RenderStyle* a, const RenderStyle* b) const override { - Vector<AnimationPropertyWrapperBase*>::const_iterator end = m_propertyWrappers.end(); - for (Vector<AnimationPropertyWrapperBase*>::const_iterator it = m_propertyWrappers.begin(); it != end; ++it) { - if (!(*it)->equals(a, b)) + if (a == b) + return true; + if (!a || !b) + return false; + + for (auto& wrapper : m_propertyWrappers) { + if (!wrapper->equals(a, b)) return false; } return true; } - virtual void blend(const AnimationBase* anim, RenderStyle* dst, const RenderStyle* a, const RenderStyle* b, double progress) const + void blend(const AnimationBase* anim, RenderStyle* dst, const RenderStyle* a, const RenderStyle* b, double progress) const override + { + for (auto& wrapper : m_propertyWrappers) + wrapper->blend(anim, dst, a, b, progress); + } + +#if !LOG_DISABLED + void logBlend(const RenderStyle*, const RenderStyle*, const RenderStyle*, double progress) const final { - Vector<AnimationPropertyWrapperBase*>::const_iterator end = m_propertyWrappers.end(); - for (Vector<AnimationPropertyWrapperBase*>::const_iterator it = m_propertyWrappers.begin(); it != end; ++it) - (*it)->blend(anim, dst, a, b, progress); + // FIXME: better logging. + LOG_WITH_STREAM(Animations, stream << " blending shorthand property " << getPropertyName(property()) << " at " << TextStream::FormatNumberRespectingIntegers(progress)); } +#endif - const Vector<AnimationPropertyWrapperBase*> propertyWrappers() const { return m_propertyWrappers; } + const Vector<AnimationPropertyWrapperBase*>& propertyWrappers() const { return m_propertyWrappers; } private: Vector<AnimationPropertyWrapperBase*> m_propertyWrappers; }; class PropertyWrapperFlex : public AnimationPropertyWrapperBase { + WTF_MAKE_FAST_ALLOCATED; public: - PropertyWrapperFlex() : AnimationPropertyWrapperBase(CSSPropertyWebkitFlex) + PropertyWrapperFlex() + : AnimationPropertyWrapperBase(CSSPropertyFlex) { } - virtual bool equals(const RenderStyle* a, const RenderStyle* b) const + bool equals(const RenderStyle* a, const RenderStyle* b) const override { - // If the style pointers are the same, don't bother doing the test. - // If either is null, return false. If both are null, return true. - if ((!a && !b) || a == b) + if (a == b) return true; if (!a || !b) return false; @@ -1018,18 +1195,26 @@ public: return a->flexBasis() == b->flexBasis() && a->flexGrow() == b->flexGrow() && a->flexShrink() == b->flexShrink(); } - virtual void blend(const AnimationBase* anim, RenderStyle* dst, const RenderStyle* a, const RenderStyle* b, double progress) const + void blend(const AnimationBase* anim, RenderStyle* dst, const RenderStyle* a, const RenderStyle* b, double progress) const override { dst->setFlexBasis(blendFunc(anim, a->flexBasis(), b->flexBasis(), progress)); dst->setFlexGrow(blendFunc(anim, a->flexGrow(), b->flexGrow(), progress)); dst->setFlexShrink(blendFunc(anim, a->flexShrink(), b->flexShrink(), progress)); } + +#if !LOG_DISABLED + void logBlend(const RenderStyle*, const RenderStyle*, const RenderStyle*, double progress) const final + { + // FIXME: better logging. + LOG_WITH_STREAM(Animations, stream << " blending flex at " << TextStream::FormatNumberRespectingIntegers(progress)); + } +#endif }; -#if ENABLE(SVG) class PropertyWrapperSVGPaint : public AnimationPropertyWrapperBase { + WTF_MAKE_FAST_ALLOCATED; public: - PropertyWrapperSVGPaint(CSSPropertyID prop, const SVGPaint::SVGPaintType& (RenderStyle::*paintTypeGetter)() const, Color (RenderStyle::*getter)() const, void (RenderStyle::*setter)(const Color&)) + PropertyWrapperSVGPaint(CSSPropertyID prop, const SVGPaintType& (RenderStyle::*paintTypeGetter)() const, Color (RenderStyle::*getter)() const, void (RenderStyle::*setter)(const Color&)) : AnimationPropertyWrapperBase(prop) , m_paintTypeGetter(paintTypeGetter) , m_getter(getter) @@ -1037,15 +1222,20 @@ public: { } - virtual bool equals(const RenderStyle* a, const RenderStyle* b) const + bool equals(const RenderStyle* a, const RenderStyle* b) const override { + if (a == b) + return true; + if (!a || !b) + return false; + if ((a->*m_paintTypeGetter)() != (b->*m_paintTypeGetter)()) return false; // We only support animations between SVGPaints that are pure Color values. // For everything else we must return true for this method, otherwise // we will try to animate between values forever. - if ((a->*m_paintTypeGetter)() == SVGPaint::SVG_PAINTTYPE_RGBCOLOR) { + if ((a->*m_paintTypeGetter)() == SVG_PAINTTYPE_RGBCOLOR) { Color fromColor = (a->*m_getter)(); Color toColor = (b->*m_getter)(); @@ -1062,10 +1252,10 @@ public: return true; } - virtual void blend(const AnimationBase* anim, RenderStyle* dst, const RenderStyle* a, const RenderStyle* b, double progress) const + void blend(const AnimationBase* anim, RenderStyle* dst, const RenderStyle* a, const RenderStyle* b, double progress) const override { - if ((a->*m_paintTypeGetter)() != SVGPaint::SVG_PAINTTYPE_RGBCOLOR - || (b->*m_paintTypeGetter)() != SVGPaint::SVG_PAINTTYPE_RGBCOLOR) + if ((a->*m_paintTypeGetter)() != SVG_PAINTTYPE_RGBCOLOR + || (b->*m_paintTypeGetter)() != SVG_PAINTTYPE_RGBCOLOR) return; Color fromColor = (a->*m_getter)(); @@ -1081,32 +1271,38 @@ public: (dst->*m_setter)(blendFunc(anim, fromColor, toColor, progress)); } +#if !LOG_DISABLED + void logBlend(const RenderStyle*, const RenderStyle*, const RenderStyle*, double progress) const final + { + // FIXME: better logging. + LOG_WITH_STREAM(Animations, stream << " blending SVGPaint at " << TextStream::FormatNumberRespectingIntegers(progress)); + } +#endif + private: - const SVGPaint::SVGPaintType& (RenderStyle::*m_paintTypeGetter)() const; + const SVGPaintType& (RenderStyle::*m_paintTypeGetter)() const; Color (RenderStyle::*m_getter)() const; void (RenderStyle::*m_setter)(const Color&); }; -#endif class CSSPropertyAnimationWrapperMap { + WTF_MAKE_FAST_ALLOCATED; public: - static CSSPropertyAnimationWrapperMap& instance() + static CSSPropertyAnimationWrapperMap& singleton() { - // FIXME: This data is never destroyed. Maybe we should ref count it and toss it when the last AnimationController is destroyed? - DEFINE_STATIC_LOCAL(OwnPtr<CSSPropertyAnimationWrapperMap>, map, ()); - if (!map) - map = adoptPtr(new CSSPropertyAnimationWrapperMap); - return *map; + // FIXME: This data is never destroyed. Maybe we should ref count it and toss it when the last CSSAnimationController is destroyed? + static NeverDestroyed<CSSPropertyAnimationWrapperMap> map; + return map; } AnimationPropertyWrapperBase* wrapperForProperty(CSSPropertyID propertyID) { if (propertyID < firstCSSProperty || propertyID > lastCSSProperty) - return 0; + return nullptr; unsigned wrapperIndex = indexFromPropertyID(propertyID); if (wrapperIndex == cInvalidPropertyWrapperIndex) - return 0; + return nullptr; return m_propertyWrappers[wrapperIndex].get(); } @@ -1124,15 +1320,19 @@ public: private: CSSPropertyAnimationWrapperMap(); + ~CSSPropertyAnimationWrapperMap() = delete; + unsigned char& indexFromPropertyID(CSSPropertyID propertyID) { return m_propertyToIdMap[propertyID - firstCSSProperty]; } - Vector<OwnPtr<AnimationPropertyWrapperBase>> m_propertyWrappers; + Vector<std::unique_ptr<AnimationPropertyWrapperBase>> m_propertyWrappers; unsigned char m_propertyToIdMap[numCSSProperties]; static const unsigned char cInvalidPropertyWrapperIndex = UCHAR_MAX; + + friend class WTF::NeverDestroyed<CSSPropertyAnimationWrapperMap>; }; CSSPropertyAnimationWrapperMap::CSSPropertyAnimationWrapperMap() @@ -1154,10 +1354,10 @@ CSSPropertyAnimationWrapperMap::CSSPropertyAnimationWrapperMap() new PropertyWrapperFlex(), - new PropertyWrapper<unsigned>(CSSPropertyBorderLeftWidth, &RenderStyle::borderLeftWidth, &RenderStyle::setBorderLeftWidth), - new PropertyWrapper<unsigned>(CSSPropertyBorderRightWidth, &RenderStyle::borderRightWidth, &RenderStyle::setBorderRightWidth), - new PropertyWrapper<unsigned>(CSSPropertyBorderTopWidth, &RenderStyle::borderTopWidth, &RenderStyle::setBorderTopWidth), - new PropertyWrapper<unsigned>(CSSPropertyBorderBottomWidth, &RenderStyle::borderBottomWidth, &RenderStyle::setBorderBottomWidth), + new PropertyWrapper<float>(CSSPropertyBorderLeftWidth, &RenderStyle::borderLeftWidth, &RenderStyle::setBorderLeftWidth), + new PropertyWrapper<float>(CSSPropertyBorderRightWidth, &RenderStyle::borderRightWidth, &RenderStyle::setBorderRightWidth), + new PropertyWrapper<float>(CSSPropertyBorderTopWidth, &RenderStyle::borderTopWidth, &RenderStyle::setBorderTopWidth), + new PropertyWrapper<float>(CSSPropertyBorderBottomWidth, &RenderStyle::borderBottomWidth, &RenderStyle::setBorderBottomWidth), new LengthPropertyWrapper<Length>(CSSPropertyMarginLeft, &RenderStyle::marginLeft, &RenderStyle::setMarginLeft), new LengthPropertyWrapper<Length>(CSSPropertyMarginRight, &RenderStyle::marginRight, &RenderStyle::setMarginRight), new LengthPropertyWrapper<Length>(CSSPropertyMarginTop, &RenderStyle::marginTop, &RenderStyle::setMarginTop), @@ -1170,7 +1370,7 @@ CSSPropertyAnimationWrapperMap::CSSPropertyAnimationWrapperMap() new PropertyWrapperVisitedAffectedColor(CSSPropertyBackgroundColor, &RenderStyle::backgroundColor, &RenderStyle::setBackgroundColor, &RenderStyle::visitedLinkBackgroundColor, &RenderStyle::setVisitedLinkBackgroundColor), - new FillLayersPropertyWrapper(CSSPropertyBackgroundImage, &RenderStyle::backgroundLayers, &RenderStyle::accessBackgroundLayers), + new FillLayersPropertyWrapper(CSSPropertyBackgroundImage, &RenderStyle::backgroundLayers, &RenderStyle::ensureBackgroundLayers), new StyleImagePropertyWrapper(CSSPropertyListStyleImage, &RenderStyle::listStyleImage, &RenderStyle::setListStyleImage), new StyleImagePropertyWrapper(CSSPropertyWebkitMaskImage, &RenderStyle::maskImage, &RenderStyle::setMaskImage), @@ -1182,47 +1382,38 @@ CSSPropertyAnimationWrapperMap::CSSPropertyAnimationWrapperMap() new StyleImagePropertyWrapper(CSSPropertyWebkitMaskBoxImageSource, &RenderStyle::maskBoxImageSource, &RenderStyle::setMaskBoxImageSource), new PropertyWrapper<const NinePieceImage&>(CSSPropertyWebkitMaskBoxImage, &RenderStyle::maskBoxImage, &RenderStyle::setMaskBoxImage), - new FillLayersPropertyWrapper(CSSPropertyBackgroundPositionX, &RenderStyle::backgroundLayers, &RenderStyle::accessBackgroundLayers), - new FillLayersPropertyWrapper(CSSPropertyBackgroundPositionY, &RenderStyle::backgroundLayers, &RenderStyle::accessBackgroundLayers), - new FillLayersPropertyWrapper(CSSPropertyBackgroundSize, &RenderStyle::backgroundLayers, &RenderStyle::accessBackgroundLayers), - new FillLayersPropertyWrapper(CSSPropertyWebkitBackgroundSize, &RenderStyle::backgroundLayers, &RenderStyle::accessBackgroundLayers), - - new FillLayersPropertyWrapper(CSSPropertyWebkitMaskPositionX, &RenderStyle::maskLayers, &RenderStyle::accessMaskLayers), - new FillLayersPropertyWrapper(CSSPropertyWebkitMaskPositionY, &RenderStyle::maskLayers, &RenderStyle::accessMaskLayers), - new FillLayersPropertyWrapper(CSSPropertyWebkitMaskSize, &RenderStyle::maskLayers, &RenderStyle::accessMaskLayers), - - new PropertyWrapper<float>(CSSPropertyFontSize, - // Must pass a specified size to setFontSize if Text Autosizing is enabled, but a computed size - // if text zoom is enabled (if neither is enabled it's irrelevant as they're probably the same). - // FIXME: Find some way to assert that text zoom isn't activated when Text Autosizing is compiled in. -#if ENABLE(TEXT_AUTOSIZING) - &RenderStyle::specifiedFontSize, -#else - &RenderStyle::computedFontSize, -#endif - &RenderStyle::setFontSize), - new PropertyWrapper<unsigned short>(CSSPropertyWebkitColumnRuleWidth, &RenderStyle::columnRuleWidth, &RenderStyle::setColumnRuleWidth), - new PropertyWrapper<float>(CSSPropertyWebkitColumnGap, &RenderStyle::columnGap, &RenderStyle::setColumnGap), - new PropertyWrapper<unsigned short>(CSSPropertyWebkitColumnCount, &RenderStyle::columnCount, &RenderStyle::setColumnCount), - new PropertyWrapper<float>(CSSPropertyWebkitColumnWidth, &RenderStyle::columnWidth, &RenderStyle::setColumnWidth), - new PropertyWrapper<short>(CSSPropertyWebkitBorderHorizontalSpacing, &RenderStyle::horizontalBorderSpacing, &RenderStyle::setHorizontalBorderSpacing), - new PropertyWrapper<short>(CSSPropertyWebkitBorderVerticalSpacing, &RenderStyle::verticalBorderSpacing, &RenderStyle::setVerticalBorderSpacing), + new FillLayersPropertyWrapper(CSSPropertyBackgroundPositionX, &RenderStyle::backgroundLayers, &RenderStyle::ensureBackgroundLayers), + new FillLayersPropertyWrapper(CSSPropertyBackgroundPositionY, &RenderStyle::backgroundLayers, &RenderStyle::ensureBackgroundLayers), + new FillLayersPropertyWrapper(CSSPropertyBackgroundSize, &RenderStyle::backgroundLayers, &RenderStyle::ensureBackgroundLayers), + new FillLayersPropertyWrapper(CSSPropertyWebkitBackgroundSize, &RenderStyle::backgroundLayers, &RenderStyle::ensureBackgroundLayers), + + new FillLayersPropertyWrapper(CSSPropertyWebkitMaskPositionX, &RenderStyle::maskLayers, &RenderStyle::ensureMaskLayers), + new FillLayersPropertyWrapper(CSSPropertyWebkitMaskPositionY, &RenderStyle::maskLayers, &RenderStyle::ensureMaskLayers), + new FillLayersPropertyWrapper(CSSPropertyWebkitMaskSize, &RenderStyle::maskLayers, &RenderStyle::ensureMaskLayers), + + new PropertyWrapper<float>(CSSPropertyFontSize, &RenderStyle::computedFontSize, &RenderStyle::setFontSize), + new PropertyWrapper<unsigned short>(CSSPropertyColumnRuleWidth, &RenderStyle::columnRuleWidth, &RenderStyle::setColumnRuleWidth), + new PropertyWrapper<float>(CSSPropertyColumnGap, &RenderStyle::columnGap, &RenderStyle::setColumnGap), + new PropertyWrapper<unsigned short>(CSSPropertyColumnCount, &RenderStyle::columnCount, &RenderStyle::setColumnCount), + new PropertyWrapper<float>(CSSPropertyColumnWidth, &RenderStyle::columnWidth, &RenderStyle::setColumnWidth), + new PropertyWrapper<float>(CSSPropertyWebkitBorderHorizontalSpacing, &RenderStyle::horizontalBorderSpacing, &RenderStyle::setHorizontalBorderSpacing), + new PropertyWrapper<float>(CSSPropertyWebkitBorderVerticalSpacing, &RenderStyle::verticalBorderSpacing, &RenderStyle::setVerticalBorderSpacing), new PropertyWrapper<int>(CSSPropertyZIndex, &RenderStyle::zIndex, &RenderStyle::setZIndex), new PropertyWrapper<short>(CSSPropertyOrphans, &RenderStyle::orphans, &RenderStyle::setOrphans), new PropertyWrapper<short>(CSSPropertyWidows, &RenderStyle::widows, &RenderStyle::setWidows), new LengthPropertyWrapper<Length>(CSSPropertyLineHeight, &RenderStyle::specifiedLineHeight, &RenderStyle::setLineHeight), - new PropertyWrapper<int>(CSSPropertyOutlineOffset, &RenderStyle::outlineOffset, &RenderStyle::setOutlineOffset), - new PropertyWrapper<unsigned short>(CSSPropertyOutlineWidth, &RenderStyle::outlineWidth, &RenderStyle::setOutlineWidth), + new PropertyWrapper<float>(CSSPropertyOutlineOffset, &RenderStyle::outlineOffset, &RenderStyle::setOutlineOffset), + new PropertyWrapper<float>(CSSPropertyOutlineWidth, &RenderStyle::outlineWidth, &RenderStyle::setOutlineWidth), new PropertyWrapper<float>(CSSPropertyLetterSpacing, &RenderStyle::letterSpacing, &RenderStyle::setLetterSpacing), new LengthPropertyWrapper<Length>(CSSPropertyWordSpacing, &RenderStyle::wordSpacing, &RenderStyle::setWordSpacing), new LengthPropertyWrapper<Length>(CSSPropertyTextIndent, &RenderStyle::textIndent, &RenderStyle::setTextIndent), - new PropertyWrapper<float>(CSSPropertyWebkitPerspective, &RenderStyle::perspective, &RenderStyle::setPerspective), - new LengthPropertyWrapper<Length>(CSSPropertyWebkitPerspectiveOriginX, &RenderStyle::perspectiveOriginX, &RenderStyle::setPerspectiveOriginX), - new LengthPropertyWrapper<Length>(CSSPropertyWebkitPerspectiveOriginY, &RenderStyle::perspectiveOriginY, &RenderStyle::setPerspectiveOriginY), - new LengthPropertyWrapper<Length>(CSSPropertyWebkitTransformOriginX, &RenderStyle::transformOriginX, &RenderStyle::setTransformOriginX), - new LengthPropertyWrapper<Length>(CSSPropertyWebkitTransformOriginY, &RenderStyle::transformOriginY, &RenderStyle::setTransformOriginY), - new PropertyWrapper<float>(CSSPropertyWebkitTransformOriginZ, &RenderStyle::transformOriginZ, &RenderStyle::setTransformOriginZ), + new PropertyWrapper<float>(CSSPropertyPerspective, &RenderStyle::perspective, &RenderStyle::setPerspective), + new LengthPropertyWrapper<Length>(CSSPropertyPerspectiveOriginX, &RenderStyle::perspectiveOriginX, &RenderStyle::setPerspectiveOriginX), + new LengthPropertyWrapper<Length>(CSSPropertyPerspectiveOriginY, &RenderStyle::perspectiveOriginY, &RenderStyle::setPerspectiveOriginY), + new LengthPropertyWrapper<Length>(CSSPropertyTransformOriginX, &RenderStyle::transformOriginX, &RenderStyle::setTransformOriginX), + new LengthPropertyWrapper<Length>(CSSPropertyTransformOriginY, &RenderStyle::transformOriginY, &RenderStyle::setTransformOriginY), + new PropertyWrapper<float>(CSSPropertyTransformOriginZ, &RenderStyle::transformOriginZ, &RenderStyle::setTransformOriginZ), new LengthPropertyWrapper<LengthSize>(CSSPropertyBorderTopLeftRadius, &RenderStyle::borderTopLeftRadius, &RenderStyle::setBorderTopLeftRadius), new LengthPropertyWrapper<LengthSize>(CSSPropertyBorderTopRightRadius, &RenderStyle::borderTopRightRadius, &RenderStyle::setBorderTopRightRadius), new LengthPropertyWrapper<LengthSize>(CSSPropertyBorderBottomLeftRadius, &RenderStyle::borderBottomLeftRadius, &RenderStyle::setBorderBottomLeftRadius), @@ -1232,30 +1423,19 @@ CSSPropertyAnimationWrapperMap::CSSPropertyAnimationWrapperMap() new LengthPropertyWrapper<LengthBox>(CSSPropertyClip, &RenderStyle::clip, &RenderStyle::setClip), -#if USE(ACCELERATED_COMPOSITING) new PropertyWrapperAcceleratedOpacity(), new PropertyWrapperAcceleratedTransform(), -#if ENABLE(CSS_FILTERS) new PropertyWrapperAcceleratedFilter(), +#if ENABLE(FILTERS_LEVEL_2) + new PropertyWrapperAcceleratedBackdropFilter(), #endif -#else - new PropertyWrapper<float>(CSSPropertyOpacity, &RenderStyle::opacity, &RenderStyle::setOpacity), - new PropertyWrapper<const TransformOperations&>(CSSPropertyWebkitTransform, &RenderStyle::transform, &RenderStyle::setTransform), -#if ENABLE(CSS_FILTERS) - new PropertyWrapper<const FilterOperations&>(CSSPropertyWebkitFilter, &RenderStyle::filter, &RenderStyle::setFilter), -#endif -#endif - new PropertyWrapperClipPath(CSSPropertyWebkitClipPath, &RenderStyle::clipPath, &RenderStyle::setClipPath), -#if ENABLE(CSS_SHAPES) - new PropertyWrapperShape(CSSPropertyWebkitShapeInside, &RenderStyle::shapeInside, &RenderStyle::setShapeInside), - new PropertyWrapperShape(CSSPropertyWebkitShapeOutside, &RenderStyle::shapeOutside, &RenderStyle::setShapeOutside), - new LengthPropertyWrapper<Length>(CSSPropertyWebkitShapeMargin, &RenderStyle::shapeMargin, &RenderStyle::setShapeMargin), - new PropertyWrapper<float>(CSSPropertyWebkitShapeImageThreshold, &RenderStyle::shapeImageThreshold, &RenderStyle::setShapeImageThreshold), -#endif + new PropertyWrapperShape(CSSPropertyShapeOutside, &RenderStyle::shapeOutside, &RenderStyle::setShapeOutside), + new LengthPropertyWrapper<Length>(CSSPropertyShapeMargin, &RenderStyle::shapeMargin, &RenderStyle::setShapeMargin), + new PropertyWrapper<float>(CSSPropertyShapeImageThreshold, &RenderStyle::shapeImageThreshold, &RenderStyle::setShapeImageThreshold), - new PropertyWrapperVisitedAffectedColor(CSSPropertyWebkitColumnRuleColor, MaybeInvalidColor, &RenderStyle::columnRuleColor, &RenderStyle::setColumnRuleColor, &RenderStyle::visitedLinkColumnRuleColor, &RenderStyle::setVisitedLinkColumnRuleColor), + new PropertyWrapperVisitedAffectedColor(CSSPropertyColumnRuleColor, MaybeInvalidColor, &RenderStyle::columnRuleColor, &RenderStyle::setColumnRuleColor, &RenderStyle::visitedLinkColumnRuleColor, &RenderStyle::setVisitedLinkColumnRuleColor), new PropertyWrapperVisitedAffectedColor(CSSPropertyWebkitTextStrokeColor, MaybeInvalidColor, &RenderStyle::textStrokeColor, &RenderStyle::setTextStrokeColor, &RenderStyle::visitedLinkTextStrokeColor, &RenderStyle::setVisitedLinkTextStrokeColor), new PropertyWrapperVisitedAffectedColor(CSSPropertyWebkitTextFillColor, MaybeInvalidColor, &RenderStyle::textFillColor, &RenderStyle::setTextFillColor, &RenderStyle::visitedLinkTextFillColor, &RenderStyle::setVisitedLinkTextFillColor), new PropertyWrapperVisitedAffectedColor(CSSPropertyBorderLeftColor, MaybeInvalidColor, &RenderStyle::borderLeftColor, &RenderStyle::setBorderLeftColor, &RenderStyle::visitedLinkBorderLeftColor, &RenderStyle::setVisitedLinkBorderLeftColor), @@ -1268,17 +1448,24 @@ CSSPropertyAnimationWrapperMap::CSSPropertyAnimationWrapperMap() new PropertyWrapperShadow(CSSPropertyWebkitBoxShadow, &RenderStyle::boxShadow, &RenderStyle::setBoxShadow), new PropertyWrapperShadow(CSSPropertyTextShadow, &RenderStyle::textShadow, &RenderStyle::setTextShadow), -#if ENABLE(SVG) new PropertyWrapperSVGPaint(CSSPropertyFill, &RenderStyle::fillPaintType, &RenderStyle::fillPaintColor, &RenderStyle::setFillPaintColor), new PropertyWrapper<float>(CSSPropertyFillOpacity, &RenderStyle::fillOpacity, &RenderStyle::setFillOpacity), new PropertyWrapperSVGPaint(CSSPropertyStroke, &RenderStyle::strokePaintType, &RenderStyle::strokePaintColor, &RenderStyle::setStrokePaintColor), new PropertyWrapper<float>(CSSPropertyStrokeOpacity, &RenderStyle::strokeOpacity, &RenderStyle::setStrokeOpacity), - new PropertyWrapper<SVGLength>(CSSPropertyStrokeWidth, &RenderStyle::strokeWidth, &RenderStyle::setStrokeWidth), - new PropertyWrapper< Vector<SVGLength>>(CSSPropertyStrokeDasharray, &RenderStyle::strokeDashArray, &RenderStyle::setStrokeDashArray), - new PropertyWrapper<SVGLength>(CSSPropertyStrokeDashoffset, &RenderStyle::strokeDashOffset, &RenderStyle::setStrokeDashOffset), + new PropertyWrapper<Vector<SVGLengthValue>>(CSSPropertyStrokeDasharray, &RenderStyle::strokeDashArray, &RenderStyle::setStrokeDashArray), new PropertyWrapper<float>(CSSPropertyStrokeMiterlimit, &RenderStyle::strokeMiterLimit, &RenderStyle::setStrokeMiterLimit), + new LengthPropertyWrapper<Length>(CSSPropertyCx, &RenderStyle::cx, &RenderStyle::setCx), + new LengthPropertyWrapper<Length>(CSSPropertyCy, &RenderStyle::cy, &RenderStyle::setCy), + new LengthPropertyWrapper<Length>(CSSPropertyR, &RenderStyle::r, &RenderStyle::setR), + new LengthPropertyWrapper<Length>(CSSPropertyRx, &RenderStyle::rx, &RenderStyle::setRx), + new LengthPropertyWrapper<Length>(CSSPropertyRy, &RenderStyle::ry, &RenderStyle::setRy), + new LengthPropertyWrapper<Length>(CSSPropertyStrokeDashoffset, &RenderStyle::strokeDashOffset, &RenderStyle::setStrokeDashOffset), + new LengthPropertyWrapper<Length>(CSSPropertyStrokeWidth, &RenderStyle::strokeWidth, &RenderStyle::setStrokeWidth), + new LengthPropertyWrapper<Length>(CSSPropertyX, &RenderStyle::x, &RenderStyle::setX), + new LengthPropertyWrapper<Length>(CSSPropertyY, &RenderStyle::y, &RenderStyle::setY), + new PropertyWrapper<float>(CSSPropertyFloodOpacity, &RenderStyle::floodOpacity, &RenderStyle::setFloodOpacity), new PropertyWrapperMaybeInvalidColor(CSSPropertyFloodColor, &RenderStyle::floodColor, &RenderStyle::setFloodColor), @@ -1287,8 +1474,10 @@ CSSPropertyAnimationWrapperMap::CSSPropertyAnimationWrapperMap() new PropertyWrapperMaybeInvalidColor(CSSPropertyLightingColor, &RenderStyle::lightingColor, &RenderStyle::setLightingColor), - new PropertyWrapper<SVGLength>(CSSPropertyBaselineShift, &RenderStyle::baselineShiftValue, &RenderStyle::setBaselineShiftValue), - new PropertyWrapper<SVGLength>(CSSPropertyKerning, &RenderStyle::kerning, &RenderStyle::setKerning), + new PropertyWrapper<SVGLengthValue>(CSSPropertyBaselineShift, &RenderStyle::baselineShiftValue, &RenderStyle::setBaselineShiftValue), + new PropertyWrapper<SVGLengthValue>(CSSPropertyKerning, &RenderStyle::kerning, &RenderStyle::setKerning), +#if ENABLE(VARIATION_FONTS) + new PropertyWrapperFontVariationSettings(CSSPropertyFontVariationSettings, &RenderStyle::fontVariationSettings, &RenderStyle::setFontVariationSettings), #endif }; const unsigned animatableLonghandPropertiesCount = WTF_ARRAY_LENGTH(animatableLonghandPropertyWrappers); @@ -1311,9 +1500,9 @@ CSSPropertyAnimationWrapperMap::CSSPropertyAnimationWrapperMap() CSSPropertyOutline, CSSPropertyPadding, CSSPropertyWebkitTextStroke, - CSSPropertyWebkitColumnRule, + CSSPropertyColumnRule, CSSPropertyWebkitBorderRadius, - CSSPropertyWebkitTransformOrigin + CSSPropertyTransformOrigin }; const unsigned animatableShorthandPropertiesCount = WTF_ARRAY_LENGTH(animatableShorthandProperties); @@ -1323,7 +1512,7 @@ CSSPropertyAnimationWrapperMap::CSSPropertyAnimationWrapperMap() // // Compound properties that have components that should be animatable: // - // CSSPropertyWebkitColumns + // CSSPropertyColumns // CSSPropertyWebkitBoxReflect // Make sure unused slots have a value @@ -1338,7 +1527,7 @@ CSSPropertyAnimationWrapperMap::CSSPropertyAnimationWrapperMap() for (unsigned i = 0; i < animatableLonghandPropertiesCount; ++i) { AnimationPropertyWrapperBase* wrapper = animatableLonghandPropertyWrappers[i]; - m_propertyWrappers.uncheckedAppend(adoptPtr(wrapper)); + m_propertyWrappers.uncheckedAppend(std::unique_ptr<AnimationPropertyWrapperBase>(wrapper)); indexFromPropertyID(wrapper->property()) = i; } @@ -1359,7 +1548,7 @@ CSSPropertyAnimationWrapperMap::CSSPropertyAnimationWrapperMap() longhandWrappers.uncheckedAppend(m_propertyWrappers[wrapperIndex].get()); } - m_propertyWrappers.uncheckedAppend(adoptPtr(new ShorthandPropertyWrapper(propertyID, longhandWrappers))); + m_propertyWrappers.uncheckedAppend(std::make_unique<ShorthandPropertyWrapper>(propertyID, WTFMove(longhandWrappers))); indexFromPropertyID(propertyID) = animatableLonghandPropertiesCount + i; } } @@ -1370,11 +1559,8 @@ static bool gatherEnclosingShorthandProperties(CSSPropertyID property, Animation return false; ShorthandPropertyWrapper* shorthandWrapper = static_cast<ShorthandPropertyWrapper*>(wrapper); - bool contained = false; - for (size_t i = 0; i < shorthandWrapper->propertyWrappers().size(); ++i) { - AnimationPropertyWrapperBase* currWrapper = shorthandWrapper->propertyWrappers()[i]; - + for (auto& currWrapper : shorthandWrapper->propertyWrappers()) { if (gatherEnclosingShorthandProperties(property, currWrapper, propertySet) || currWrapper->property() == property) contained = true; } @@ -1390,31 +1576,27 @@ bool CSSPropertyAnimation::blendProperties(const AnimationBase* anim, CSSPropert { ASSERT(prop != CSSPropertyInvalid); - AnimationPropertyWrapperBase* wrapper = CSSPropertyAnimationWrapperMap::instance().wrapperForProperty(prop); + AnimationPropertyWrapperBase* wrapper = CSSPropertyAnimationWrapperMap::singleton().wrapperForProperty(prop); if (wrapper) { wrapper->blend(anim, dst, a, b, progress); -#if USE(ACCELERATED_COMPOSITING) - return !wrapper->animationIsAccelerated() || !anim->isAccelerated(); -#else - return true; +#if !LOG_DISABLED + wrapper->logBlend(a, b, dst, progress); #endif + return !wrapper->animationIsAccelerated() || !anim->isAccelerated(); } - return false; } -#if USE(ACCELERATED_COMPOSITING) bool CSSPropertyAnimation::animationOfPropertyIsAccelerated(CSSPropertyID prop) { - AnimationPropertyWrapperBase* wrapper = CSSPropertyAnimationWrapperMap::instance().wrapperForProperty(prop); + AnimationPropertyWrapperBase* wrapper = CSSPropertyAnimationWrapperMap::singleton().wrapperForProperty(prop); return wrapper ? wrapper->animationIsAccelerated() : false; } -#endif // Note: this is inefficient. It's only called from pauseTransitionAtTime(). HashSet<CSSPropertyID> CSSPropertyAnimation::animatableShorthandsAffectingProperty(CSSPropertyID property) { - CSSPropertyAnimationWrapperMap& map = CSSPropertyAnimationWrapperMap::instance(); + CSSPropertyAnimationWrapperMap& map = CSSPropertyAnimationWrapperMap::singleton(); HashSet<CSSPropertyID> foundProperties; for (unsigned i = 0; i < map.size(); ++i) @@ -1425,7 +1607,7 @@ HashSet<CSSPropertyID> CSSPropertyAnimation::animatableShorthandsAffectingProper bool CSSPropertyAnimation::propertiesEqual(CSSPropertyID prop, const RenderStyle* a, const RenderStyle* b) { - AnimationPropertyWrapperBase* wrapper = CSSPropertyAnimationWrapperMap::instance().wrapperForProperty(prop); + AnimationPropertyWrapperBase* wrapper = CSSPropertyAnimationWrapperMap::singleton().wrapperForProperty(prop); if (wrapper) return wrapper->equals(a, b); return true; @@ -1433,7 +1615,7 @@ bool CSSPropertyAnimation::propertiesEqual(CSSPropertyID prop, const RenderStyle CSSPropertyID CSSPropertyAnimation::getPropertyAtIndex(int i, bool& isShorthand) { - CSSPropertyAnimationWrapperMap& map = CSSPropertyAnimationWrapperMap::instance(); + CSSPropertyAnimationWrapperMap& map = CSSPropertyAnimationWrapperMap::singleton(); if (i < 0 || static_cast<unsigned>(i) >= map.size()) return CSSPropertyInvalid; @@ -1445,7 +1627,7 @@ CSSPropertyID CSSPropertyAnimation::getPropertyAtIndex(int i, bool& isShorthand) int CSSPropertyAnimation::getNumProperties() { - return CSSPropertyAnimationWrapperMap::instance().size(); + return CSSPropertyAnimationWrapperMap::singleton().size(); } } diff --git a/Source/WebCore/page/animation/CSSPropertyAnimation.h b/Source/WebCore/page/animation/CSSPropertyAnimation.h index c41c7dd90..98ec9a154 100644 --- a/Source/WebCore/page/animation/CSSPropertyAnimation.h +++ b/Source/WebCore/page/animation/CSSPropertyAnimation.h @@ -10,7 +10,7 @@ * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. - * 3. Neither the name of Apple Computer, Inc. ("Apple") nor the names of + * 3. Neither the name of Apple Inc. ("Apple") nor the names of * its contributors may be used to endorse or promote products derived * from this software without specific prior written permission. * @@ -26,8 +26,7 @@ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ -#ifndef CSSPropertyAnimation_h -#define CSSPropertyAnimation_h +#pragma once #include "CSSPropertyNames.h" #include "RenderStyleConstants.h" @@ -40,9 +39,7 @@ class RenderStyle; class CSSPropertyAnimation { public: -#if USE(ACCELERATED_COMPOSITING) static bool animationOfPropertyIsAccelerated(CSSPropertyID); -#endif static bool propertiesEqual(CSSPropertyID, const RenderStyle* a, const RenderStyle* b); static CSSPropertyID getPropertyAtIndex(int, bool& isShorthand); static int getNumProperties(); @@ -54,5 +51,3 @@ public: }; } // namespace WebCore - -#endif // CSSPropertyAnimation_h diff --git a/Source/WebCore/page/animation/CompositeAnimation.cpp b/Source/WebCore/page/animation/CompositeAnimation.cpp index e18779ea7..f89f1e514 100644 --- a/Source/WebCore/page/animation/CompositeAnimation.cpp +++ b/Source/WebCore/page/animation/CompositeAnimation.cpp @@ -10,7 +10,7 @@ * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. - * 3. Neither the name of Apple Computer, Inc. ("Apple") nor the names of + * 3. Neither the name of Apple Inc. ("Apple") nor the names of * its contributors may be used to endorse or promote products derived * from this software without specific prior written permission. * @@ -29,7 +29,7 @@ #include "config.h" #include "CompositeAnimation.h" -#include "AnimationControllerPrivate.h" +#include "CSSAnimationControllerPrivate.h" #include "CSSPropertyAnimation.h" #include "CSSPropertyNames.h" #include "ImplicitAnimation.h" @@ -37,14 +37,15 @@ #include "Logging.h" #include "RenderElement.h" #include "RenderStyle.h" +#include <wtf/NeverDestroyed.h> #include <wtf/text/CString.h> namespace WebCore { -CompositeAnimation::CompositeAnimation(AnimationControllerPrivate* animationController) +CompositeAnimation::CompositeAnimation(CSSAnimationControllerPrivate& animationController) : m_animationController(animationController) { - m_suspended = animationController->isSuspended() && !animationController->allowsNewAnimationsWhileSuspended(); + m_suspended = m_animationController.isSuspended() && !m_animationController.allowsNewAnimationsWhileSuspended(); } CompositeAnimation::~CompositeAnimation() @@ -62,25 +63,21 @@ void CompositeAnimation::clearRenderer() if (!m_transitions.isEmpty()) { // Clear the renderers from all running animations, in case we are in the middle of // an animation callback (see https://bugs.webkit.org/show_bug.cgi?id=22052) - CSSPropertyTransitionsMap::const_iterator transitionsEnd = m_transitions.end(); - for (CSSPropertyTransitionsMap::const_iterator it = m_transitions.begin(); it != transitionsEnd; ++it) { - ImplicitAnimation* transition = it->value.get(); - animationController()->animationWillBeRemoved(transition); + for (auto& transition : m_transitions.values()) { + animationController().animationWillBeRemoved(transition.get()); transition->clear(); } } if (!m_keyframeAnimations.isEmpty()) { m_keyframeAnimations.checkConsistency(); - AnimationNameMap::const_iterator animationsEnd = m_keyframeAnimations.end(); - for (AnimationNameMap::const_iterator it = m_keyframeAnimations.begin(); it != animationsEnd; ++it) { - KeyframeAnimation* anim = it->value.get(); - animationController()->animationWillBeRemoved(anim); - anim->clear(); + for (auto& animation : m_keyframeAnimations.values()) { + animationController().animationWillBeRemoved(animation.get()); + animation->clear(); } } } -void CompositeAnimation::updateTransitions(RenderElement* renderer, RenderStyle* currentStyle, RenderStyle* targetStyle) +void CompositeAnimation::updateTransitions(RenderElement* renderer, const RenderStyle* currentStyle, const RenderStyle* targetStyle) { // If currentStyle is null or there are no old or new transitions, just skip it if (!currentStyle || (!targetStyle->transitions() && m_transitions.isEmpty())) @@ -88,20 +85,19 @@ void CompositeAnimation::updateTransitions(RenderElement* renderer, RenderStyle* // Mark all existing transitions as no longer active. We will mark the still active ones // in the next loop and then toss the ones that didn't get marked. - CSSPropertyTransitionsMap::const_iterator end = m_transitions.end(); - for (CSSPropertyTransitionsMap::const_iterator it = m_transitions.begin(); it != end; ++it) - it->value->setActive(false); + for (auto& transition : m_transitions.values()) + transition->setActive(false); - RefPtr<RenderStyle> modifiedCurrentStyle; + std::unique_ptr<RenderStyle> modifiedCurrentStyle; // Check to see if we need to update the active transitions if (targetStyle->transitions()) { for (size_t i = 0; i < targetStyle->transitions()->size(); ++i) { - const Animation& animation = targetStyle->transitions()->animation(i); + auto& animation = targetStyle->transitions()->animation(i); bool isActiveTransition = !m_suspended && (animation.duration() || animation.delay() > 0); Animation::AnimationMode mode = animation.animationMode(); - if (mode == Animation::AnimateNone) + if (mode == Animation::AnimateNone || mode == Animation::AnimateUnknownProperty) continue; CSSPropertyID prop = animation.property(); @@ -125,8 +121,8 @@ void CompositeAnimation::updateTransitions(RenderElement* renderer, RenderStyle* // If there is a running animation for this property, the transition is overridden // and we have to use the unanimatedStyle from the animation. We do the test // against the unanimated style here, but we "override" the transition later. - RefPtr<KeyframeAnimation> keyframeAnim = getAnimationForProperty(prop); - RenderStyle* fromStyle = keyframeAnim ? keyframeAnim->unanimatedStyle() : currentStyle; + auto* keyframeAnimation = animationForProperty(prop); + auto* fromStyle = keyframeAnimation ? keyframeAnimation->unanimatedStyle() : currentStyle; // See if there is a current transition for this prop ImplicitAnimation* implAnim = m_transitions.get(prop); @@ -148,18 +144,16 @@ void CompositeAnimation::updateTransitions(RenderElement* renderer, RenderStyle* // list. In this case, the latter one overrides the earlier one, so we // behave as though this is a running animation being replaced. if (!implAnim->isTargetPropertyEqual(prop, targetStyle)) { -#if USE(ACCELERATED_COMPOSITING) // For accelerated animations we need to return a new RenderStyle with the _current_ value // of the property, so that restarted transitions use the correct starting point. if (CSSPropertyAnimation::animationOfPropertyIsAccelerated(prop) && implAnim->isAccelerated()) { if (!modifiedCurrentStyle) - modifiedCurrentStyle = RenderStyle::clone(currentStyle); + modifiedCurrentStyle = RenderStyle::clonePtr(*currentStyle); implAnim->blendPropertyValueInStyle(prop, modifiedCurrentStyle.get()); } -#endif LOG(Animations, "Removing existing ImplicitAnimation %p for property %s", implAnim, getPropertyName(prop)); - animationController()->animationWillBeRemoved(implAnim); + animationController().animationWillBeRemoved(implAnim); m_transitions.remove(prop); equal = false; } @@ -174,11 +168,11 @@ void CompositeAnimation::updateTransitions(RenderElement* renderer, RenderStyle* // <https://bugs.webkit.org/show_bug.cgi?id=24787> if (!equal && isActiveTransition) { // Add the new transition - RefPtr<ImplicitAnimation> implicitAnimation = ImplicitAnimation::create(animation, prop, renderer, this, modifiedCurrentStyle ? modifiedCurrentStyle.get() : fromStyle); - LOG(Animations, "Created ImplicitAnimation %p for property %s duration %.2f delay %.2f", implicitAnimation.get(), getPropertyName(prop), animation.duration(), animation.delay()); - m_transitions.set(prop, implicitAnimation.release()); + auto implicitAnimation = ImplicitAnimation::create(animation, prop, renderer, this, modifiedCurrentStyle ? modifiedCurrentStyle.get() : fromStyle); + LOG(Animations, "Created ImplicitAnimation %p on renderer %p for property %s duration %.2f delay %.2f", implicitAnimation.ptr(), renderer, getPropertyName(prop), animation.duration(), animation.delay()); + m_transitions.set(prop, WTFMove(implicitAnimation)); } - + // We only need one pass for the single prop case if (!all) break; @@ -188,158 +182,184 @@ void CompositeAnimation::updateTransitions(RenderElement* renderer, RenderStyle* // Make a list of transitions to be removed Vector<int> toBeRemoved; - end = m_transitions.end(); - for (CSSPropertyTransitionsMap::const_iterator it = m_transitions.begin(); it != end; ++it) { - ImplicitAnimation* anim = it->value.get(); - if (!anim->active()) { - animationController()->animationWillBeRemoved(anim); - toBeRemoved.append(anim->animatingProperty()); - LOG(Animations, "Removing ImplicitAnimation %p for property %s", anim, getPropertyName(anim->animatingProperty())); + for (auto& transition : m_transitions.values()) { + if (!transition->active()) { + animationController().animationWillBeRemoved(transition.get()); + toBeRemoved.append(transition->animatingProperty()); + LOG(Animations, "Removing ImplicitAnimation %p from renderer %p for property %s", transition.get(), renderer, getPropertyName(transition->animatingProperty())); } } // Now remove the transitions from the list - for (size_t j = 0; j < toBeRemoved.size(); ++j) - m_transitions.remove(toBeRemoved[j]); + for (auto propertyToRemove : toBeRemoved) + m_transitions.remove(propertyToRemove); } -void CompositeAnimation::updateKeyframeAnimations(RenderElement* renderer, RenderStyle* currentStyle, RenderStyle* targetStyle) +void CompositeAnimation::updateKeyframeAnimations(RenderElement* renderer, const RenderStyle* currentStyle, const RenderStyle* targetStyle) { // Nothing to do if we don't have any animations, and didn't have any before if (m_keyframeAnimations.isEmpty() && !targetStyle->hasAnimations()) return; m_keyframeAnimations.checkConsistency(); + + if (currentStyle && currentStyle->hasAnimations() && targetStyle->hasAnimations() && *(currentStyle->animations()) == *(targetStyle->animations())) + return; + +#if ENABLE(CSS_ANIMATIONS_LEVEL_2) + m_hasScrollTriggeredAnimation = false; +#endif + + AnimationNameMap newAnimations; + + // Toss the animation order map. + m_keyframeAnimationOrderMap.clear(); - AnimationNameMap::const_iterator kfend = m_keyframeAnimations.end(); + static NeverDestroyed<const AtomicString> none("none", AtomicString::ConstructFromLiteral); - if (currentStyle && currentStyle->hasAnimations() && targetStyle->hasAnimations() && *(currentStyle->animations()) == *(targetStyle->animations())) { - // The current and target animations are the same so we just need to toss any - // animation which is finished (postActive). - for (AnimationNameMap::const_iterator it = m_keyframeAnimations.begin(); it != kfend; ++it) { - if (it->value->postActive()) - it->value->setIndex(-1); - } - } else { - // Mark all existing animations as no longer active. - for (AnimationNameMap::const_iterator it = m_keyframeAnimations.begin(); it != kfend; ++it) - it->value->setIndex(-1); + // Now mark any still active animations as active and add any new animations. + if (targetStyle->animations()) { + int numAnims = targetStyle->animations()->size(); + for (int i = 0; i < numAnims; ++i) { + auto& animation = targetStyle->animations()->animation(i); + AtomicString animationName(animation.name()); + + if (!animation.isValidAnimation()) + continue; - // Toss the animation order map. - m_keyframeAnimationOrderMap.clear(); + // See if there is a current animation for this name. + RefPtr<KeyframeAnimation> keyframeAnim = m_keyframeAnimations.get(animationName.impl()); + if (keyframeAnim) { + newAnimations.add(keyframeAnim->name().impl(), keyframeAnim); - DEFINE_STATIC_LOCAL(const AtomicString, none, ("none", AtomicString::ConstructFromLiteral)); - - // Now mark any still active animations as active and add any new animations. - if (targetStyle->animations()) { - int numAnims = targetStyle->animations()->size(); - for (int i = 0; i < numAnims; ++i) { - const Animation& animation = targetStyle->animations()->animation(i); - AtomicString animationName(animation.name()); - - if (!animation.isValidAnimation()) + if (keyframeAnim->postActive()) continue; - - // See if there is a current animation for this name. - RefPtr<KeyframeAnimation> keyframeAnim = m_keyframeAnimations.get(animationName.impl()); - - if (keyframeAnim) { - // If this animation is postActive, skip it so it gets removed at the end of this function. - if (keyframeAnim->postActive()) - continue; - - // This one is still active. - - // Animations match, but play states may differ. Update if needed. - keyframeAnim->updatePlayState(animation.playState()); - - // Set the saved animation to this new one, just in case the play state has changed. - keyframeAnim->setAnimation(animation); - keyframeAnim->setIndex(i); - } else if ((animation.duration() || animation.delay()) && animation.iterationCount() && animationName != none) { - keyframeAnim = KeyframeAnimation::create(animation, renderer, i, this, targetStyle); - LOG(Animations, "Creating KeyframeAnimation %p with keyframes %s, duration %.2f, delay %.2f, iterations %.2f", keyframeAnim.get(), animation.name().utf8().data(), animation.duration(), animation.delay(), animation.iterationCount()); - if (m_suspended) { - keyframeAnim->updatePlayState(AnimPlayStatePaused); - LOG(Animations, " (created in suspended/paused state)"); - } -#if !LOG_DISABLED - for (auto it = keyframeAnim->keyframes().beginProperties(), end = keyframeAnim->keyframes().endProperties(); it != end; ++it) - LOG(Animations, " property %s", getPropertyName(*it)); + +#if ENABLE(CSS_ANIMATIONS_LEVEL_2) + if (animation.trigger()->isScrollAnimationTrigger()) + m_hasScrollTriggeredAnimation = true; #endif - m_keyframeAnimations.set(keyframeAnim->name().impl(), keyframeAnim); + + // Animations match, but play states may differ. Update if needed. + keyframeAnim->updatePlayState(animation.playState()); + + // Set the saved animation to this new one, just in case the play state has changed. + keyframeAnim->setAnimation(animation); + } else if ((animation.duration() || animation.delay()) && animation.iterationCount() && animationName != none) { + keyframeAnim = KeyframeAnimation::create(animation, renderer, this, targetStyle); + LOG(Animations, "Creating KeyframeAnimation %p on renderer %p with keyframes %s, duration %.2f, delay %.2f, iterations %.2f", keyframeAnim.get(), renderer, animation.name().utf8().data(), animation.duration(), animation.delay(), animation.iterationCount()); + + if (m_suspended) { + keyframeAnim->updatePlayState(AnimPlayStatePaused); + LOG(Animations, " (created in suspended/paused state)"); } - - // Add this to the animation order map. - if (keyframeAnim) - m_keyframeAnimationOrderMap.append(keyframeAnim->name().impl()); +#if !LOG_DISABLED + for (auto propertyID : keyframeAnim->keyframes().properties()) + LOG(Animations, " property %s", getPropertyName(propertyID)); +#endif + +#if ENABLE(CSS_ANIMATIONS_LEVEL_2) + if (animation.trigger()->isScrollAnimationTrigger()) + m_hasScrollTriggeredAnimation = true; +#endif + + newAnimations.set(keyframeAnim->name().impl(), keyframeAnim); } + + // Add this to the animation order map. + if (keyframeAnim) + m_keyframeAnimationOrderMap.append(keyframeAnim->name().impl()); } } // Make a list of animations to be removed. - Vector<AtomicStringImpl*> animsToBeRemoved; - kfend = m_keyframeAnimations.end(); - for (AnimationNameMap::const_iterator it = m_keyframeAnimations.begin(); it != kfend; ++it) { - KeyframeAnimation* keyframeAnim = it->value.get(); - if (keyframeAnim->index() < 0) { - animsToBeRemoved.append(keyframeAnim->name().impl()); - animationController()->animationWillBeRemoved(keyframeAnim); - keyframeAnim->clear(); - LOG(Animations, "Removing KeyframeAnimation %p", keyframeAnim); + for (auto& animation : m_keyframeAnimations.values()) { + if (!newAnimations.contains(animation->name().impl())) { + animationController().animationWillBeRemoved(animation.get()); + animation->clear(); + LOG(Animations, "Removing KeyframeAnimation %p from renderer %p", animation.get(), renderer); } } - // Now remove the animations from the list. - for (size_t j = 0; j < animsToBeRemoved.size(); ++j) - m_keyframeAnimations.remove(animsToBeRemoved[j]); + std::swap(newAnimations, m_keyframeAnimations); } -PassRef<RenderStyle> CompositeAnimation::animate(RenderElement& renderer, RenderStyle* currentStyle, RenderStyle& targetStyle) +bool CompositeAnimation::animate(RenderElement& renderer, const RenderStyle* currentStyle, const RenderStyle& targetStyle, std::unique_ptr<RenderStyle>& blendedStyle) { - RefPtr<RenderStyle> resultStyle; - // We don't do any transitions if we don't have a currentStyle (on startup). updateTransitions(&renderer, currentStyle, &targetStyle); updateKeyframeAnimations(&renderer, currentStyle, &targetStyle); m_keyframeAnimations.checkConsistency(); + bool animationStateChanged = false; + bool forceStackingContext = false; + if (currentStyle) { // Now that we have transition objects ready, let them know about the new goal state. We want them // to fill in a RenderStyle*& only if needed. - if (!m_transitions.isEmpty()) { - CSSPropertyTransitionsMap::const_iterator end = m_transitions.end(); - for (CSSPropertyTransitionsMap::const_iterator it = m_transitions.begin(); it != end; ++it) { - if (ImplicitAnimation* anim = it->value.get()) - anim->animate(this, &renderer, currentStyle, &targetStyle, resultStyle); - } + bool checkForStackingContext = false; + for (auto& transition : m_transitions.values()) { + bool didBlendStyle = false; + if (transition->animate(this, &renderer, currentStyle, &targetStyle, blendedStyle, didBlendStyle)) + animationStateChanged = true; + + if (didBlendStyle) + checkForStackingContext |= WillChangeData::propertyCreatesStackingContext(transition->animatingProperty()); + } + + if (blendedStyle && checkForStackingContext) { + // Note that this is similar to code in StyleResolver::adjustRenderStyle() but only needs to consult + // animatable properties that can trigger stacking context. + if (blendedStyle->opacity() < 1.0f + || blendedStyle->hasTransformRelatedProperty() + || blendedStyle->hasMask() + || blendedStyle->clipPath() + || blendedStyle->boxReflect() + || blendedStyle->hasFilter() +#if ENABLE(FILTERS_LEVEL_2) + || blendedStyle->hasBackdropFilter() +#endif + ) + forceStackingContext = true; } } // Now that we have animation objects ready, let them know about the new goal state. We want them // to fill in a RenderStyle*& only if needed. - for (Vector<AtomicStringImpl*>::const_iterator it = m_keyframeAnimationOrderMap.begin(); it != m_keyframeAnimationOrderMap.end(); ++it) { - RefPtr<KeyframeAnimation> keyframeAnim = m_keyframeAnimations.get(*it); - if (keyframeAnim) - keyframeAnim->animate(this, &renderer, currentStyle, &targetStyle, resultStyle); + for (auto& name : m_keyframeAnimationOrderMap) { + RefPtr<KeyframeAnimation> keyframeAnim = m_keyframeAnimations.get(name); + if (keyframeAnim) { + bool didBlendStyle = false; + if (keyframeAnim->animate(this, &renderer, currentStyle, &targetStyle, blendedStyle, didBlendStyle)) + animationStateChanged = true; + + forceStackingContext |= didBlendStyle && keyframeAnim->triggersStackingContext(); + m_hasAnimationThatDependsOnLayout |= keyframeAnim->dependsOnLayout(); + } } - return resultStyle ? resultStyle.releaseNonNull() : targetStyle; + // https://drafts.csswg.org/css-animations-1/ + // While an animation is applied but has not finished, or has finished but has an animation-fill-mode of forwards or both, + // the user agent must act as if the will-change property ([css-will-change-1]) on the element additionally + // includes all the properties animated by the animation. + if (forceStackingContext && blendedStyle) { + if (blendedStyle->hasAutoZIndex()) + blendedStyle->setZIndex(0); + } + + return animationStateChanged; } -PassRefPtr<RenderStyle> CompositeAnimation::getAnimatedStyle() const +std::unique_ptr<RenderStyle> CompositeAnimation::getAnimatedStyle() const { - RefPtr<RenderStyle> resultStyle; - CSSPropertyTransitionsMap::const_iterator end = m_transitions.end(); - for (CSSPropertyTransitionsMap::const_iterator it = m_transitions.begin(); it != end; ++it) { - if (ImplicitAnimation* implicitAnimation = it->value.get()) - implicitAnimation->getAnimatedStyle(resultStyle); - } + std::unique_ptr<RenderStyle> resultStyle; + for (auto& transition : m_transitions.values()) + transition->getAnimatedStyle(resultStyle); m_keyframeAnimations.checkConsistency(); - for (Vector<AtomicStringImpl*>::const_iterator it = m_keyframeAnimationOrderMap.begin(); it != m_keyframeAnimationOrderMap.end(); ++it) { - RefPtr<KeyframeAnimation> keyframeAnimation = m_keyframeAnimations.get(*it); + for (auto& name : m_keyframeAnimationOrderMap) { + RefPtr<KeyframeAnimation> keyframeAnimation = m_keyframeAnimations.get(name); if (keyframeAnimation) keyframeAnimation->getAnimatedStyle(resultStyle); } @@ -354,10 +374,10 @@ double CompositeAnimation::timeToNextService() const double minT = -1; if (!m_transitions.isEmpty()) { - CSSPropertyTransitionsMap::const_iterator transitionsEnd = m_transitions.end(); - for (CSSPropertyTransitionsMap::const_iterator it = m_transitions.begin(); it != transitionsEnd; ++it) { - ImplicitAnimation* transition = it->value.get(); - double t = transition ? transition->timeToNextService() : -1; + for (auto& transition : m_transitions.values()) { + double t = transition->timeToNextService(); + if (t == -1) + continue; if (t < minT || minT == -1) minT = t; if (minT == 0) @@ -366,10 +386,10 @@ double CompositeAnimation::timeToNextService() const } if (!m_keyframeAnimations.isEmpty()) { m_keyframeAnimations.checkConsistency(); - AnimationNameMap::const_iterator animationsEnd = m_keyframeAnimations.end(); - for (AnimationNameMap::const_iterator it = m_keyframeAnimations.begin(); it != animationsEnd; ++it) { - KeyframeAnimation* animation = it->value.get(); - double t = animation ? animation->timeToNextService() : -1; + for (auto& animation : m_keyframeAnimations.values()) { + double t = animation->timeToNextService(); + if (t == -1) + continue; if (t < minT || minT == -1) minT = t; if (minT == 0) @@ -380,23 +400,53 @@ double CompositeAnimation::timeToNextService() const return minT; } -PassRefPtr<KeyframeAnimation> CompositeAnimation::getAnimationForProperty(CSSPropertyID property) const +KeyframeAnimation* CompositeAnimation::animationForProperty(CSSPropertyID property) const { - RefPtr<KeyframeAnimation> retval; - + KeyframeAnimation* result = nullptr; + // We want to send back the last animation with the property if there are multiples. // So we need to iterate through all animations if (!m_keyframeAnimations.isEmpty()) { m_keyframeAnimations.checkConsistency(); - AnimationNameMap::const_iterator animationsEnd = m_keyframeAnimations.end(); - for (AnimationNameMap::const_iterator it = m_keyframeAnimations.begin(); it != animationsEnd; ++it) { - RefPtr<KeyframeAnimation> anim = it->value; - if (anim->hasAnimationForProperty(property)) - retval = anim; + for (auto& animation : m_keyframeAnimations.values()) { + if (animation->hasAnimationForProperty(property)) + result = animation.get(); } } + + return result; +} + +bool CompositeAnimation::computeExtentOfTransformAnimation(LayoutRect& bounds) const +{ + // If more than one transition and animation affect transform, give up. + bool seenTransformAnimation = false; + + for (auto& animation : m_keyframeAnimations.values()) { + if (!animation->hasAnimationForProperty(CSSPropertyTransform)) + continue; + + if (seenTransformAnimation) + return false; + + seenTransformAnimation = true; + + if (!animation->computeExtentOfTransformAnimation(bounds)) + return false; + } + + for (auto& transition : m_transitions.values()) { + if (transition->animatingProperty() != CSSPropertyTransform || !transition->hasStyle()) + continue; + + if (seenTransformAnimation) + return false; + + if (!transition->computeExtentOfTransformAnimation(bounds)) + return false; + } - return retval; + return true; } void CompositeAnimation::suspendAnimations() @@ -408,18 +458,14 @@ void CompositeAnimation::suspendAnimations() if (!m_keyframeAnimations.isEmpty()) { m_keyframeAnimations.checkConsistency(); - AnimationNameMap::const_iterator animationsEnd = m_keyframeAnimations.end(); - for (AnimationNameMap::const_iterator it = m_keyframeAnimations.begin(); it != animationsEnd; ++it) { - if (KeyframeAnimation* anim = it->value.get()) - anim->updatePlayState(AnimPlayStatePaused); - } + for (auto& animation : m_keyframeAnimations.values()) + animation->updatePlayState(AnimPlayStatePaused); } + if (!m_transitions.isEmpty()) { - CSSPropertyTransitionsMap::const_iterator transitionsEnd = m_transitions.end(); - for (CSSPropertyTransitionsMap::const_iterator it = m_transitions.begin(); it != transitionsEnd; ++it) { - ImplicitAnimation* anim = it->value.get(); - if (anim && anim->hasStyle()) - anim->updatePlayState(AnimPlayStatePaused); + for (auto& transition : m_transitions.values()) { + if (transition->hasStyle()) + transition->updatePlayState(AnimPlayStatePaused); } } } @@ -433,32 +479,26 @@ void CompositeAnimation::resumeAnimations() if (!m_keyframeAnimations.isEmpty()) { m_keyframeAnimations.checkConsistency(); - AnimationNameMap::const_iterator animationsEnd = m_keyframeAnimations.end(); - for (AnimationNameMap::const_iterator it = m_keyframeAnimations.begin(); it != animationsEnd; ++it) { - KeyframeAnimation* anim = it->value.get(); - if (anim && anim->playStatePlaying()) - anim->updatePlayState(AnimPlayStatePlaying); + for (auto& animation : m_keyframeAnimations.values()) { + if (animation->playStatePlaying()) + animation->updatePlayState(AnimPlayStatePlaying); } } if (!m_transitions.isEmpty()) { - CSSPropertyTransitionsMap::const_iterator transitionsEnd = m_transitions.end(); - for (CSSPropertyTransitionsMap::const_iterator it = m_transitions.begin(); it != transitionsEnd; ++it) { - ImplicitAnimation* anim = it->value.get(); - if (anim && anim->hasStyle()) - anim->updatePlayState(AnimPlayStatePlaying); + for (auto& transition : m_transitions.values()) { + if (transition->hasStyle()) + transition->updatePlayState(AnimPlayStatePlaying); } } } void CompositeAnimation::overrideImplicitAnimations(CSSPropertyID property) { - CSSPropertyTransitionsMap::const_iterator end = m_transitions.end(); if (!m_transitions.isEmpty()) { - for (CSSPropertyTransitionsMap::const_iterator it = m_transitions.begin(); it != end; ++it) { - ImplicitAnimation* anim = it->value.get(); - if (anim && anim->animatingProperty() == property) - anim->setOverridden(true); + for (auto& transition : m_transitions.values()) { + if (transition->animatingProperty() == property) + transition->setOverridden(true); } } } @@ -466,32 +506,26 @@ void CompositeAnimation::overrideImplicitAnimations(CSSPropertyID property) void CompositeAnimation::resumeOverriddenImplicitAnimations(CSSPropertyID property) { if (!m_transitions.isEmpty()) { - CSSPropertyTransitionsMap::const_iterator end = m_transitions.end(); - for (CSSPropertyTransitionsMap::const_iterator it = m_transitions.begin(); it != end; ++it) { - ImplicitAnimation* anim = it->value.get(); - if (anim && anim->animatingProperty() == property) - anim->setOverridden(false); + for (auto& transition : m_transitions.values()) { + if (transition->animatingProperty() == property) + transition->setOverridden(false); } } } -bool CompositeAnimation::isAnimatingProperty(CSSPropertyID property, bool acceleratedOnly, bool isRunningNow) const +bool CompositeAnimation::isAnimatingProperty(CSSPropertyID property, bool acceleratedOnly, AnimationBase::RunningState runningState) const { if (!m_keyframeAnimations.isEmpty()) { m_keyframeAnimations.checkConsistency(); - AnimationNameMap::const_iterator animationsEnd = m_keyframeAnimations.end(); - for (AnimationNameMap::const_iterator it = m_keyframeAnimations.begin(); it != animationsEnd; ++it) { - KeyframeAnimation* anim = it->value.get(); - if (anim && anim->isAnimatingProperty(property, acceleratedOnly, isRunningNow)) + for (auto& animation : m_keyframeAnimations.values()) { + if (animation->isAnimatingProperty(property, acceleratedOnly, runningState)) return true; } } if (!m_transitions.isEmpty()) { - CSSPropertyTransitionsMap::const_iterator transitionsEnd = m_transitions.end(); - for (CSSPropertyTransitionsMap::const_iterator it = m_transitions.begin(); it != transitionsEnd; ++it) { - ImplicitAnimation* anim = it->value.get(); - if (anim && anim->isAnimatingProperty(property, acceleratedOnly, isRunningNow)) + for (auto& transition : m_transitions.values()) { + if (transition->isAnimatingProperty(property, acceleratedOnly, runningState)) return true; } } @@ -506,13 +540,8 @@ bool CompositeAnimation::pauseAnimationAtTime(const AtomicString& name, double t if (!keyframeAnim || !keyframeAnim->running()) return false; - double count = keyframeAnim->m_animation->iterationCount(); - if ((t >= 0.0) && ((count == Animation::IterationCountInfinite) || (t <= count * keyframeAnim->duration()))) { - keyframeAnim->freezeAtTime(t); - return true; - } - - return false; + keyframeAnim->freezeAtTime(t); + return true; } bool CompositeAnimation::pauseTransitionAtTime(CSSPropertyID property, double t) @@ -526,9 +555,8 @@ bool CompositeAnimation::pauseTransitionAtTime(CSSPropertyID property, double t) // This code is only used for testing, so performance is not critical here. HashSet<CSSPropertyID> shorthandProperties = CSSPropertyAnimation::animatableShorthandsAffectingProperty(property); bool anyPaused = false; - HashSet<CSSPropertyID>::const_iterator end = shorthandProperties.end(); - for (HashSet<CSSPropertyID>::const_iterator it = shorthandProperties.begin(); it != end; ++it) { - if (pauseTransitionAtTime(*it, t)) + for (auto propertyID : shorthandProperties) { + if (pauseTransitionAtTime(propertyID, t)) anyPaused = true; } return anyPaused; @@ -549,23 +577,15 @@ unsigned CompositeAnimation::numberOfActiveAnimations() const { unsigned count = 0; - if (!m_keyframeAnimations.isEmpty()) { - m_keyframeAnimations.checkConsistency(); - AnimationNameMap::const_iterator animationsEnd = m_keyframeAnimations.end(); - for (AnimationNameMap::const_iterator it = m_keyframeAnimations.begin(); it != animationsEnd; ++it) { - KeyframeAnimation* anim = it->value.get(); - if (anim->running()) - ++count; - } + m_keyframeAnimations.checkConsistency(); + for (auto& animation : m_keyframeAnimations.values()) { + if (animation->running()) + ++count; } - if (!m_transitions.isEmpty()) { - CSSPropertyTransitionsMap::const_iterator transitionsEnd = m_transitions.end(); - for (CSSPropertyTransitionsMap::const_iterator it = m_transitions.begin(); it != transitionsEnd; ++it) { - ImplicitAnimation* anim = it->value.get(); - if (anim->running()) - ++count; - } + for (auto& transition : m_transitions.values()) { + if (transition->running()) + ++count; } return count; diff --git a/Source/WebCore/page/animation/CompositeAnimation.h b/Source/WebCore/page/animation/CompositeAnimation.h index 48c679ef2..715de586d 100644 --- a/Source/WebCore/page/animation/CompositeAnimation.h +++ b/Source/WebCore/page/animation/CompositeAnimation.h @@ -10,7 +10,7 @@ * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. - * 3. Neither the name of Apple Computer, Inc. ("Apple") nor the names of + * 3. Neither the name of Apple Inc. ("Apple") nor the names of * its contributors may be used to endorse or promote products derived * from this software without specific prior written permission. * @@ -26,8 +26,7 @@ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ -#ifndef CompositeAnimation_h -#define CompositeAnimation_h +#pragma once #include "ImplicitAnimation.h" #include "KeyframeAnimation.h" @@ -37,30 +36,32 @@ namespace WebCore { -class AnimationControllerPrivate; -class AnimationController; +class CSSAnimationControllerPrivate; +class CSSAnimationController; class RenderElement; class RenderStyle; // A CompositeAnimation represents a collection of animations that are running // on a single RenderElement, such as a number of properties transitioning at once. class CompositeAnimation : public RefCounted<CompositeAnimation> { + WTF_MAKE_FAST_ALLOCATED; public: - static PassRefPtr<CompositeAnimation> create(AnimationControllerPrivate* animationController) + static Ref<CompositeAnimation> create(CSSAnimationControllerPrivate& animationController) { - return adoptRef(new CompositeAnimation(animationController)); + return adoptRef(*new CompositeAnimation(animationController)); }; ~CompositeAnimation(); void clearRenderer(); - PassRef<RenderStyle> animate(RenderElement&, RenderStyle* currentStyle, RenderStyle& targetStyle); - PassRefPtr<RenderStyle> getAnimatedStyle() const; + bool animate(RenderElement&, const RenderStyle* currentStyle, const RenderStyle& targetStyle, std::unique_ptr<RenderStyle>& blendedStyle); + std::unique_ptr<RenderStyle> getAnimatedStyle() const; + bool computeExtentOfTransformAnimation(LayoutRect&) const; double timeToNextService() const; - AnimationControllerPrivate* animationController() const { return m_animationController; } + CSSAnimationControllerPrivate& animationController() const { return m_animationController; } void suspendAnimations(); void resumeAnimations(); @@ -68,9 +69,9 @@ public: bool hasAnimations() const { return !m_transitions.isEmpty() || !m_keyframeAnimations.isEmpty(); } - bool isAnimatingProperty(CSSPropertyID, bool acceleratedOnly, bool isRunningNow) const; + bool isAnimatingProperty(CSSPropertyID, bool acceleratedOnly, AnimationBase::RunningState) const; - PassRefPtr<KeyframeAnimation> getAnimationForProperty(CSSPropertyID) const; + KeyframeAnimation* animationForProperty(CSSPropertyID) const; void overrideImplicitAnimations(CSSPropertyID); void resumeOverriddenImplicitAnimations(CSSPropertyID); @@ -79,22 +80,30 @@ public: bool pauseTransitionAtTime(CSSPropertyID, double); unsigned numberOfActiveAnimations() const; +#if ENABLE(CSS_ANIMATIONS_LEVEL_2) + bool hasScrollTriggeredAnimation() const { return m_hasScrollTriggeredAnimation; } +#endif + + bool hasAnimationThatDependsOnLayout() const { return m_hasAnimationThatDependsOnLayout; } + private: - CompositeAnimation(AnimationControllerPrivate*); + CompositeAnimation(CSSAnimationControllerPrivate&); - void updateTransitions(RenderElement*, RenderStyle* currentStyle, RenderStyle* targetStyle); - void updateKeyframeAnimations(RenderElement*, RenderStyle* currentStyle, RenderStyle* targetStyle); + void updateTransitions(RenderElement*, const RenderStyle* currentStyle, const RenderStyle* targetStyle); + void updateKeyframeAnimations(RenderElement*, const RenderStyle* currentStyle, const RenderStyle* targetStyle); typedef HashMap<int, RefPtr<ImplicitAnimation>> CSSPropertyTransitionsMap; - typedef HashMap<AtomicStringImpl*, RefPtr<KeyframeAnimation>> AnimationNameMap; + typedef HashMap<AtomicStringImpl*, RefPtr<KeyframeAnimation>> AnimationNameMap; - AnimationControllerPrivate* m_animationController; + CSSAnimationControllerPrivate& m_animationController; CSSPropertyTransitionsMap m_transitions; AnimationNameMap m_keyframeAnimations; Vector<AtomicStringImpl*> m_keyframeAnimationOrderMap; bool m_suspended; + bool m_hasAnimationThatDependsOnLayout { false }; +#if ENABLE(CSS_ANIMATIONS_LEVEL_2) + bool m_hasScrollTriggeredAnimation { false }; +#endif }; } // namespace WebCore - -#endif // CompositeAnimation_h diff --git a/Source/WebCore/page/animation/ImplicitAnimation.cpp b/Source/WebCore/page/animation/ImplicitAnimation.cpp index af1d78819..924eb4b35 100644 --- a/Source/WebCore/page/animation/ImplicitAnimation.cpp +++ b/Source/WebCore/page/animation/ImplicitAnimation.cpp @@ -10,7 +10,7 @@ * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. - * 3. Neither the name of Apple Computer, Inc. ("Apple") nor the names of + * 3. Neither the name of Apple Inc. ("Apple") nor the names of * its contributors may be used to endorse or promote products derived * from this software without specific prior written permission. * @@ -27,24 +27,24 @@ */ #include "config.h" +#include "ImplicitAnimation.h" -#include "AnimationControllerPrivate.h" +#include "CSSAnimationControllerPrivate.h" #include "CSSPropertyAnimation.h" #include "CompositeAnimation.h" #include "EventNames.h" -#include "ImplicitAnimation.h" +#include "GeometryUtilities.h" #include "KeyframeAnimation.h" -#include "RenderBoxModelObject.h" +#include "RenderBox.h" +#include "StylePendingResources.h" namespace WebCore { -ImplicitAnimation::ImplicitAnimation(const Animation& transition, CSSPropertyID animatingProperty, RenderElement* renderer, CompositeAnimation* compAnim, RenderStyle* fromStyle) +ImplicitAnimation::ImplicitAnimation(const Animation& transition, CSSPropertyID animatingProperty, RenderElement* renderer, CompositeAnimation* compAnim, const RenderStyle* fromStyle) : AnimationBase(transition, renderer, compAnim) + , m_fromStyle(RenderStyle::clonePtr(*fromStyle)) , m_transitionProperty(transition.property()) , m_animatingProperty(animatingProperty) - , m_overridden(false) - , m_active(true) - , m_fromStyle(fromStyle) { ASSERT(animatingProperty != CSSPropertyInvalid); } @@ -61,12 +61,14 @@ bool ImplicitAnimation::shouldSendEventForListener(Document::ListenerType inList return m_object->document().hasListenerType(inListenerType); } -void ImplicitAnimation::animate(CompositeAnimation*, RenderElement*, const RenderStyle*, RenderStyle* targetStyle, RefPtr<RenderStyle>& animatedStyle) +bool ImplicitAnimation::animate(CompositeAnimation*, RenderElement*, const RenderStyle*, const RenderStyle* targetStyle, std::unique_ptr<RenderStyle>& animatedStyle, bool& didBlendStyle) { // If we get this far and the animation is done, it means we are cleaning up a just finished animation. // So just return. Everything is already all cleaned up. if (postActive()) - return; + return false; + + AnimationState oldState = state(); // Reset to start the transition if we are new if (isNew()) @@ -75,40 +77,64 @@ void ImplicitAnimation::animate(CompositeAnimation*, RenderElement*, const Rende // Run a cycle of animation. // We know we will need a new render style, so make one if needed if (!animatedStyle) - animatedStyle = RenderStyle::clone(targetStyle); + animatedStyle = RenderStyle::clonePtr(*targetStyle); -#if USE(ACCELERATED_COMPOSITING) - bool needsAnim = CSSPropertyAnimation::blendProperties(this, m_animatingProperty, animatedStyle.get(), m_fromStyle.get(), m_toStyle.get(), progress(1, 0, 0)); + CSSPropertyAnimation::blendProperties(this, m_animatingProperty, animatedStyle.get(), m_fromStyle.get(), m_toStyle.get(), progress()); // FIXME: we also need to detect cases where we have to software animate for other reasons, // such as a child using inheriting the transform. https://bugs.webkit.org/show_bug.cgi?id=23902 - if (!needsAnim) - // If we are running an accelerated animation, set a flag in the style which causes the style - // to compare as different to any other style. This ensures that changes to the property - // that is animating are correctly detected during the animation (e.g. when a transition - // gets interrupted). - animatedStyle->setIsRunningAcceleratedAnimation(); -#endif // Fire the start timeout if needed fireAnimationEventsIfNeeded(); + + didBlendStyle = true; + return state() != oldState; } -void ImplicitAnimation::getAnimatedStyle(RefPtr<RenderStyle>& animatedStyle) +void ImplicitAnimation::getAnimatedStyle(std::unique_ptr<RenderStyle>& animatedStyle) { if (!animatedStyle) - animatedStyle = RenderStyle::clone(m_toStyle.get()); + animatedStyle = RenderStyle::clonePtr(*m_toStyle); + + CSSPropertyAnimation::blendProperties(this, m_animatingProperty, animatedStyle.get(), m_fromStyle.get(), m_toStyle.get(), progress()); +} + +bool ImplicitAnimation::computeExtentOfTransformAnimation(LayoutRect& bounds) const +{ + ASSERT(hasStyle()); + + if (!is<RenderBox>(m_object)) + return true; // Non-boxes don't get transformed; - CSSPropertyAnimation::blendProperties(this, m_animatingProperty, animatedStyle.get(), m_fromStyle.get(), m_toStyle.get(), progress(1, 0, 0)); + ASSERT(m_animatingProperty == CSSPropertyTransform); + + RenderBox& box = downcast<RenderBox>(*m_object); + FloatRect rendererBox = snapRectToDevicePixels(box.borderBoxRect(), box.document().deviceScaleFactor()); + + LayoutRect startBounds = bounds; + LayoutRect endBounds = bounds; + + if (transformFunctionListsMatch()) { + if (!computeTransformedExtentViaTransformList(rendererBox, *m_fromStyle, startBounds)) + return false; + + if (!computeTransformedExtentViaTransformList(rendererBox, *m_toStyle, endBounds)) + return false; + } else { + if (!computeTransformedExtentViaMatrix(rendererBox, *m_fromStyle, startBounds)) + return false; + + if (!computeTransformedExtentViaMatrix(rendererBox, *m_toStyle, endBounds)) + return false; + } + + bounds = unionRect(startBounds, endBounds); + return true; } bool ImplicitAnimation::startAnimation(double timeOffset) { -#if USE(ACCELERATED_COMPOSITING) if (m_object && m_object->isComposited()) - return toRenderBoxModelObject(m_object)->startTransition(timeOffset, m_animatingProperty, m_fromStyle.get(), m_toStyle.get()); -#else - UNUSED_PARAM(timeOffset); -#endif + return downcast<RenderBoxModelObject>(*m_object).startTransition(timeOffset, m_animatingProperty, m_fromStyle.get(), m_toStyle.get()); return false; } @@ -117,12 +143,8 @@ void ImplicitAnimation::pauseAnimation(double timeOffset) if (!m_object) return; -#if USE(ACCELERATED_COMPOSITING) if (m_object->isComposited()) - toRenderBoxModelObject(m_object)->transitionPaused(timeOffset, m_animatingProperty); -#else - UNUSED_PARAM(timeOffset); -#endif + downcast<RenderBoxModelObject>(*m_object).transitionPaused(timeOffset, m_animatingProperty); // Restore the original (unanimated) style if (!paused()) setNeedsStyleRecalc(m_object->element()); @@ -130,10 +152,8 @@ void ImplicitAnimation::pauseAnimation(double timeOffset) void ImplicitAnimation::endAnimation() { -#if USE(ACCELERATED_COMPOSITING) if (m_object && m_object->isComposited()) - toRenderBoxModelObject(m_object)->transitionFinished(m_animatingProperty); -#endif + downcast<RenderBoxModelObject>(*m_object).transitionFinished(m_animatingProperty); } void ImplicitAnimation::onAnimationEnd(double elapsedTime) @@ -143,10 +163,9 @@ void ImplicitAnimation::onAnimationEnd(double elapsedTime) // running. But now that the transition has completed, we need to update this style with its new // destination. If we didn't, the next time through we would think a transition had started // (comparing the old unanimated style with the new final style of the transition). - RefPtr<KeyframeAnimation> keyframeAnim = m_compAnim->getAnimationForProperty(m_animatingProperty); - if (keyframeAnim) - keyframeAnim->setUnanimatedStyle(m_toStyle); - + if (auto* animation = m_compositeAnimation->animationForProperty(m_animatingProperty)) + animation->setUnanimatedStyle(RenderStyle::clonePtr(*m_toStyle)); + sendTransitionEvent(eventNames().transitionendEvent, elapsedTime); endAnimation(); } @@ -162,12 +181,12 @@ bool ImplicitAnimation::sendTransitionEvent(const AtomicString& eventType, doubl // Dispatch the event RefPtr<Element> element = m_object->element(); - ASSERT(!element || !element->document().inPageCache()); + ASSERT(!element || element->document().pageCacheState() == Document::NotInPageCache); if (!element) return false; // Schedule event handling - m_compAnim->animationController()->addEventToDispatch(element, eventType, propertyName, elapsedTime); + m_compositeAnimation->animationController().addEventToDispatch(*element, eventType, propertyName, elapsedTime); // Restore the original (unanimated) style if (eventType == eventNames().transitionendEvent && element->renderer()) @@ -180,21 +199,25 @@ bool ImplicitAnimation::sendTransitionEvent(const AtomicString& eventType, doubl return false; // Didn't dispatch an event } -void ImplicitAnimation::reset(RenderStyle* to) +void ImplicitAnimation::reset(const RenderStyle* to) { ASSERT(to); ASSERT(m_fromStyle); - m_toStyle = to; + m_toStyle = RenderStyle::clonePtr(*to); + + if (m_object && m_object->element()) + Style::loadPendingResources(*m_toStyle, m_object->element()->document(), m_object->element()); // Restart the transition if (m_fromStyle && m_toStyle) - updateStateMachine(AnimationStateInputRestartAnimation, -1); + updateStateMachine(AnimationStateInput::RestartAnimation, -1); // set the transform animation list validateTransformFunctionList(); -#if ENABLE(CSS_FILTERS) checkForMatchingFilterFunctionLists(); +#if ENABLE(FILTERS_LEVEL_2) + checkForMatchingBackdropFilterFunctionLists(); #endif } @@ -204,7 +227,7 @@ void ImplicitAnimation::setOverridden(bool b) return; m_overridden = b; - updateStateMachine(m_overridden ? AnimationStateInputPauseOverride : AnimationStateInputResumeOverride, -1); + updateStateMachine(m_overridden ? AnimationStateInput::PauseOverride : AnimationStateInput::ResumeOverride, -1); } bool ImplicitAnimation::affectsProperty(CSSPropertyID property) const @@ -229,12 +252,12 @@ void ImplicitAnimation::blendPropertyValueInStyle(CSSPropertyID prop, RenderStyl if (!m_toStyle) return; - CSSPropertyAnimation::blendProperties(this, prop, currentStyle, m_fromStyle.get(), m_toStyle.get(), progress(1, 0, 0)); + CSSPropertyAnimation::blendProperties(this, prop, currentStyle, m_fromStyle.get(), m_toStyle.get(), progress()); } void ImplicitAnimation::validateTransformFunctionList() { - m_transformFunctionListValid = false; + m_transformFunctionListsMatch = false; if (!m_fromStyle || !m_toStyle) return; @@ -248,44 +271,53 @@ void ImplicitAnimation::validateTransformFunctionList() if (val->operations().isEmpty()) return; - // An emtpy transform list matches anything. + // An empty transform list matches anything. if (val != toVal && !toVal->operations().isEmpty() && !val->operationsMatch(*toVal)) return; // Transform lists match. - m_transformFunctionListValid = true; + m_transformFunctionListsMatch = true; +} + +static bool filterOperationsMatch(const FilterOperations* fromOperations, const FilterOperations& toOperations) +{ + if (fromOperations->operations().isEmpty()) + fromOperations = &toOperations; + + if (fromOperations->operations().isEmpty()) + return false; + + if (fromOperations != &toOperations && !toOperations.operations().isEmpty() && !fromOperations->operationsMatch(toOperations)) + return false; + + return true; } -#if ENABLE(CSS_FILTERS) void ImplicitAnimation::checkForMatchingFilterFunctionLists() { m_filterFunctionListsMatch = false; - + if (!m_fromStyle || !m_toStyle) return; - - const FilterOperations* val = &m_fromStyle->filter(); - const FilterOperations* toVal = &m_toStyle->filter(); - if (val->operations().isEmpty()) - val = toVal; + m_filterFunctionListsMatch = filterOperationsMatch(&m_fromStyle->filter(), m_toStyle->filter()); +} - if (val->operations().isEmpty()) - return; - - // An emtpy filter list matches anything. - if (val != toVal && !toVal->operations().isEmpty() && !val->operationsMatch(*toVal)) +#if ENABLE(FILTERS_LEVEL_2) +void ImplicitAnimation::checkForMatchingBackdropFilterFunctionLists() +{ + m_backdropFilterFunctionListsMatch = false; + + if (!m_fromStyle || !m_toStyle) return; - // Filter lists match. - m_filterFunctionListsMatch = true; + m_backdropFilterFunctionListsMatch = filterOperationsMatch(&m_fromStyle->backdropFilter(), m_toStyle->backdropFilter()); } #endif double ImplicitAnimation::timeToNextService() { double t = AnimationBase::timeToNextService(); -#if USE(ACCELERATED_COMPOSITING) if (t != 0 || preActive()) return t; @@ -295,7 +327,6 @@ double ImplicitAnimation::timeToNextService() bool isLooping; getTimeToNextEvent(t, isLooping); } -#endif return t; } diff --git a/Source/WebCore/page/animation/ImplicitAnimation.h b/Source/WebCore/page/animation/ImplicitAnimation.h index df651141e..9447417b0 100644 --- a/Source/WebCore/page/animation/ImplicitAnimation.h +++ b/Source/WebCore/page/animation/ImplicitAnimation.h @@ -10,7 +10,7 @@ * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. - * 3. Neither the name of Apple Computer, Inc. ("Apple") nor the names of + * 3. Neither the name of Apple Inc. ("Apple") nor the names of * its contributors may be used to endorse or promote products derived * from this software without specific prior written permission. * @@ -26,8 +26,7 @@ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ -#ifndef ImplicitAnimation_h -#define ImplicitAnimation_h +#pragma once #include "AnimationBase.h" #include "CSSPropertyNames.h" @@ -41,27 +40,29 @@ class RenderElement; // for a single RenderElement. class ImplicitAnimation : public AnimationBase { public: - static PassRefPtr<ImplicitAnimation> create(const Animation& animation, CSSPropertyID animatingProperty, RenderElement* renderer, CompositeAnimation* compositeAnimation, RenderStyle* fromStyle) + static Ref<ImplicitAnimation> create(const Animation& animation, CSSPropertyID animatingProperty, RenderElement* renderer, CompositeAnimation* compositeAnimation, const RenderStyle* fromStyle) { - return adoptRef(new ImplicitAnimation(animation, animatingProperty, renderer, compositeAnimation, fromStyle)); + return adoptRef(*new ImplicitAnimation(animation, animatingProperty, renderer, compositeAnimation, fromStyle)); }; CSSPropertyID transitionProperty() const { return m_transitionProperty; } CSSPropertyID animatingProperty() const { return m_animatingProperty; } - virtual void onAnimationEnd(double elapsedTime) override; - virtual bool startAnimation(double timeOffset) override; - virtual void pauseAnimation(double timeOffset) override; - virtual void endAnimation() override; + void onAnimationEnd(double elapsedTime) override; + bool startAnimation(double timeOffset) override; + void pauseAnimation(double timeOffset) override; + void endAnimation() override; - virtual void animate(CompositeAnimation*, RenderElement*, const RenderStyle* currentStyle, RenderStyle* targetStyle, RefPtr<RenderStyle>& animatedStyle) override; - virtual void getAnimatedStyle(RefPtr<RenderStyle>& animatedStyle) override; - virtual void reset(RenderStyle* to); + bool animate(CompositeAnimation*, RenderElement*, const RenderStyle* currentStyle, const RenderStyle* targetStyle, std::unique_ptr<RenderStyle>& animatedStyle, bool& didBlendStyle) override; + void getAnimatedStyle(std::unique_ptr<RenderStyle>& animatedStyle) override; + void reset(const RenderStyle* to); + + bool computeExtentOfTransformAnimation(LayoutRect&) const override; void setOverridden(bool); - virtual bool overridden() const override { return m_overridden; } + bool overridden() const override { return m_overridden; } - virtual bool affectsProperty(CSSPropertyID) const override; + bool affectsProperty(CSSPropertyID) const override; bool hasStyle() const { return m_fromStyle && m_toStyle; } @@ -69,7 +70,7 @@ public: void blendPropertyValueInStyle(CSSPropertyID, RenderStyle*); - virtual double timeToNextService() override; + double timeToNextService() override; bool active() const { return m_active; } void setActive(bool b) { m_active = b; } @@ -79,24 +80,24 @@ protected: bool sendTransitionEvent(const AtomicString&, double elapsedTime); void validateTransformFunctionList(); -#if ENABLE(CSS_FILTERS) void checkForMatchingFilterFunctionLists(); +#if ENABLE(FILTERS_LEVEL_2) + void checkForMatchingBackdropFilterFunctionLists(); #endif private: - ImplicitAnimation(const Animation&, CSSPropertyID, RenderElement*, CompositeAnimation*, RenderStyle*); + ImplicitAnimation(const Animation&, CSSPropertyID, RenderElement*, CompositeAnimation*, const RenderStyle*); virtual ~ImplicitAnimation(); + // The two styles that we are blending. + std::unique_ptr<RenderStyle> m_fromStyle; + std::unique_ptr<RenderStyle> m_toStyle; + CSSPropertyID m_transitionProperty; // Transition property as specified in the RenderStyle. CSSPropertyID m_animatingProperty; // Specific property for this ImplicitAnimation - bool m_overridden; // true when there is a keyframe animation that overrides the transitioning property - bool m_active; // used for culling the list of transitions - // The two styles that we are blending. - RefPtr<RenderStyle> m_fromStyle; - RefPtr<RenderStyle> m_toStyle; + bool m_active { true }; // Used for culling the list of transitions. + bool m_overridden { false }; // True when there is a keyframe animation that overrides the transitioning property }; } // namespace WebCore - -#endif // ImplicitAnimation_h diff --git a/Source/WebCore/page/animation/KeyframeAnimation.cpp b/Source/WebCore/page/animation/KeyframeAnimation.cpp index 8f661c6c3..5294b0a31 100644 --- a/Source/WebCore/page/animation/KeyframeAnimation.cpp +++ b/Source/WebCore/page/animation/KeyframeAnimation.cpp @@ -10,7 +10,7 @@ * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. - * 3. Neither the name of Apple Computer, Inc. ("Apple") nor the names of + * 3. Neither the name of Apple Inc. ("Apple") nor the names of * its contributors may be used to endorse or promote products derived * from this software without specific prior written permission. * @@ -29,33 +29,37 @@ #include "config.h" #include "KeyframeAnimation.h" -#include "AnimationControllerPrivate.h" +#include "CSSAnimationControllerPrivate.h" #include "CSSPropertyAnimation.h" #include "CSSPropertyNames.h" #include "CompositeAnimation.h" #include "EventNames.h" -#include "RenderBoxModelObject.h" +#include "GeometryUtilities.h" +#include "RenderBox.h" #include "RenderStyle.h" +#include "StylePendingResources.h" #include "StyleResolver.h" +#include "StyleScope.h" +#include "TranslateTransformOperation.h" +#include "WillChangeData.h" namespace WebCore { -KeyframeAnimation::KeyframeAnimation(const Animation& animation, RenderElement* renderer, int index, CompositeAnimation* compAnim, RenderStyle* unanimatedStyle) - : AnimationBase(animation, renderer, compAnim) +KeyframeAnimation::KeyframeAnimation(const Animation& animation, RenderElement* renderer, CompositeAnimation* compositeAnimation, const RenderStyle* unanimatedStyle) + : AnimationBase(animation, renderer, compositeAnimation) , m_keyframes(animation.name()) - , m_index(index) - , m_startEventDispatched(false) - , m_unanimatedStyle(unanimatedStyle) + , m_unanimatedStyle(RenderStyle::clonePtr(*unanimatedStyle)) { - // Get the keyframe RenderStyles - if (m_object && m_object->element()) - m_object->document().ensureStyleResolver().keyframeStylesForAnimation(m_object->element(), unanimatedStyle, m_keyframes); + resolveKeyframeStyles(); // Update the m_transformFunctionListValid flag based on whether the function lists in the keyframes match. validateTransformFunctionList(); -#if ENABLE(CSS_FILTERS) checkForMatchingFilterFunctionLists(); +#if ENABLE(FILTERS_LEVEL_2) + checkForMatchingBackdropFilterFunctionLists(); #endif + computeStackingContextImpact(); + computeLayoutDependency(); } KeyframeAnimation::~KeyframeAnimation() @@ -65,38 +69,60 @@ KeyframeAnimation::~KeyframeAnimation() endAnimation(); } -static const Animation* getAnimationFromStyleByName(const RenderStyle* style, const AtomicString& name) +void KeyframeAnimation::computeStackingContextImpact() { - if (!style->animations()) - return 0; - - for (size_t i = 0; i < style->animations()->size(); i++) { - if (name == style->animations()->animation(i).name()) - return &style->animations()->animation(i); + for (auto propertyID : m_keyframes.properties()) { + if (WillChangeData::propertyCreatesStackingContext(propertyID)) { + m_triggersStackingContext = true; + break; + } } +} + +void KeyframeAnimation::computeLayoutDependency() +{ + if (!m_keyframes.containsProperty(CSSPropertyTransform)) + return; - return 0; + size_t numKeyframes = m_keyframes.size(); + for (size_t i = 0; i < numKeyframes; i++) { + auto* keyframeStyle = m_keyframes[i].style(); + if (!keyframeStyle) { + ASSERT_NOT_REACHED(); + continue; + } + if (keyframeStyle->hasTransform()) { + auto& transformOperations = keyframeStyle->transform(); + for (auto operation : transformOperations.operations()) { + if (operation->isTranslateTransformOperationType()) { + auto translation = downcast<TranslateTransformOperation>(operation.get()); + if (translation->x().isPercent() || translation->y().isPercent()) { + m_dependsOnLayout = true; + return; + } + } + } + } + } } void KeyframeAnimation::fetchIntervalEndpointsForProperty(CSSPropertyID property, const RenderStyle*& fromStyle, const RenderStyle*& toStyle, double& prog) const { + size_t numKeyframes = m_keyframes.size(); + if (!numKeyframes) + return; + // Find the first key double elapsedTime = getElapsedTime(); if (m_animation->duration() && m_animation->iterationCount() != Animation::IterationCountInfinite) elapsedTime = std::min(elapsedTime, m_animation->duration() * m_animation->iterationCount()); const double fractionalTime = this->fractionalTime(1, elapsedTime, 0); - - size_t numKeyframes = m_keyframes.size(); - if (!numKeyframes) - return; - ASSERT(!m_keyframes[0].key()); ASSERT(m_keyframes[m_keyframes.size() - 1].key() == 1); - + int prevIndex = -1; int nextIndex = -1; - // FIXME: with a lot of keys, this linear search will be slow. We could binary search. for (size_t i = 0; i < numKeyframes; ++i) { const KeyframeValue& currKeyFrame = m_keyframes[i]; @@ -108,16 +134,11 @@ void KeyframeAnimation::fetchIntervalEndpointsForProperty(CSSPropertyID property nextIndex = i; break; } - prevIndex = i; } - double scale = 1; - double offset = 0; - if (prevIndex == -1) prevIndex = 0; - if (nextIndex == -1) nextIndex = m_keyframes.size() - 1; @@ -126,32 +147,32 @@ void KeyframeAnimation::fetchIntervalEndpointsForProperty(CSSPropertyID property fromStyle = prevKeyframe.style(); toStyle = nextKeyframe.style(); - - offset = prevKeyframe.key(); - scale = 1.0 / (nextKeyframe.key() - prevKeyframe.key()); - const TimingFunction* timingFunction = 0; - if (const Animation* matchedAnimation = getAnimationFromStyleByName(fromStyle, name())) - timingFunction = matchedAnimation->timingFunction().get(); + double offset = prevKeyframe.key(); + double scale = 1.0 / (nextIndex == prevIndex ? 1 : (nextKeyframe.key() - prevKeyframe.key())); - prog = progress(scale, offset, timingFunction); + prog = progress(scale, offset, prevKeyframe.timingFunction(name())); } -void KeyframeAnimation::animate(CompositeAnimation* compositeAnimation, RenderElement*, const RenderStyle*, RenderStyle* targetStyle, RefPtr<RenderStyle>& animatedStyle) +bool KeyframeAnimation::animate(CompositeAnimation* compositeAnimation, RenderElement*, const RenderStyle*, const RenderStyle* targetStyle, std::unique_ptr<RenderStyle>& animatedStyle, bool& didBlendStyle) { // Fire the start timeout if needed fireAnimationEventsIfNeeded(); // If we have not yet started, we will not have a valid start time, so just start the animation if needed. - if (isNew() && m_animation->playState() == AnimPlayStatePlaying && !compositeAnimation->isSuspended()) - updateStateMachine(AnimationStateInputStartAnimation, -1); + if (isNew()) { + if (m_animation->playState() == AnimPlayStatePlaying && !compositeAnimation->isSuspended()) + updateStateMachine(AnimationStateInput::StartAnimation, -1); + else if (m_animation->playState() == AnimPlayStatePaused) + updateStateMachine(AnimationStateInput::PlayStatePaused, -1); + } // If we get this far and the animation is done, it means we are cleaning up a just finished animation. // If so, we need to send back the targetStyle. if (postActive()) { if (!animatedStyle) - animatedStyle = const_cast<RenderStyle*>(targetStyle); - return; + animatedStyle = RenderStyle::clonePtr(*targetStyle); + return false; } // If we are waiting for the start timer, we don't want to change the style yet. @@ -160,65 +181,95 @@ void KeyframeAnimation::animate(CompositeAnimation* compositeAnimation, RenderEl // Special case 2 - if there is a backwards fill mode, then we want to continue // through to the style blend so that we get the fromStyle. if (waitingToStart() && m_animation->delay() > 0 && !m_animation->fillsBackwards()) - return; + return false; // If we have no keyframes, don't animate. if (!m_keyframes.size()) { - updateStateMachine(AnimationStateInputEndAnimation, -1); - return; + updateStateMachine(AnimationStateInput::EndAnimation, -1); + return false; } + // FIXME: the code below never changes the state, so this function always returns false. + AnimationState oldState = state(); + // Run a cycle of animation. // We know we will need a new render style, so make one if needed. if (!animatedStyle) - animatedStyle = RenderStyle::clone(targetStyle); + animatedStyle = RenderStyle::clonePtr(*targetStyle); // FIXME: we need to be more efficient about determining which keyframes we are animating between. // We should cache the last pair or something. - HashSet<CSSPropertyID>::const_iterator endProperties = m_keyframes.endProperties(); - for (HashSet<CSSPropertyID>::const_iterator it = m_keyframes.beginProperties(); it != endProperties; ++it) { + for (auto propertyID : m_keyframes.properties()) { // Get the from/to styles and progress between - const RenderStyle* fromStyle = 0; - const RenderStyle* toStyle = 0; - double progress = 0.0; - fetchIntervalEndpointsForProperty(*it, fromStyle, toStyle, progress); - -#if USE(ACCELERATED_COMPOSITING) - bool needsAnim = CSSPropertyAnimation::blendProperties(this, *it, animatedStyle.get(), fromStyle, toStyle, progress); - if (!needsAnim) - // If we are running an accelerated animation, set a flag in the style - // to indicate it. This can be used to make sure we get an updated - // style for hit testing, etc. - animatedStyle->setIsRunningAcceleratedAnimation(); -#endif + const RenderStyle* fromStyle = nullptr; + const RenderStyle* toStyle = nullptr; + double progress = 0; + fetchIntervalEndpointsForProperty(propertyID, fromStyle, toStyle, progress); + + CSSPropertyAnimation::blendProperties(this, propertyID, animatedStyle.get(), fromStyle, toStyle, progress); } + + didBlendStyle = true; + return state() != oldState; } -void KeyframeAnimation::getAnimatedStyle(RefPtr<RenderStyle>& animatedStyle) +void KeyframeAnimation::getAnimatedStyle(std::unique_ptr<RenderStyle>& animatedStyle) { - // If we're in the delay phase and we're not backwards filling, tell the caller - // to use the current style. - if (waitingToStart() && m_animation->delay() > 0 && !m_animation->fillsBackwards()) + // If we're done, or in the delay phase and we're not backwards filling, tell the caller to use the current style. + if (postActive() || (waitingToStart() && m_animation->delay() > 0 && !m_animation->fillsBackwards())) return; if (!m_keyframes.size()) return; if (!animatedStyle) - animatedStyle = RenderStyle::clone(&m_object->style()); + animatedStyle = RenderStyle::clonePtr(m_object->style()); - HashSet<CSSPropertyID>::const_iterator endProperties = m_keyframes.endProperties(); - for (HashSet<CSSPropertyID>::const_iterator it = m_keyframes.beginProperties(); it != endProperties; ++it) { + for (auto propertyID : m_keyframes.properties()) { // Get the from/to styles and progress between - const RenderStyle* fromStyle = 0; - const RenderStyle* toStyle = 0; - double progress = 0.0; - fetchIntervalEndpointsForProperty(*it, fromStyle, toStyle, progress); + const RenderStyle* fromStyle = nullptr; + const RenderStyle* toStyle = nullptr; + double progress = 0; + fetchIntervalEndpointsForProperty(propertyID, fromStyle, toStyle, progress); - CSSPropertyAnimation::blendProperties(this, *it, animatedStyle.get(), fromStyle, toStyle, progress); + CSSPropertyAnimation::blendProperties(this, propertyID, animatedStyle.get(), fromStyle, toStyle, progress); } } +bool KeyframeAnimation::computeExtentOfTransformAnimation(LayoutRect& bounds) const +{ + ASSERT(m_keyframes.containsProperty(CSSPropertyTransform)); + + if (!is<RenderBox>(m_object)) + return true; // Non-boxes don't get transformed; + + RenderBox& box = downcast<RenderBox>(*m_object); + FloatRect rendererBox = snapRectToDevicePixels(box.borderBoxRect(), box.document().deviceScaleFactor()); + + FloatRect cumulativeBounds = bounds; + + for (auto& keyframe : m_keyframes.keyframes()) { + if (!keyframe.containsProperty(CSSPropertyTransform)) + continue; + + LayoutRect keyframeBounds = bounds; + + bool canCompute; + if (transformFunctionListsMatch()) + canCompute = computeTransformedExtentViaTransformList(rendererBox, *keyframe.style(), keyframeBounds); + else + canCompute = computeTransformedExtentViaMatrix(rendererBox, *keyframe.style(), keyframeBounds); + + if (!canCompute) + return false; + + cumulativeBounds.unite(keyframeBounds); + } + + bounds = LayoutRect(cumulativeBounds); + return true; +} + bool KeyframeAnimation::hasAnimationForProperty(CSSPropertyID property) const { return m_keyframes.containsProperty(property); @@ -226,13 +277,8 @@ bool KeyframeAnimation::hasAnimationForProperty(CSSPropertyID property) const bool KeyframeAnimation::startAnimation(double timeOffset) { -#if USE(ACCELERATED_COMPOSITING) - if (m_object && m_object->isComposited()) { - return toRenderBoxModelObject(m_object)->startAnimation(timeOffset, m_animation.get(), m_keyframes); - } -#else - UNUSED_PARAM(timeOffset); -#endif + if (m_object && m_object->isComposited()) + return downcast<RenderBoxModelObject>(*m_object).startAnimation(timeOffset, m_animation.ptr(), m_keyframes); return false; } @@ -241,12 +287,9 @@ void KeyframeAnimation::pauseAnimation(double timeOffset) if (!m_object) return; -#if USE(ACCELERATED_COMPOSITING) if (m_object->isComposited()) - toRenderBoxModelObject(m_object)->animationPaused(timeOffset, m_keyframes.animationName()); -#else - UNUSED_PARAM(timeOffset); -#endif + downcast<RenderBoxModelObject>(*m_object).animationPaused(timeOffset, m_keyframes.animationName()); + // Restore the original (unanimated) style if (!paused()) setNeedsStyleRecalc(m_object->element()); @@ -257,10 +300,9 @@ void KeyframeAnimation::endAnimation() if (!m_object) return; -#if USE(ACCELERATED_COMPOSITING) if (m_object->isComposited()) - toRenderBoxModelObject(m_object)->animationFinished(m_keyframes.animationName()); -#endif + downcast<RenderBoxModelObject>(*m_object).animationFinished(m_keyframes.animationName()); + // Restore the original (unanimated) style if (!paused()) setNeedsStyleRecalc(m_object->element()); @@ -273,17 +315,17 @@ bool KeyframeAnimation::shouldSendEventForListener(Document::ListenerType listen void KeyframeAnimation::onAnimationStart(double elapsedTime) { - sendAnimationEvent(eventNames().webkitAnimationStartEvent, elapsedTime); + sendAnimationEvent(eventNames().animationstartEvent, elapsedTime); } void KeyframeAnimation::onAnimationIteration(double elapsedTime) { - sendAnimationEvent(eventNames().webkitAnimationIterationEvent, elapsedTime); + sendAnimationEvent(eventNames().animationiterationEvent, elapsedTime); } void KeyframeAnimation::onAnimationEnd(double elapsedTime) { - sendAnimationEvent(eventNames().webkitAnimationEndEvent, elapsedTime); + sendAnimationEvent(eventNames().animationendEvent, elapsedTime); // End the animation if we don't fill forwards. Forward filling // animations are ended properly in the class destructor. if (!m_animation->fillsForwards()) @@ -293,12 +335,12 @@ void KeyframeAnimation::onAnimationEnd(double elapsedTime) bool KeyframeAnimation::sendAnimationEvent(const AtomicString& eventType, double elapsedTime) { Document::ListenerType listenerType; - if (eventType == eventNames().webkitAnimationIterationEvent) + if (eventType == eventNames().webkitAnimationIterationEvent || eventType == eventNames().animationiterationEvent) listenerType = Document::ANIMATIONITERATION_LISTENER; - else if (eventType == eventNames().webkitAnimationEndEvent) + else if (eventType == eventNames().webkitAnimationEndEvent || eventType == eventNames().animationendEvent) listenerType = Document::ANIMATIONEND_LISTENER; else { - ASSERT(eventType == eventNames().webkitAnimationStartEvent); + ASSERT(eventType == eventNames().webkitAnimationStartEvent || eventType == eventNames().animationstartEvent); if (m_startEventDispatched) return false; m_startEventDispatched = true; @@ -309,15 +351,15 @@ bool KeyframeAnimation::sendAnimationEvent(const AtomicString& eventType, double // Dispatch the event RefPtr<Element> element = m_object->element(); - ASSERT(!element || !element->document().inPageCache()); + ASSERT(!element || element->document().pageCacheState() == Document::NotInPageCache); if (!element) return false; // Schedule event handling - m_compAnim->animationController()->addEventToDispatch(element, eventType, m_keyframes.animationName(), elapsedTime); + m_compositeAnimation->animationController().addEventToDispatch(*element, eventType, m_keyframes.animationName(), elapsedTime); // Restore the original (unanimated) style - if (eventType == eventNames().webkitAnimationEndEvent && element->renderer()) + if ((eventType == eventNames().webkitAnimationEndEvent || eventType == eventNames().animationendEvent) && element->renderer()) setNeedsStyleRecalc(element.get()); return true; // Did dispatch an event @@ -329,17 +371,15 @@ bool KeyframeAnimation::sendAnimationEvent(const AtomicString& eventType, double void KeyframeAnimation::overrideAnimations() { // This will override implicit animations that match the properties in the keyframe animation - HashSet<CSSPropertyID>::const_iterator end = m_keyframes.endProperties(); - for (HashSet<CSSPropertyID>::const_iterator it = m_keyframes.beginProperties(); it != end; ++it) - compositeAnimation()->overrideImplicitAnimations(*it); + for (auto propertyID : m_keyframes.properties()) + compositeAnimation()->overrideImplicitAnimations(propertyID); } void KeyframeAnimation::resumeOverriddenAnimations() { // This will resume overridden implicit animations - HashSet<CSSPropertyID>::const_iterator end = m_keyframes.endProperties(); - for (HashSet<CSSPropertyID>::const_iterator it = m_keyframes.beginProperties(); it != end; ++it) - compositeAnimation()->resumeOverriddenImplicitAnimations(*it); + for (auto propertyID : m_keyframes.properties()) + compositeAnimation()->resumeOverriddenImplicitAnimations(propertyID); } bool KeyframeAnimation::affectsProperty(CSSPropertyID property) const @@ -347,11 +387,27 @@ bool KeyframeAnimation::affectsProperty(CSSPropertyID property) const return m_keyframes.containsProperty(property); } +void KeyframeAnimation::resolveKeyframeStyles() +{ + if (!m_object || !m_object->element()) + return; + auto& element = *m_object->element(); + + if (auto* styleScope = Style::Scope::forOrdinal(element, m_animation->nameStyleScopeOrdinal())) + styleScope->resolver().keyframeStylesForAnimation(*m_object->element(), m_unanimatedStyle.get(), m_keyframes); + + // Ensure resource loads for all the frames. + for (auto& keyframe : m_keyframes.keyframes()) { + if (auto* style = const_cast<RenderStyle*>(keyframe.style())) + Style::loadPendingResources(*style, element.document(), &element); + } +} + void KeyframeAnimation::validateTransformFunctionList() { - m_transformFunctionListValid = false; + m_transformFunctionListsMatch = false; - if (m_keyframes.size() < 2 || !m_keyframes.containsProperty(CSSPropertyWebkitTransform)) + if (m_keyframes.size() < 2 || !m_keyframes.containsProperty(CSSPropertyTransform)) return; // Empty transforms match anything, so find the first non-empty entry as the reference @@ -384,16 +440,14 @@ void KeyframeAnimation::validateTransformFunctionList() return; } - // Keyframes are valid - m_transformFunctionListValid = true; + m_transformFunctionListsMatch = true; } -#if ENABLE(CSS_FILTERS) void KeyframeAnimation::checkForMatchingFilterFunctionLists() { m_filterFunctionListsMatch = false; - if (m_keyframes.size() < 2 || !m_keyframes.containsProperty(CSSPropertyWebkitFilter)) + if (m_keyframes.size() < 2 || !m_keyframes.containsProperty(CSSPropertyFilter)) return; // Empty filters match anything, so find the first non-empty entry as the reference @@ -401,8 +455,7 @@ void KeyframeAnimation::checkForMatchingFilterFunctionLists() size_t firstNonEmptyFilterKeyframeIndex = numKeyframes; for (size_t i = 0; i < numKeyframes; ++i) { - const KeyframeValue& currentKeyframe = m_keyframes[i]; - if (currentKeyframe.style()->filter().operations().size()) { + if (m_keyframes[i].style()->filter().operations().size()) { firstNonEmptyFilterKeyframeIndex = i; break; } @@ -410,39 +463,74 @@ void KeyframeAnimation::checkForMatchingFilterFunctionLists() if (firstNonEmptyFilterKeyframeIndex == numKeyframes) return; - - const FilterOperations* firstVal = &m_keyframes[firstNonEmptyFilterKeyframeIndex].style()->filter(); + + auto& firstVal = m_keyframes[firstNonEmptyFilterKeyframeIndex].style()->filter(); for (size_t i = firstNonEmptyFilterKeyframeIndex + 1; i < numKeyframes; ++i) { - const KeyframeValue& currentKeyframe = m_keyframes[i]; - const FilterOperations* val = ¤tKeyframe.style()->filter(); - + auto& value = m_keyframes[i].style()->filter(); + // An emtpy filter list matches anything. - if (val->operations().isEmpty()) + if (value.operations().isEmpty()) continue; - - if (!firstVal->operationsMatch(*val)) + + if (!firstVal.operationsMatch(value)) return; } - + m_filterFunctionListsMatch = true; } + +#if ENABLE(FILTERS_LEVEL_2) +void KeyframeAnimation::checkForMatchingBackdropFilterFunctionLists() +{ + m_backdropFilterFunctionListsMatch = false; + + if (m_keyframes.size() < 2 || !m_keyframes.containsProperty(CSSPropertyWebkitBackdropFilter)) + return; + + // Empty filters match anything, so find the first non-empty entry as the reference + size_t numKeyframes = m_keyframes.size(); + size_t firstNonEmptyFilterKeyframeIndex = numKeyframes; + + for (size_t i = 0; i < numKeyframes; ++i) { + if (m_keyframes[i].style()->backdropFilter().operations().size()) { + firstNonEmptyFilterKeyframeIndex = i; + break; + } + } + + if (firstNonEmptyFilterKeyframeIndex == numKeyframes) + return; + + auto& firstVal = m_keyframes[firstNonEmptyFilterKeyframeIndex].style()->backdropFilter(); + + for (size_t i = firstNonEmptyFilterKeyframeIndex + 1; i < numKeyframes; ++i) { + auto& value = m_keyframes[i].style()->backdropFilter(); + + // An emtpy filter list matches anything. + if (value.operations().isEmpty()) + continue; + + if (!firstVal.operationsMatch(value)) + return; + } + + m_backdropFilterFunctionListsMatch = true; +} #endif double KeyframeAnimation::timeToNextService() { double t = AnimationBase::timeToNextService(); -#if USE(ACCELERATED_COMPOSITING) if (t != 0 || preActive()) return t; // A return value of 0 means we need service. But if we only have accelerated animations we // only need service at the end of the transition - HashSet<CSSPropertyID>::const_iterator endProperties = m_keyframes.endProperties(); bool acceleratedPropertiesOnly = true; - for (HashSet<CSSPropertyID>::const_iterator it = m_keyframes.beginProperties(); it != endProperties; ++it) { - if (!CSSPropertyAnimation::animationOfPropertyIsAccelerated(*it) || !isAccelerated()) { + for (auto propertyID : m_keyframes.properties()) { + if (!CSSPropertyAnimation::animationOfPropertyIsAccelerated(propertyID) || !isAccelerated()) { acceleratedPropertiesOnly = false; break; } @@ -452,7 +540,7 @@ double KeyframeAnimation::timeToNextService() bool isLooping; getTimeToNextEvent(t, isLooping); } -#endif + return t; } diff --git a/Source/WebCore/page/animation/KeyframeAnimation.h b/Source/WebCore/page/animation/KeyframeAnimation.h index 34ebd9951..8731d343c 100644 --- a/Source/WebCore/page/animation/KeyframeAnimation.h +++ b/Source/WebCore/page/animation/KeyframeAnimation.h @@ -10,7 +10,7 @@ * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. - * 3. Neither the name of Apple Computer, Inc. ("Apple") nor the names of + * 3. Neither the name of Apple Inc. ("Apple") nor the names of * its contributors may be used to endorse or promote products derived * from this software without specific prior written permission. * @@ -26,8 +26,7 @@ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ -#ifndef KeyframeAnimation_h -#define KeyframeAnimation_h +#pragma once #include "AnimationBase.h" #include "Document.h" @@ -40,66 +39,72 @@ class RenderStyle; // A KeyframeAnimation tracks the state of an explicit animation for a single RenderElement. class KeyframeAnimation final : public AnimationBase { public: - static RefPtr<KeyframeAnimation> create(const Animation& animation, RenderElement* renderer, int index, CompositeAnimation* compositeAnimation, RenderStyle* unanimatedStyle) + static Ref<KeyframeAnimation> create(const Animation& animation, RenderElement* renderer, CompositeAnimation* compositeAnimation, const RenderStyle* unanimatedStyle) { - return adoptRef(new KeyframeAnimation(animation, renderer, index, compositeAnimation, unanimatedStyle)); + return adoptRef(*new KeyframeAnimation(animation, renderer, compositeAnimation, unanimatedStyle)); } - virtual void animate(CompositeAnimation*, RenderElement*, const RenderStyle* currentStyle, RenderStyle* targetStyle, RefPtr<RenderStyle>& animatedStyle) override; - virtual void getAnimatedStyle(RefPtr<RenderStyle>&) override; + bool animate(CompositeAnimation*, RenderElement*, const RenderStyle* currentStyle, const RenderStyle* targetStyle, std::unique_ptr<RenderStyle>& animatedStyle, bool& didBlendStyle) override; + void getAnimatedStyle(std::unique_ptr<RenderStyle>&) override; + + bool computeExtentOfTransformAnimation(LayoutRect&) const override; const KeyframeList& keyframes() const { return m_keyframes; } const AtomicString& name() const { return m_keyframes.animationName(); } - int index() const { return m_index; } - void setIndex(int i) { m_index = i; } bool hasAnimationForProperty(CSSPropertyID) const; - - void setUnanimatedStyle(PassRefPtr<RenderStyle> style) { m_unanimatedStyle = style; } + + bool triggersStackingContext() const { return m_triggersStackingContext; } + bool dependsOnLayout() const { return m_dependsOnLayout; } + + void setUnanimatedStyle(std::unique_ptr<RenderStyle> style) { m_unanimatedStyle = WTFMove(style); } RenderStyle* unanimatedStyle() const { return m_unanimatedStyle.get(); } - virtual double timeToNextService() override; + double timeToNextService() override; protected: - virtual void onAnimationStart(double elapsedTime) override; - virtual void onAnimationIteration(double elapsedTime) override; - virtual void onAnimationEnd(double elapsedTime) override; - virtual bool startAnimation(double timeOffset) override; - virtual void pauseAnimation(double timeOffset) override; - virtual void endAnimation() override; + void onAnimationStart(double elapsedTime) override; + void onAnimationIteration(double elapsedTime) override; + void onAnimationEnd(double elapsedTime) override; + bool startAnimation(double timeOffset) override; + void pauseAnimation(double timeOffset) override; + void endAnimation() override; - virtual void overrideAnimations() override; - virtual void resumeOverriddenAnimations() override; + void overrideAnimations() override; + void resumeOverriddenAnimations() override; bool shouldSendEventForListener(Document::ListenerType inListenerType) const; bool sendAnimationEvent(const AtomicString&, double elapsedTime); - virtual bool affectsProperty(CSSPropertyID) const override; + bool affectsProperty(CSSPropertyID) const override; + bool computeExtentOfAnimationForMatrixAnimation(const FloatRect& rendererBox, LayoutRect&) const; + + bool computeExtentOfAnimationForMatchingTransformLists(const FloatRect& rendererBox, LayoutRect&) const; + + void computeStackingContextImpact(); + void computeLayoutDependency(); + void resolveKeyframeStyles(); void validateTransformFunctionList(); -#if ENABLE(CSS_FILTERS) void checkForMatchingFilterFunctionLists(); +#if ENABLE(FILTERS_LEVEL_2) + void checkForMatchingBackdropFilterFunctionLists(); #endif private: - KeyframeAnimation(const Animation&, RenderElement*, int index, CompositeAnimation*, RenderStyle* unanimatedStyle); + KeyframeAnimation(const Animation&, RenderElement*, CompositeAnimation*, const RenderStyle* unanimatedStyle); virtual ~KeyframeAnimation(); // Get the styles for the given property surrounding the current animation time and the progress between them. void fetchIntervalEndpointsForProperty(CSSPropertyID, const RenderStyle*& fromStyle, const RenderStyle*& toStyle, double& progress) const; - // The keyframes that we are blending. KeyframeList m_keyframes; + std::unique_ptr<RenderStyle> m_unanimatedStyle; // The style just before we started animation - // The order in which this animation appears in the animation-name style. - int m_index; - bool m_startEventDispatched; - - // The style just before we started animation - RefPtr<RenderStyle> m_unanimatedStyle; + bool m_startEventDispatched { false }; + bool m_triggersStackingContext { false }; + bool m_dependsOnLayout { false }; }; } // namespace WebCore - -#endif // KeyframeAnimation_h |