Source code

Revision control

Copy as Markdown

Other Tools

/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
/* vim: set ts=8 sts=2 et sw=2 tw=80: */
/* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
#include "SMILTimedElement.h"
#include "mozilla/AutoRestore.h"
#include "mozilla/ContentEvents.h"
#include "mozilla/DebugOnly.h"
#include "mozilla/EventDispatcher.h"
#include "mozilla/SMILAnimationFunction.h"
#include "mozilla/SMILInstanceTime.h"
#include "mozilla/SMILParserUtils.h"
#include "mozilla/SMILTimeContainer.h"
#include "mozilla/SMILTimeValue.h"
#include "mozilla/SMILTimeValueSpec.h"
#include "mozilla/dom/DocumentInlines.h"
#include "mozilla/dom/SVGAnimationElement.h"
#include "nsAttrValueInlines.h"
#include "nsGkAtoms.h"
#include "nsReadableUtils.h"
#include "nsMathUtils.h"
#include "nsThreadUtils.h"
#include "prdtoa.h"
#include "prtime.h"
#include "nsString.h"
#include "nsCharSeparatedTokenizer.h"
#include <algorithm>
using namespace mozilla::dom;
namespace mozilla {
//----------------------------------------------------------------------
// Helper class: InstanceTimeComparator
// Upon inserting an instance time into one of our instance time lists we assign
// it a serial number. This allows us to sort the instance times in such a way
// that where we have several equal instance times, the ones added later will
// sort later. This means that when we call UpdateCurrentInterval during the
// waiting state we won't unnecessarily change the begin instance.
//
// The serial number also means that every instance time has an unambiguous
// position in the array so we can use RemoveElementSorted and the like.
bool SMILTimedElement::InstanceTimeComparator::Equals(
const SMILInstanceTime* aElem1, const SMILInstanceTime* aElem2) const {
MOZ_ASSERT(aElem1 && aElem2, "Trying to compare null instance time pointers");
MOZ_ASSERT(aElem1->Serial() && aElem2->Serial(),
"Instance times have not been assigned serial numbers");
MOZ_ASSERT(aElem1 == aElem2 || aElem1->Serial() != aElem2->Serial(),
"Serial numbers are not unique");
return aElem1->Serial() == aElem2->Serial();
}
bool SMILTimedElement::InstanceTimeComparator::LessThan(
const SMILInstanceTime* aElem1, const SMILInstanceTime* aElem2) const {
MOZ_ASSERT(aElem1 && aElem2, "Trying to compare null instance time pointers");
MOZ_ASSERT(aElem1->Serial() && aElem2->Serial(),
"Instance times have not been assigned serial numbers");
int8_t cmp = aElem1->Time().CompareTo(aElem2->Time());
return cmp == 0 ? aElem1->Serial() < aElem2->Serial() : cmp < 0;
}
//----------------------------------------------------------------------
// Helper class: AsyncTimeEventRunner
namespace {
class AsyncTimeEventRunner : public Runnable {
protected:
const RefPtr<nsIContent> mTarget;
EventMessage mMsg;
int32_t mDetail;
public:
AsyncTimeEventRunner(nsIContent* aTarget, EventMessage aMsg, int32_t aDetail)
: mozilla::Runnable("AsyncTimeEventRunner"),
mTarget(aTarget),
mMsg(aMsg),
mDetail(aDetail) {}
// TODO: Convert this to MOZ_CAN_RUN_SCRIPT (bug 1415230, bug 1535398)
MOZ_CAN_RUN_SCRIPT_BOUNDARY NS_IMETHOD Run() override {
InternalSMILTimeEvent event(true, mMsg);
event.mDetail = mDetail;
RefPtr<nsPresContext> context = nullptr;
Document* doc = mTarget->GetComposedDoc();
if (doc) {
context = doc->GetPresContext();
}
return EventDispatcher::Dispatch(mTarget, context, &event);
}
};
} // namespace
//----------------------------------------------------------------------
// Helper class: AutoIntervalUpdateBatcher
// Stack-based helper class to set the mDeferIntervalUpdates flag on an
// SMILTimedElement and perform the UpdateCurrentInterval when the object is
// destroyed.
//
// If several of these objects are allocated on the stack, the update will not
// be performed until the last object for a given SMILTimedElement is
// destroyed.
class MOZ_STACK_CLASS SMILTimedElement::AutoIntervalUpdateBatcher {
public:
explicit AutoIntervalUpdateBatcher(SMILTimedElement& aTimedElement)
: mTimedElement(aTimedElement),
mDidSetFlag(!aTimedElement.mDeferIntervalUpdates) {
mTimedElement.mDeferIntervalUpdates = true;
}
~AutoIntervalUpdateBatcher() {
if (!mDidSetFlag) return;
mTimedElement.mDeferIntervalUpdates = false;
if (mTimedElement.mDoDeferredUpdate) {
mTimedElement.mDoDeferredUpdate = false;
mTimedElement.UpdateCurrentInterval();
}
}
private:
SMILTimedElement& mTimedElement;
bool mDidSetFlag;
};
//----------------------------------------------------------------------
// Helper class: AutoIntervalUpdater
// Stack-based helper class to call UpdateCurrentInterval when it is destroyed
// which helps avoid bugs where we forget to call UpdateCurrentInterval in the
// case of early returns (e.g. due to parse errors).
//
// This can be safely used in conjunction with AutoIntervalUpdateBatcher; any
// calls to UpdateCurrentInterval made by this class will simply be deferred if
// there is an AutoIntervalUpdateBatcher on the stack.
class MOZ_STACK_CLASS SMILTimedElement::AutoIntervalUpdater {
public:
explicit AutoIntervalUpdater(SMILTimedElement& aTimedElement)
: mTimedElement(aTimedElement) {}
~AutoIntervalUpdater() { mTimedElement.UpdateCurrentInterval(); }
private:
SMILTimedElement& mTimedElement;
};
//----------------------------------------------------------------------
// Templated helper functions
// Selectively remove elements from an array of type
// nsTArray<RefPtr<SMILInstanceTime> > with O(n) performance.
template <class TestFunctor>
void SMILTimedElement::RemoveInstanceTimes(InstanceTimeList& aArray,
TestFunctor& aTest) {
InstanceTimeList newArray;
for (uint32_t i = 0; i < aArray.Length(); ++i) {
SMILInstanceTime* item = aArray[i].get();
if (aTest(item, i)) {
// As per bugs 665334 and 669225 we should be careful not to remove the
// instance time that corresponds to the previous interval's end time.
//
// Most functors supplied here fulfil this condition by checking if the
// instance time is marked as "ShouldPreserve" and if so, not deleting it.
//
// However, when filtering instance times, we sometimes need to drop even
// instance times marked as "ShouldPreserve". In that case we take special
// care not to delete the end instance time of the previous interval.
MOZ_ASSERT(!GetPreviousInterval() || item != GetPreviousInterval()->End(),
"Removing end instance time of previous interval");
item->Unlink();
} else {
newArray.AppendElement(item);
}
}
aArray = std::move(newArray);
}
//----------------------------------------------------------------------
// Static members
const nsAttrValue::EnumTable SMILTimedElement::sFillModeTable[] = {
{"remove", FILL_REMOVE}, {"freeze", FILL_FREEZE}, {nullptr, 0}};
const nsAttrValue::EnumTable SMILTimedElement::sRestartModeTable[] = {
{"always", RESTART_ALWAYS},
{"whenNotActive", RESTART_WHENNOTACTIVE},
{"never", RESTART_NEVER},
{nullptr, 0}};
const SMILMilestone SMILTimedElement::sMaxMilestone(
std::numeric_limits<SMILTime>::max(), false);
// The thresholds at which point we start filtering intervals and instance times
// indiscriminately.
// See FilterIntervals and FilterInstanceTimes.
const uint8_t SMILTimedElement::sMaxNumIntervals = 20;
const uint8_t SMILTimedElement::sMaxNumInstanceTimes = 100;
// Detect if we arrive in some sort of undetected recursive syncbase dependency
// relationship
const uint8_t SMILTimedElement::sMaxUpdateIntervalRecursionDepth = 20;
//----------------------------------------------------------------------
// Ctor, dtor
SMILTimedElement::SMILTimedElement()
: mAnimationElement(nullptr),
mFillMode(FILL_REMOVE),
mRestartMode(RESTART_ALWAYS),
mInstanceSerialIndex(0),
mClient(nullptr),
mCurrentInterval(nullptr),
mCurrentRepeatIteration(0),
mPrevRegisteredMilestone(sMaxMilestone),
mElementState(STATE_STARTUP),
mSeekState(SEEK_NOT_SEEKING),
mDeferIntervalUpdates(false),
mDoDeferredUpdate(false),
mIsDisabled(false),
mDeleteCount(0),
mUpdateIntervalRecursionDepth(0) {
mSimpleDur.SetIndefinite();
mMin = SMILTimeValue::Zero();
mMax.SetIndefinite();
}
SMILTimedElement::~SMILTimedElement() {
// Unlink all instance times from dependent intervals
for (RefPtr<SMILInstanceTime>& instance : mBeginInstances) {
instance->Unlink();
}
mBeginInstances.Clear();
for (RefPtr<SMILInstanceTime>& instance : mEndInstances) {
instance->Unlink();
}
mEndInstances.Clear();
// Notify anyone listening to our intervals that they're gone
// (We shouldn't get any callbacks from this because all our instance times
// are now disassociated with any intervals)
ClearIntervals();
// The following assertions are important in their own right (for checking
// correct behavior) but also because AutoIntervalUpdateBatcher holds pointers
// to class so if they fail there's the possibility we might have dangling
// pointers.
MOZ_ASSERT(!mDeferIntervalUpdates,
"Interval updates should no longer be blocked when an "
"SMILTimedElement disappears");
MOZ_ASSERT(!mDoDeferredUpdate,
"There should no longer be any pending updates when an "
"SMILTimedElement disappears");
}
void SMILTimedElement::SetAnimationElement(SVGAnimationElement* aElement) {
MOZ_ASSERT(aElement, "NULL owner element");
MOZ_ASSERT(!mAnimationElement, "Re-setting owner");
mAnimationElement = aElement;
}
SMILTimeContainer* SMILTimedElement::GetTimeContainer() {
return mAnimationElement ? mAnimationElement->GetTimeContainer() : nullptr;
}
dom::Element* SMILTimedElement::GetTargetElement() {
return mAnimationElement ? mAnimationElement->GetTargetElementContent()
: nullptr;
}
//----------------------------------------------------------------------
// ElementTimeControl methods
//
// The definition of the ElementTimeControl interface differs between SMIL
// Animation and SVG 1.1. In SMIL Animation all methods have a void return
// type and the new instance time is simply added to the list and restart
// semantics are applied as with any other instance time. In the SVG definition
// the methods return a bool depending on the restart mode.
//
// This inconsistency has now been addressed by an erratum in SVG 1.1:
//
//
// which favours the definition in SMIL, i.e. instance times are just added
// without first checking the restart mode.
nsresult SMILTimedElement::BeginElementAt(double aOffsetSeconds) {
SMILTimeContainer* container = GetTimeContainer();
if (!container) return NS_ERROR_FAILURE;
SMILTime currentTime = container->GetCurrentTimeAsSMILTime();
return AddInstanceTimeFromCurrentTime(currentTime, aOffsetSeconds, true);
}
nsresult SMILTimedElement::EndElementAt(double aOffsetSeconds) {
SMILTimeContainer* container = GetTimeContainer();
if (!container) return NS_ERROR_FAILURE;
SMILTime currentTime = container->GetCurrentTimeAsSMILTime();
return AddInstanceTimeFromCurrentTime(currentTime, aOffsetSeconds, false);
}
//----------------------------------------------------------------------
// SVGAnimationElement methods
SMILTimeValue SMILTimedElement::GetStartTime() const {
return mElementState == STATE_WAITING || mElementState == STATE_ACTIVE
? mCurrentInterval->Begin()->Time()
: SMILTimeValue();
}
//----------------------------------------------------------------------
// Hyperlinking support
SMILTimeValue SMILTimedElement::GetHyperlinkTime() const {
SMILTimeValue hyperlinkTime; // Default ctor creates unresolved time
if (mElementState == STATE_ACTIVE) {
hyperlinkTime = mCurrentInterval->Begin()->Time();
} else if (!mBeginInstances.IsEmpty()) {
hyperlinkTime = mBeginInstances[0]->Time();
}
return hyperlinkTime;
}
//----------------------------------------------------------------------
// SMILTimedElement
void SMILTimedElement::AddInstanceTime(SMILInstanceTime* aInstanceTime,
bool aIsBegin) {
MOZ_ASSERT(aInstanceTime, "Attempting to add null instance time");
// Event-sensitivity: If an element is not active (but the parent time
// container is), then events are only handled for begin specifications.
if (mElementState != STATE_ACTIVE && !aIsBegin &&
aInstanceTime->IsDynamic()) {
// No need to call Unlink here--dynamic instance times shouldn't be linked
// to anything that's going to miss them
MOZ_ASSERT(!aInstanceTime->GetBaseInterval(),
"Dynamic instance time has a base interval--we probably need "
"to unlink it if we're not going to use it");
return;
}
aInstanceTime->SetSerial(++mInstanceSerialIndex);
InstanceTimeList& instanceList = aIsBegin ? mBeginInstances : mEndInstances;
RefPtr<SMILInstanceTime>* inserted =
instanceList.InsertElementSorted(aInstanceTime, InstanceTimeComparator());
if (!inserted) {
NS_WARNING("Insufficient memory to insert instance time");
return;
}
UpdateCurrentInterval();
}
void SMILTimedElement::UpdateInstanceTime(SMILInstanceTime* aInstanceTime,
SMILTimeValue& aUpdatedTime,
bool aIsBegin) {
MOZ_ASSERT(aInstanceTime, "Attempting to update null instance time");
// The reason we update the time here and not in the SMILTimeValueSpec is
// that it means we *could* re-sort more efficiently by doing a sorted remove
// and insert but currently this doesn't seem to be necessary given how
// infrequently we get these change notices.
aInstanceTime->DependentUpdate(aUpdatedTime);
InstanceTimeList& instanceList = aIsBegin ? mBeginInstances : mEndInstances;
instanceList.Sort(InstanceTimeComparator());
// Generally speaking, UpdateCurrentInterval makes changes to the current
// interval and sends changes notices itself. However, in this case because
// instance times are shared between the instance time list and the intervals
// we are effectively changing the current interval outside
// UpdateCurrentInterval so we need to explicitly signal that we've made
// a change.
//
// This wouldn't be necessary if we cloned instance times on adding them to
// the current interval but this introduces other complications (particularly
// detecting which instance time is being used to define the begin of the
// current interval when doing a Reset).
bool changedCurrentInterval =
mCurrentInterval && (mCurrentInterval->Begin() == aInstanceTime ||
mCurrentInterval->End() == aInstanceTime);
UpdateCurrentInterval(changedCurrentInterval);
}
void SMILTimedElement::RemoveInstanceTime(SMILInstanceTime* aInstanceTime,
bool aIsBegin) {
MOZ_ASSERT(aInstanceTime, "Attempting to remove null instance time");
// If the instance time should be kept (because it is or was the fixed end
// point of an interval) then just disassociate it from the creator.
if (aInstanceTime->ShouldPreserve()) {
aInstanceTime->Unlink();
return;
}
InstanceTimeList& instanceList = aIsBegin ? mBeginInstances : mEndInstances;
mozilla::DebugOnly<bool> found =
instanceList.RemoveElementSorted(aInstanceTime, InstanceTimeComparator());
MOZ_ASSERT(found, "Couldn't find instance time to delete");
UpdateCurrentInterval();
}
namespace {
class MOZ_STACK_CLASS RemoveByCreator {
public:
explicit RemoveByCreator(const SMILTimeValueSpec* aCreator)
: mCreator(aCreator) {}
bool operator()(SMILInstanceTime* aInstanceTime, uint32_t /*aIndex*/) {
if (aInstanceTime->GetCreator() != mCreator) return false;
// If the instance time should be kept (because it is or was the fixed end
// point of an interval) then just disassociate it from the creator.
if (aInstanceTime->ShouldPreserve()) {
aInstanceTime->Unlink();
return false;
}
return true;
}
private:
const SMILTimeValueSpec* mCreator;
};
} // namespace
void SMILTimedElement::RemoveInstanceTimesForCreator(
const SMILTimeValueSpec* aCreator, bool aIsBegin) {
MOZ_ASSERT(aCreator, "Creator not set");
InstanceTimeList& instances = aIsBegin ? mBeginInstances : mEndInstances;
RemoveByCreator removeByCreator(aCreator);
RemoveInstanceTimes(instances, removeByCreator);
UpdateCurrentInterval();
}
void SMILTimedElement::SetTimeClient(SMILAnimationFunction* aClient) {
//
// No need to check for nullptr. A nullptr parameter simply means to remove
// the previous client which we do by setting to nullptr anyway.
//
mClient = aClient;
}
void SMILTimedElement::SampleAt(SMILTime aContainerTime) {
if (mIsDisabled) return;
// Milestones are cleared before a sample
mPrevRegisteredMilestone = sMaxMilestone;
DoSampleAt(aContainerTime, false);
}
void SMILTimedElement::SampleEndAt(SMILTime aContainerTime) {
if (mIsDisabled) return;
// Milestones are cleared before a sample
mPrevRegisteredMilestone = sMaxMilestone;
// If the current interval changes, we don't bother trying to remove any old
// milestones we'd registered. So it's possible to get a call here to end an
// interval at a time that no longer reflects the end of the current interval.
//
// For now we just check that we're actually in an interval but note that the
// initial sample we use to initialise the model is an end sample. This is
// because we want to resolve all the instance times before committing to an
// initial interval. Therefore an end sample from the startup state is also
// acceptable.
if (mElementState == STATE_ACTIVE || mElementState == STATE_STARTUP) {
DoSampleAt(aContainerTime, true); // End sample
} else {
// Even if this was an unnecessary milestone sample we want to be sure that
// our next real milestone is registered.
RegisterMilestone();
}
}
void SMILTimedElement::DoSampleAt(SMILTime aContainerTime, bool aEndOnly) {
MOZ_ASSERT(mAnimationElement,
"Got sample before being registered with an animation element");
MOZ_ASSERT(GetTimeContainer(),
"Got sample without being registered with a time container");
// This could probably happen if we later implement externalResourcesRequired
// (bug 277955) and whilst waiting for those resources (and the animation to
// start) we transfer a node from another document fragment that has already
// started. In such a case we might receive milestone samples registered with
// the already active container.
if (GetTimeContainer()->IsPausedByType(SMILTimeContainer::PAUSE_BEGIN))
return;
// We use an end-sample to start animation since an end-sample lets us
// tentatively create an interval without committing to it (by transitioning
// to the ACTIVE state) and this is necessary because we might have
// dependencies on other animations that are yet to start. After these
// other animations start, it may be necessary to revise our initial interval.
//
// However, sometimes instead of an end-sample we can get a regular sample
// during STARTUP state. This can happen, for example, if we register
// a milestone before time t=0 and are then re-bound to the tree (which sends
// us back to the STARTUP state). In such a case we should just ignore the
// sample and wait for our real initial sample which will be an end-sample.
if (mElementState == STATE_STARTUP && !aEndOnly) return;
bool finishedSeek = false;
if (GetTimeContainer()->IsSeeking() && mSeekState == SEEK_NOT_SEEKING) {
mSeekState = mElementState == STATE_ACTIVE ? SEEK_FORWARD_FROM_ACTIVE
: SEEK_FORWARD_FROM_INACTIVE;
} else if (mSeekState != SEEK_NOT_SEEKING &&
!GetTimeContainer()->IsSeeking()) {
finishedSeek = true;
}
bool stateChanged;
SMILTimeValue sampleTime(aContainerTime);
do {
#ifdef DEBUG
// Check invariant
if (mElementState == STATE_STARTUP || mElementState == STATE_POSTACTIVE) {
MOZ_ASSERT(!mCurrentInterval,
"Shouldn't have current interval in startup or postactive "
"states");
} else {
MOZ_ASSERT(mCurrentInterval,
"Should have current interval in waiting and active states");
}
#endif
stateChanged = false;
switch (mElementState) {
case STATE_STARTUP: {
SMILInterval firstInterval;
mElementState =
GetNextInterval(nullptr, nullptr, nullptr, firstInterval)
? STATE_WAITING
: STATE_POSTACTIVE;
stateChanged = true;
if (mElementState == STATE_WAITING) {
mCurrentInterval = MakeUnique<SMILInterval>(firstInterval);
NotifyNewInterval();
}
} break;
case STATE_WAITING: {
if (mCurrentInterval->Begin()->Time() <= sampleTime) {
mElementState = STATE_ACTIVE;
mCurrentInterval->FixBegin();
if (mClient) {
mClient->Activate(mCurrentInterval->Begin()->Time().GetMillis());
}
if (mSeekState == SEEK_NOT_SEEKING) {
FireTimeEventAsync(eSMILBeginEvent, 0);
}
if (HasPlayed()) {
Reset(); // Apply restart behaviour
// The call to Reset() may mean that the end point of our current
// interval should be changed and so we should update the interval
// now. However, calling UpdateCurrentInterval could result in the
// interval getting deleted (perhaps through some web of syncbase
// dependencies) therefore we make updating the interval the last
// thing we do. There is no guarantee that mCurrentInterval is set
// after this.
UpdateCurrentInterval();
}
stateChanged = true;
}
} break;
case STATE_ACTIVE: {
// Ending early will change the interval but we don't notify dependents
// of the change until we have closed off the current interval (since we
// don't want dependencies to un-end our early end).
bool didApplyEarlyEnd = ApplyEarlyEnd(sampleTime);
if (mCurrentInterval->End()->Time() <= sampleTime) {
SMILInterval newInterval;
mElementState = GetNextInterval(mCurrentInterval.get(), nullptr,
nullptr, newInterval)
? STATE_WAITING
: STATE_POSTACTIVE;
if (mClient) {
mClient->Inactivate(mFillMode == FILL_FREEZE);
}
mCurrentInterval->FixEnd();
if (mSeekState == SEEK_NOT_SEEKING) {
FireTimeEventAsync(eSMILEndEvent, 0);
}
mCurrentRepeatIteration = 0;
mOldIntervals.AppendElement(std::move(mCurrentInterval));
SampleFillValue();
if (mElementState == STATE_WAITING) {
mCurrentInterval = MakeUnique<SMILInterval>(newInterval);
}
// We are now in a consistent state to dispatch notifications
if (didApplyEarlyEnd) {
NotifyChangedInterval(mOldIntervals.LastElement().get(), false,
true);
}
if (mElementState == STATE_WAITING) {
NotifyNewInterval();
}
FilterHistory();
stateChanged = true;
} else if (mCurrentInterval->Begin()->Time() <= sampleTime) {
MOZ_ASSERT(!didApplyEarlyEnd, "We got an early end, but didn't end");
SMILTime beginTime = mCurrentInterval->Begin()->Time().GetMillis();
SMILTime activeTime = aContainerTime - beginTime;
// The 'min' attribute can cause the active interval to be longer than
// the 'repeating interval'.
// In that extended period we apply the fill mode.
if (GetRepeatDuration() <= SMILTimeValue(activeTime)) {
if (mClient && mClient->IsActive()) {
mClient->Inactivate(mFillMode == FILL_FREEZE);
}
SampleFillValue();
} else {
SampleSimpleTime(activeTime);
// We register our repeat times as milestones (except when we're
// seeking) so we should get a sample at exactly the time we repeat.
// (And even when we are seeking we want to update
// mCurrentRepeatIteration so we do that first before testing the
// seek state.)
uint32_t prevRepeatIteration = mCurrentRepeatIteration;
if (ActiveTimeToSimpleTime(activeTime, mCurrentRepeatIteration) ==
0 &&
mCurrentRepeatIteration != prevRepeatIteration &&
mCurrentRepeatIteration && mSeekState == SEEK_NOT_SEEKING) {
FireTimeEventAsync(eSMILRepeatEvent,
static_cast<int32_t>(mCurrentRepeatIteration));
}
}
}
// Otherwise |sampleTime| is *before* the current interval. That
// normally doesn't happen but can happen if we get a stray milestone
// sample (e.g. if we registered a milestone with a time container that
// later got re-attached as a child of a more advanced time container).
// In that case we should just ignore the sample.
} break;
case STATE_POSTACTIVE:
break;
}
// Generally we continue driving the state machine so long as we have
// changed state. However, for end samples we only drive the state machine
// as far as the waiting or postactive state because we don't want to commit
// to any new interval (by transitioning to the active state) until all the
// end samples have finished and we then have complete information about the
// available instance times upon which to base our next interval.
} while (stateChanged && (!aEndOnly || (mElementState != STATE_WAITING &&
mElementState != STATE_POSTACTIVE)));
if (finishedSeek) {
DoPostSeek();
}
RegisterMilestone();
}
void SMILTimedElement::HandleContainerTimeChange() {
// In future we could possibly introduce a separate change notice for time
// container changes and only notify those dependents who live in other time
// containers. For now we don't bother because when we re-resolve the time in
// the SMILTimeValueSpec we'll check if anything has changed and if not, we
// won't go any further.
if (mElementState == STATE_WAITING || mElementState == STATE_ACTIVE) {
NotifyChangedInterval(mCurrentInterval.get(), false, false);
}
}
namespace {
bool RemoveNonDynamic(SMILInstanceTime* aInstanceTime) {
// Generally dynamically-generated instance times (DOM calls, event-based
// times) are not associated with their creator SMILTimeValueSpec since
// they may outlive them.
MOZ_ASSERT(!aInstanceTime->IsDynamic() || !aInstanceTime->GetCreator(),
"Dynamic instance time should be unlinked from its creator");
return !aInstanceTime->IsDynamic() && !aInstanceTime->ShouldPreserve();
}
} // namespace
void SMILTimedElement::Rewind() {
MOZ_ASSERT(mAnimationElement,
"Got rewind request before being attached to an animation "
"element");
// It's possible to get a rewind request whilst we're already in the middle of
// a backwards seek. This can happen when we're performing tree surgery and
// seeking containers at the same time because we can end up requesting
// a local rewind on an element after binding it to a new container and then
// performing a rewind on that container as a whole without sampling in
// between.
//
// However, it should currently be impossible to get a rewind in the middle of
// a forwards seek since forwards seeks are detected and processed within the
// same (re)sample.
if (mSeekState == SEEK_NOT_SEEKING) {
mSeekState = mElementState == STATE_ACTIVE ? SEEK_BACKWARD_FROM_ACTIVE
: SEEK_BACKWARD_FROM_INACTIVE;
}
MOZ_ASSERT(mSeekState == SEEK_BACKWARD_FROM_INACTIVE ||
mSeekState == SEEK_BACKWARD_FROM_ACTIVE,
"Rewind in the middle of a forwards seek?");
ClearTimingState(RemoveNonDynamic);
RebuildTimingState(RemoveNonDynamic);
MOZ_ASSERT(!mCurrentInterval, "Current interval is set at end of rewind");
}
namespace {
bool RemoveAll(SMILInstanceTime* aInstanceTime) { return true; }
} // namespace
bool SMILTimedElement::SetIsDisabled(bool aIsDisabled) {
if (mIsDisabled == aIsDisabled) return false;
if (aIsDisabled) {
mIsDisabled = true;
ClearTimingState(RemoveAll);
} else {
RebuildTimingState(RemoveAll);
mIsDisabled = false;
}
return true;
}
namespace {
bool RemoveNonDOM(SMILInstanceTime* aInstanceTime) {
return !aInstanceTime->FromDOM() && !aInstanceTime->ShouldPreserve();
}
} // namespace
bool SMILTimedElement::SetAttr(nsAtom* aAttribute, const nsAString& aValue,
nsAttrValue& aResult, Element& aContextElement,
nsresult* aParseResult) {
bool foundMatch = true;
nsresult parseResult = NS_OK;
if (aAttribute == nsGkAtoms::begin) {
parseResult = SetBeginSpec(aValue, aContextElement, RemoveNonDOM);
} else if (aAttribute == nsGkAtoms::dur) {
parseResult = SetSimpleDuration(aValue);
} else if (aAttribute == nsGkAtoms::end) {
parseResult = SetEndSpec(aValue, aContextElement, RemoveNonDOM);
} else if (aAttribute == nsGkAtoms::fill) {
parseResult = SetFillMode(aValue);
} else if (aAttribute == nsGkAtoms::max) {
parseResult = SetMax(aValue);
} else if (aAttribute == nsGkAtoms::min) {
parseResult = SetMin(aValue);
} else if (aAttribute == nsGkAtoms::repeatCount) {
parseResult = SetRepeatCount(aValue);
} else if (aAttribute == nsGkAtoms::repeatDur) {
parseResult = SetRepeatDur(aValue);
} else if (aAttribute == nsGkAtoms::restart) {
parseResult = SetRestart(aValue);
} else {
foundMatch = false;
}
if (foundMatch) {
aResult.SetTo(aValue);
if (aParseResult) {
*aParseResult = parseResult;
}
}
return foundMatch;
}
bool SMILTimedElement::UnsetAttr(nsAtom* aAttribute) {
bool foundMatch = true;
if (aAttribute == nsGkAtoms::begin) {
UnsetBeginSpec(RemoveNonDOM);
} else if (aAttribute == nsGkAtoms::dur) {
UnsetSimpleDuration();
} else if (aAttribute == nsGkAtoms::end) {
UnsetEndSpec(RemoveNonDOM);
} else if (aAttribute == nsGkAtoms::fill) {
UnsetFillMode();
} else if (aAttribute == nsGkAtoms::max) {
UnsetMax();
} else if (aAttribute == nsGkAtoms::min) {
UnsetMin();
} else if (aAttribute == nsGkAtoms::repeatCount) {
UnsetRepeatCount();
} else if (aAttribute == nsGkAtoms::repeatDur) {
UnsetRepeatDur();
} else if (aAttribute == nsGkAtoms::restart) {
UnsetRestart();
} else {
foundMatch = false;
}
return foundMatch;
}
//----------------------------------------------------------------------
// Setters and unsetters
nsresult SMILTimedElement::SetBeginSpec(const nsAString& aBeginSpec,
Element& aContextElement,
RemovalTestFunction aRemove) {
return SetBeginOrEndSpec(aBeginSpec, aContextElement, true /*isBegin*/,
aRemove);
}
void SMILTimedElement::UnsetBeginSpec(RemovalTestFunction aRemove) {
ClearSpecs(mBeginSpecs, mBeginInstances, aRemove);
UpdateCurrentInterval();
}
nsresult SMILTimedElement::SetEndSpec(const nsAString& aEndSpec,
Element& aContextElement,
RemovalTestFunction aRemove) {
return SetBeginOrEndSpec(aEndSpec, aContextElement, false /*!isBegin*/,
aRemove);
}
void SMILTimedElement::UnsetEndSpec(RemovalTestFunction aRemove) {
ClearSpecs(mEndSpecs, mEndInstances, aRemove);
UpdateCurrentInterval();
}
nsresult SMILTimedElement::SetSimpleDuration(const nsAString& aDurSpec) {
// Update the current interval before returning
AutoIntervalUpdater updater(*this);
SMILTimeValue duration;
const nsAString& dur = SMILParserUtils::TrimWhitespace(aDurSpec);
// SVG-specific: "For SVG's animation elements, if "media" is specified, the
// attribute will be ignored." (SVG 1.1, section 19.2.6)
if (dur.EqualsLiteral("media") || dur.EqualsLiteral("indefinite")) {
duration.SetIndefinite();
} else {
if (!SMILParserUtils::ParseClockValue(
dur, SMILTimeValue::Rounding::EnsureNonZero, &duration) ||
duration.IsZero()) {
mSimpleDur.SetIndefinite();
return NS_ERROR_FAILURE;
}
}
// mSimpleDur should never be unresolved. ParseClockValue will either set
// duration to resolved or will return false.
MOZ_ASSERT(duration.IsResolved(), "Setting unresolved simple duration");
mSimpleDur = duration;
return NS_OK;
}
void SMILTimedElement::UnsetSimpleDuration() {
mSimpleDur.SetIndefinite();
UpdateCurrentInterval();
}
nsresult SMILTimedElement::SetMin(const nsAString& aMinSpec) {
// Update the current interval before returning
AutoIntervalUpdater updater(*this);
SMILTimeValue duration;
const nsAString& min = SMILParserUtils::TrimWhitespace(aMinSpec);
if (min.EqualsLiteral("media")) {
duration = SMILTimeValue::Zero();
} else {
if (!SMILParserUtils::ParseClockValue(min, SMILTimeValue::Rounding::Nearest,
&duration)) {
mMin = SMILTimeValue::Zero();
return NS_ERROR_FAILURE;
}
}
MOZ_ASSERT(duration.GetMillis() >= 0L, "Invalid duration");
mMin = duration;
return NS_OK;
}
void SMILTimedElement::UnsetMin() {
mMin = SMILTimeValue::Zero();
UpdateCurrentInterval();
}
nsresult SMILTimedElement::SetMax(const nsAString& aMaxSpec) {
// Update the current interval before returning
AutoIntervalUpdater updater(*this);
SMILTimeValue duration;
const nsAString& max = SMILParserUtils::TrimWhitespace(aMaxSpec);
if (max.EqualsLiteral("media") || max.EqualsLiteral("indefinite")) {
duration.SetIndefinite();
} else {
if (!SMILParserUtils::ParseClockValue(
max, SMILTimeValue::Rounding::EnsureNonZero, &duration) ||
duration.IsZero()) {
mMax.SetIndefinite();
return NS_ERROR_FAILURE;
}
MOZ_ASSERT(duration.GetMillis() > 0L, "Invalid duration");
}
mMax = duration;
return NS_OK;
}
void SMILTimedElement::UnsetMax() {
mMax.SetIndefinite();
UpdateCurrentInterval();
}
nsresult SMILTimedElement::SetRestart(const nsAString& aRestartSpec) {
nsAttrValue temp;
bool parseResult = temp.ParseEnumValue(aRestartSpec, sRestartModeTable, true);
mRestartMode =
parseResult ? SMILRestartMode(temp.GetEnumValue()) : RESTART_ALWAYS;
UpdateCurrentInterval();
return parseResult ? NS_OK : NS_ERROR_FAILURE;
}
void SMILTimedElement::UnsetRestart() {
mRestartMode = RESTART_ALWAYS;
UpdateCurrentInterval();
}
nsresult SMILTimedElement::SetRepeatCount(const nsAString& aRepeatCountSpec) {
// Update the current interval before returning
AutoIntervalUpdater updater(*this);
SMILRepeatCount newRepeatCount;
if (SMILParserUtils::ParseRepeatCount(aRepeatCountSpec, newRepeatCount)) {
mRepeatCount = newRepeatCount;
return NS_OK;
}
mRepeatCount.Unset();
return NS_ERROR_FAILURE;
}
void SMILTimedElement::UnsetRepeatCount() {
mRepeatCount.Unset();
UpdateCurrentInterval();
}
nsresult SMILTimedElement::SetRepeatDur(const nsAString& aRepeatDurSpec) {
// Update the current interval before returning
AutoIntervalUpdater updater(*this);
SMILTimeValue duration;
const nsAString& repeatDur = SMILParserUtils::TrimWhitespace(aRepeatDurSpec);
if (repeatDur.EqualsLiteral("indefinite")) {
duration.SetIndefinite();
} else {
if (!SMILParserUtils::ParseClockValue(
repeatDur, SMILTimeValue::Rounding::EnsureNonZero, &duration)) {
mRepeatDur.SetUnresolved();
return NS_ERROR_FAILURE;
}
}
mRepeatDur = duration;
return NS_OK;
}
void SMILTimedElement::UnsetRepeatDur() {
mRepeatDur.SetUnresolved();
UpdateCurrentInterval();
}
nsresult SMILTimedElement::SetFillMode(const nsAString& aFillModeSpec) {
uint16_t previousFillMode = mFillMode;
nsAttrValue temp;
bool parseResult = temp.ParseEnumValue(aFillModeSpec, sFillModeTable, true);
mFillMode = parseResult ? SMILFillMode(temp.GetEnumValue()) : FILL_REMOVE;
// Update fill mode of client
if (mFillMode != previousFillMode && HasClientInFillRange()) {
mClient->Inactivate(mFillMode == FILL_FREEZE);
SampleFillValue();
}
return parseResult ? NS_OK : NS_ERROR_FAILURE;
}
void SMILTimedElement::UnsetFillMode() {
uint16_t previousFillMode = mFillMode;
mFillMode = FILL_REMOVE;
if (previousFillMode == FILL_FREEZE && HasClientInFillRange()) {
mClient->Inactivate(false);
}
}
void SMILTimedElement::AddDependent(SMILTimeValueSpec& aDependent) {
// There's probably no harm in attempting to register a dependent
// SMILTimeValueSpec twice, but we're not expecting it to happen.
MOZ_ASSERT(!mTimeDependents.GetEntry(&aDependent),
"SMILTimeValueSpec is already registered as a dependency");
mTimeDependents.PutEntry(&aDependent);
// Add current interval. We could add historical intervals too but that would
// cause unpredictable results since some intervals may have been filtered.
// SMIL doesn't say what to do here so for simplicity and consistency we
// simply add the current interval if there is one.
//
// It's not necessary to call SyncPauseTime since we're dealing with
// historical instance times not newly added ones.
if (mCurrentInterval) {
aDependent.HandleNewInterval(*mCurrentInterval, GetTimeContainer());
}
}
void SMILTimedElement::RemoveDependent(SMILTimeValueSpec& aDependent) {
mTimeDependents.RemoveEntry(&aDependent);
}
bool SMILTimedElement::IsTimeDependent(const SMILTimedElement& aOther) const {
const SMILInstanceTime* thisBegin = GetEffectiveBeginInstance();
const SMILInstanceTime* otherBegin = aOther.GetEffectiveBeginInstance();
if (!thisBegin || !otherBegin) return false;
return thisBegin->IsDependentOn(*otherBegin);
}
void SMILTimedElement::BindToTree(Element& aContextElement) {
// Reset previously registered milestone since we may be registering with
// a different time container now.
mPrevRegisteredMilestone = sMaxMilestone;
// If we were already active then clear all our timing information and start
// afresh
if (mElementState != STATE_STARTUP) {
mSeekState = SEEK_NOT_SEEKING;
Rewind();
}
// Scope updateBatcher to last only for the ResolveReferences calls:
{
AutoIntervalUpdateBatcher updateBatcher(*this);
// Resolve references to other parts of the tree
for (UniquePtr<SMILTimeValueSpec>& beginSpec : mBeginSpecs) {
beginSpec->ResolveReferences(aContextElement);
}
for (UniquePtr<SMILTimeValueSpec>& endSpec : mEndSpecs) {
endSpec->ResolveReferences(aContextElement);
}
}
RegisterMilestone();
}
void SMILTimedElement::HandleTargetElementChange(Element* aNewTarget) {
AutoIntervalUpdateBatcher updateBatcher(*this);
for (UniquePtr<SMILTimeValueSpec>& beginSpec : mBeginSpecs) {
beginSpec->HandleTargetElementChange(aNewTarget);
}
for (UniquePtr<SMILTimeValueSpec>& endSpec : mEndSpecs) {
endSpec->HandleTargetElementChange(aNewTarget);
}
}
void SMILTimedElement::Traverse(nsCycleCollectionTraversalCallback* aCallback) {
for (UniquePtr<SMILTimeValueSpec>& beginSpec : mBeginSpecs) {
MOZ_ASSERT(beginSpec, "null SMILTimeValueSpec in list of begin specs");
beginSpec->Traverse(aCallback);
}
for (UniquePtr<SMILTimeValueSpec>& endSpec : mEndSpecs) {
MOZ_ASSERT(endSpec, "null SMILTimeValueSpec in list of end specs");
endSpec->Traverse(aCallback);
}
}
void SMILTimedElement::Unlink() {
AutoIntervalUpdateBatcher updateBatcher(*this);
// Remove dependencies on other elements
for (UniquePtr<SMILTimeValueSpec>& beginSpec : mBeginSpecs) {
MOZ_ASSERT(beginSpec, "null SMILTimeValueSpec in list of begin specs");
beginSpec->Unlink();
}
for (UniquePtr<SMILTimeValueSpec>& endSpec : mEndSpecs) {
MOZ_ASSERT(endSpec, "null SMILTimeValueSpec in list of end specs");
endSpec->Unlink();
}
ClearIntervals();
// Make sure we don't notify other elements of new intervals
mTimeDependents.Clear();
}
//----------------------------------------------------------------------
// Implementation helpers
nsresult SMILTimedElement::SetBeginOrEndSpec(const nsAString& aSpec,
Element& aContextElement,
bool aIsBegin,
RemovalTestFunction aRemove) {
TimeValueSpecList& timeSpecsList = aIsBegin ? mBeginSpecs : mEndSpecs;
InstanceTimeList& instances = aIsBegin ? mBeginInstances : mEndInstances;
ClearSpecs(timeSpecsList, instances, aRemove);
AutoIntervalUpdateBatcher updateBatcher(*this);
nsCharSeparatedTokenizer tokenizer(aSpec, ';');
if (!tokenizer.hasMoreTokens()) { // Empty list
return NS_ERROR_FAILURE;
}
bool hadFailure = false;
while (tokenizer.hasMoreTokens()) {
auto spec = MakeUnique<SMILTimeValueSpec>(*this, aIsBegin);
nsresult rv = spec->SetSpec(tokenizer.nextToken(), aContextElement);
if (NS_SUCCEEDED(rv)) {
timeSpecsList.AppendElement(std::move(spec));
} else {
hadFailure = true;
}
}
// The return value from this function is only used to determine if we should
// print a console message or not, so we return failure if we had one or more
// failures but we don't need to differentiate between different types of
// failures or the number of failures.
return hadFailure ? NS_ERROR_FAILURE : NS_OK;
}
namespace {
// Adaptor functor for RemoveInstanceTimes that allows us to use function
// pointers instead.
// Without this we'd have to either templatize ClearSpecs and all its callers
// or pass bool flags around to specify which removal function to use here.
class MOZ_STACK_CLASS RemoveByFunction {
public:
explicit RemoveByFunction(SMILTimedElement::RemovalTestFunction aFunction)
: mFunction(aFunction) {}
bool operator()(SMILInstanceTime* aInstanceTime, uint32_t /*aIndex*/) {
return mFunction(aInstanceTime);
}
private:
SMILTimedElement::RemovalTestFunction mFunction;
};
} // namespace
void SMILTimedElement::ClearSpecs(TimeValueSpecList& aSpecs,
InstanceTimeList& aInstances,
RemovalTestFunction aRemove) {
AutoIntervalUpdateBatcher updateBatcher(*this);
for (UniquePtr<SMILTimeValueSpec>& spec : aSpecs) {
spec->Unlink();
}
aSpecs.Clear();
RemoveByFunction removeByFunction(aRemove);
RemoveInstanceTimes(aInstances, removeByFunction);
}
void SMILTimedElement::ClearIntervals() {
if (mElementState != STATE_STARTUP) {
mElementState = STATE_POSTACTIVE;
}
mCurrentRepeatIteration = 0;
ResetCurrentInterval();
// Remove old intervals
for (int32_t i = mOldIntervals.Length() - 1; i >= 0; --i) {
mOldIntervals[i]->Unlink();
}
mOldIntervals.Clear();
}
bool SMILTimedElement::ApplyEarlyEnd(const SMILTimeValue& aSampleTime) {
// This should only be called within DoSampleAt as a helper function
MOZ_ASSERT(mElementState == STATE_ACTIVE,
"Unexpected state to try to apply an early end");
bool updated = false;
// Only apply an early end if we're not already ending.
if (mCurrentInterval->End()->Time() > aSampleTime) {
SMILInstanceTime* earlyEnd = CheckForEarlyEnd(aSampleTime);
if (earlyEnd) {
if (earlyEnd->IsDependent()) {
// Generate a new instance time for the early end since the
// existing instance time is part of some dependency chain that we
// don't want to participate in.
RefPtr<SMILInstanceTime> newEarlyEnd =
new SMILInstanceTime(earlyEnd->Time());
mCurrentInterval->SetEnd(*newEarlyEnd);
} else {
mCurrentInterval->SetEnd(*earlyEnd);
}
updated = true;
}
}
return updated;
}
namespace {
class MOZ_STACK_CLASS RemoveReset {
public:
explicit RemoveReset(const SMILInstanceTime* aCurrentIntervalBegin)
: mCurrentIntervalBegin(aCurrentIntervalBegin) {}
bool operator()(SMILInstanceTime* aInstanceTime, uint32_t /*aIndex*/) {
// SMIL 3.0 section 5.4.3, 'Resetting element state':
// Any instance times associated with past Event-values, Repeat-values,
// Accesskey-values or added via DOM method calls are removed from the
// dependent begin and end instance times lists. In effect, all events
// and DOM methods calls in the past are cleared. This does not apply to
// an instance time that defines the begin of the current interval.
return aInstanceTime->IsDynamic() && !aInstanceTime->ShouldPreserve() &&
(!mCurrentIntervalBegin || aInstanceTime != mCurrentIntervalBegin);
}
private:
const SMILInstanceTime* mCurrentIntervalBegin;
};
} // namespace
void SMILTimedElement::Reset() {
RemoveReset resetBegin(mCurrentInterval ? mCurrentInterval->Begin()
: nullptr);
RemoveInstanceTimes(mBeginInstances, resetBegin);
RemoveReset resetEnd(nullptr);
RemoveInstanceTimes(mEndInstances, resetEnd);
}
void SMILTimedElement::ClearTimingState(RemovalTestFunction aRemove) {
mElementState = STATE_STARTUP;
ClearIntervals();
UnsetBeginSpec(aRemove);
UnsetEndSpec(aRemove);
if (mClient) {
mClient->Inactivate(false);
}
}
void SMILTimedElement::RebuildTimingState(RemovalTestFunction aRemove) {
MOZ_ASSERT(mAnimationElement,
"Attempting to enable a timed element not attached to an "
"animation element");
MOZ_ASSERT(mElementState == STATE_STARTUP,
"Rebuilding timing state from non-startup state");
if (mAnimationElement->HasAttr(nsGkAtoms::begin)) {
nsAutoString attValue;
mAnimationElement->GetAttr(nsGkAtoms::begin, attValue);
SetBeginSpec(attValue, *mAnimationElement, aRemove);
}
if (mAnimationElement->HasAttr(nsGkAtoms::end)) {
nsAutoString attValue;
mAnimationElement->GetAttr(nsGkAtoms::end, attValue);
SetEndSpec(attValue, *mAnimationElement, aRemove);
}
mPrevRegisteredMilestone = sMaxMilestone;
RegisterMilestone();
}
void SMILTimedElement::DoPostSeek() {
// Finish backwards seek
if (mSeekState == SEEK_BACKWARD_FROM_INACTIVE ||
mSeekState == SEEK_BACKWARD_FROM_ACTIVE) {
// Previously some dynamic instance times may have been marked to be
// preserved because they were endpoints of an historic interval (which may
// or may not have been filtered). Now that we've finished a seek we should
// clear that flag for those instance times whose intervals are no longer
// historic.
UnpreserveInstanceTimes(mBeginInstances);
UnpreserveInstanceTimes(mEndInstances);
// Now that the times have been unmarked perform a reset. This might seem
// counter-intuitive when we're only doing a seek within an interval but
// SMIL seems to require this. SMIL 3.0, 'Hyperlinks and timing':
// Resolved end times associated with events, Repeat-values,
// Accesskey-values or added via DOM method calls are cleared when seeking
// to time earlier than the resolved end time.
Reset();
UpdateCurrentInterval();
}
switch (mSeekState) {
case SEEK_FORWARD_FROM_ACTIVE:
case SEEK_BACKWARD_FROM_ACTIVE:
if (mElementState != STATE_ACTIVE) {
FireTimeEventAsync(eSMILEndEvent, 0);
}
break;
case SEEK_FORWARD_FROM_INACTIVE:
case SEEK_BACKWARD_FROM_INACTIVE:
if (mElementState == STATE_ACTIVE) {
FireTimeEventAsync(eSMILBeginEvent, 0);
}
break;
case SEEK_NOT_SEEKING:
/* Do nothing */
break;
}
mSeekState = SEEK_NOT_SEEKING;
}
void SMILTimedElement::UnpreserveInstanceTimes(InstanceTimeList& aList) {
const SMILInterval* prevInterval = GetPreviousInterval();
const SMILInstanceTime* cutoff = mCurrentInterval ? mCurrentInterval->Begin()
: prevInterval ? prevInterval->Begin()
: nullptr;
for (RefPtr<SMILInstanceTime>& instance : aList) {
if (!cutoff || cutoff->Time().CompareTo(instance->Time()) < 0) {
instance->UnmarkShouldPreserve();
}
}
}
void SMILTimedElement::FilterHistory() {
// We should filter the intervals first, since instance times still used in an
// interval won't be filtered.
FilterIntervals();
FilterInstanceTimes(mBeginInstances);
FilterInstanceTimes(mEndInstances);
}
void SMILTimedElement::FilterIntervals() {
// We can filter old intervals that:
//
// a) are not the previous interval; AND
// b) are not in the middle of a dependency chain; AND
// c) are not the first interval
//
// Condition (a) is necessary since the previous interval is used for applying
// fill effects and updating the current interval.
//
// Condition (b) is necessary since even if this interval itself is not
// active, it may be part of a dependency chain that includes active
// intervals. Such chains are used to establish priorities within the
// animation sandwich.
//
// Condition (c) is necessary to support hyperlinks that target animations
// since in some cases the defined behavior is to seek the document back to
// the first resolved begin time. Presumably the intention here is not
// actually to use the first resolved begin time, the
// _the_first_resolved_begin_time_that_produced_an_interval. That is,
// if we have begin="-5s; -3s; 1s; 3s" with a duration on 1s, we should seek
// to 1s. The spec doesn't say this but I'm pretty sure that is the intention.
// It seems negative times were simply not considered.
//
// Although the above conditions allow us to safely filter intervals for most
// scenarios they do not cover all cases and there will still be scenarios
// that generate intervals indefinitely. In such a case we simply set
// a maximum number of intervals and drop any intervals beyond that threshold.
uint32_t threshold = mOldIntervals.Length() > sMaxNumIntervals
? mOldIntervals.Length() - sMaxNumIntervals
: 0;
IntervalList filteredList;
for (uint32_t i = 0; i < mOldIntervals.Length(); ++i) {
SMILInterval* interval = mOldIntervals[i].get();
if (i != 0 && /*skip first interval*/
i + 1 < mOldIntervals.Length() && /*skip previous interval*/
(i < threshold || !interval->IsDependencyChainLink())) {
interval->Unlink(true /*filtered, not deleted*/);
} else {
filteredList.AppendElement(std::move(mOldIntervals[i]));
}
}
mOldIntervals = std::move(filteredList);
}
namespace {
class MOZ_STACK_CLASS RemoveFiltered {
public:
explicit RemoveFiltered(SMILTimeValue aCutoff) : mCutoff(aCutoff) {}
bool operator()(SMILInstanceTime* aInstanceTime, uint32_t /*aIndex*/) {
// We can filter instance times that:
// a) Precede the end point of the previous interval; AND
// b) Are NOT syncbase times that might be updated to a time after the end
// point of the previous interval; AND
// c) Are NOT fixed end points in any remaining interval.
return aInstanceTime->Time() < mCutoff && aInstanceTime->IsFixedTime() &&
!aInstanceTime->ShouldPreserve();
}
private:
SMILTimeValue mCutoff;
};
class MOZ_STACK_CLASS RemoveBelowThreshold {
public:
RemoveBelowThreshold(uint32_t aThreshold,
nsTArray<const SMILInstanceTime*>& aTimesToKeep)
: mThreshold(aThreshold), mTimesToKeep(aTimesToKeep) {}
bool operator()(SMILInstanceTime* aInstanceTime, uint32_t aIndex) {
return aIndex < mThreshold && !mTimesToKeep.Contains(aInstanceTime);
}
private:
uint32_t mThreshold;
nsTArray<const SMILInstanceTime*>& mTimesToKeep;
};
} // namespace
void SMILTimedElement::FilterInstanceTimes(InstanceTimeList& aList) {
if (GetPreviousInterval()) {
RemoveFiltered removeFiltered(GetPreviousInterval()->End()->Time());
RemoveInstanceTimes(aList, removeFiltered);
}
// As with intervals it is possible to create a document that, even despite
// our most aggressive filtering, will generate instance times indefinitely
// (e.g. cyclic dependencies with TimeEvents---we can't filter such times as
// they're unpredictable due to the possibility of seeking the document which
// may prevent some events from being generated). Therefore we introduce
// a hard cutoff at which point we just drop the oldest instance times.
if (aList.Length() > sMaxNumInstanceTimes) {
uint32_t threshold = aList.Length() - sMaxNumInstanceTimes;
// There are a few instance times we should keep though, notably:
// - the current interval begin time,
// - the previous interval end time (see note in RemoveInstanceTimes)
// - the first interval begin time (see note in FilterIntervals)
nsTArray<const SMILInstanceTime*> timesToKeep;
if (mCurrentInterval) {
timesToKeep.AppendElement(mCurrentInterval->Begin());
}
const SMILInterval* prevInterval = GetPreviousInterval();
if (prevInterval) {
timesToKeep.AppendElement(prevInterval->End());
}
if (!mOldIntervals.IsEmpty()) {
timesToKeep.AppendElement(mOldIntervals[0]->Begin());
}
RemoveBelowThreshold removeBelowThreshold(threshold, timesToKeep);
RemoveInstanceTimes(aList, removeBelowThreshold);
}
}
//
// This method is based on the pseudocode given in the SMILANIM spec.
//
// See:
//
bool SMILTimedElement::GetNextInterval(const SMILInterval* aPrevInterval,
const SMILInterval* aReplacedInterval,
const SMILInstanceTime* aFixedBeginTime,
SMILInterval& aResult) const {
MOZ_ASSERT(!aFixedBeginTime || aFixedBeginTime->Time().IsDefinite(),
"Unresolved or indefinite begin time given for interval start");
static const SMILTimeValue zeroTime(0L);
if (mRestartMode == RESTART_NEVER && aPrevInterval) return false;
// Calc starting point
SMILTimeValue beginAfter;
bool prevIntervalWasZeroDur = false;
if (aPrevInterval) {
beginAfter = aPrevInterval->End()->Time();
prevIntervalWasZeroDur =
aPrevInterval->End()->Time() == aPrevInterval->Begin()->Time();
} else {
beginAfter.SetMillis(INT64_MIN);
}
RefPtr<SMILInstanceTime> tempBegin;
RefPtr<SMILInstanceTime> tempEnd;
while (true) {
// Calculate begin time
if (aFixedBeginTime) {
if (aFixedBeginTime->Time() < beginAfter) {
return false;
}
// our ref-counting is not const-correct
tempBegin = const_cast<SMILInstanceTime*>(aFixedBeginTime);
} else if ((!mAnimationElement ||
!mAnimationElement->HasAttr(nsGkAtoms::begin)) &&
beginAfter <= zeroTime) {
tempBegin = new SMILInstanceTime(SMILTimeValue(0));
} else {
int32_t beginPos = 0;
do {
tempBegin =
GetNextGreaterOrEqual(mBeginInstances, beginAfter, beginPos);
if (!tempBegin || !tempBegin->Time().IsDefinite()) {
return false;
}
// If we're updating the current interval then skip any begin time that
// is dependent on the current interval's begin time. e.g.
// <animate id="a" begin="b.begin; a.begin+2s"...
// If b's interval disappears whilst 'a' is in the waiting state the
// begin time at "a.begin+2s" should be skipped since 'a' never begun.
} while (aReplacedInterval &&
tempBegin->GetBaseTime() == aReplacedInterval->Begin());
}
MOZ_ASSERT(tempBegin && tempBegin->Time().IsDefinite() &&
tempBegin->Time() >= beginAfter,
"Got a bad begin time while fetching next interval");
// Calculate end time
{
int32_t endPos = 0;
do {
tempEnd =
GetNextGreaterOrEqual(mEndInstances, tempBegin->Time(), endPos);
// SMIL doesn't allow for coincident zero-duration intervals, so if the
// previous interval was zero-duration, and tempEnd is going to give us
// another zero duration interval, then look for another end to use
// instead.
if (tempEnd && prevIntervalWasZeroDur &&
tempEnd->Time() == beginAfter) {
tempEnd = GetNextGreater(mEndInstances, tempBegin->Time(), endPos);
}
// As above with begin times, avoid creating self-referential loops
// between instance times by checking that the newly found end instance
// time is not already dependent on the end of the current interval.
} while (tempEnd && aReplacedInterval &&
tempEnd->GetBaseTime() == aReplacedInterval->End());
if (!tempEnd) {
// If all the ends are before the beginning we have a bad interval
// UNLESS:
// a) We never had any end attribute to begin with (the SMIL pseudocode
// places this condition earlier in the flow but that fails to allow
// for DOM calls when no "indefinite" condition is given), OR
// b) We never had any end instance times to begin with, OR
// c) We have end events which leave the interval open-ended.
bool openEndedIntervalOk = mEndSpecs.IsEmpty() ||
mEndInstances.IsEmpty() ||
EndHasEventConditions();
// The above conditions correspond with the SMIL pseudocode but SMIL
// doesn't address self-dependent instance times which we choose to
// ignore.
//
// Therefore we add a qualification of (b) above that even if
// there are end instance times but they all depend on the end of the
// current interval we should act as if they didn't exist and allow the
// open-ended interval.
//
// In the following condition we don't use |= because it doesn't provide
// short-circuit behavior.
openEndedIntervalOk =
openEndedIntervalOk ||
(aReplacedInterval &&
AreEndTimesDependentOn(aReplacedInterval->End()));
if (!openEndedIntervalOk) {
return false; // Bad interval
}
}
SMILTimeValue intervalEnd = tempEnd ? tempEnd->Time() : SMILTimeValue();
SMILTimeValue activeEnd = CalcActiveEnd(tempBegin->Time(), intervalEnd);
if (!tempEnd || intervalEnd != activeEnd) {
tempEnd = new SMILInstanceTime(activeEnd);
}
}
MOZ_ASSERT(tempEnd, "Failed to get end point for next interval");
// When we choose the interval endpoints, we don't allow coincident
// zero-duration intervals, so if we arrive here and we have a zero-duration
// interval starting at the same point as a previous zero-duration interval,
// then it must be because we've applied constraints to the active duration.
// In that case, we will potentially run into an infinite loop, so we break
// it by searching for the next interval that starts AFTER our current
// zero-duration interval.
if (prevIntervalWasZeroDur && tempEnd->Time() == beginAfter) {
beginAfter.SetMillis(tempBegin->Time().GetMillis() + 1);
prevIntervalWasZeroDur = false;
continue;
}
prevIntervalWasZeroDur = tempBegin->Time() == tempEnd->Time();
// Check for valid interval
if (tempEnd->Time() > zeroTime ||
(tempBegin->Time() == zeroTime && tempEnd->Time() == zeroTime)) {
aResult.Set(*tempBegin, *tempEnd);
return true;
}
if (mRestartMode == RESTART_NEVER) {
// tempEnd <= 0 so we're going to loop which effectively means restarting
return false;
}
beginAfter = tempEnd->Time();
}
MOZ_ASSERT_UNREACHABLE("Hmm... we really shouldn't be here");
return false;
}
SMILInstanceTime* SMILTimedElement::GetNextGreater(
const InstanceTimeList& aList, const SMILTimeValue& aBase,
int32_t& aPosition) const {
SMILInstanceTime* result = nullptr;
while ((result = GetNextGreaterOrEqual(aList, aBase, aPosition)) &&
result->Time() == aBase) {
}
return result;
}
SMILInstanceTime* SMILTimedElement::GetNextGreaterOrEqual(
const InstanceTimeList& aList, const SMILTimeValue& aBase,
int32_t& aPosition) const {
SMILInstanceTime* result = nullptr;
int32_t count = aList.Length();
for (; aPosition < count && !result; ++aPosition) {
SMILInstanceTime* val = aList[aPosition].get();
MOZ_ASSERT(val, "NULL instance time in list");
if (val->Time() >= aBase) {
result = val;
}
}
return result;
}
/**
* @see SMILANIM 3.3.4
*/
SMILTimeValue SMILTimedElement::CalcActiveEnd(const SMILTimeValue& aBegin,
const SMILTimeValue& aEnd) const {
SMILTimeValue result;
MOZ_ASSERT(mSimpleDur.IsResolved(),
"Unresolved simple duration in CalcActiveEnd");
MOZ_ASSERT(aBegin.IsDefinite(),
"Indefinite or unresolved begin time in CalcActiveEnd");
result = GetRepeatDuration();
if (aEnd.IsDefinite()) {
SMILTime