The Tor Browser / file revision

 /* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */

 /* 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 "mozilla/DebugOnly.h"

 #include "mozilla/BasicEvents.h"

 #include "mozilla/EventDispatcher.h"

 #include "mozilla/dom/SVGAnimationElement.h"

 #include "nsSMILTimedElement.h"

 #include "nsAttrValueInlines.h"

 #include "nsSMILAnimationFunction.h"

 #include "nsSMILTimeValue.h"

 #include "nsSMILTimeValueSpec.h"

 #include "nsSMILInstanceTime.h"

 #include "nsSMILParserUtils.h"

 #include "nsSMILTimeContainer.h"

 #include "nsGkAtoms.h"

 #include "nsReadableUtils.h"

 #include "nsMathUtils.h"

 #include "nsThreadUtils.h"

 #include "nsIPresShell.h"

 #include "prdtoa.h"

 #include "plstr.h"

 #include "prtime.h"

 #include "nsString.h"

 #include "mozilla/AutoRestore.h"

 #include "nsCharSeparatedTokenizer.h"

 #include <algorithm>

 using namespace mozilla;

 using namespace mozilla::dom;

 //----------------------------------------------------------------------

 // 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

 nsSMILTimedElement::InstanceTimeComparator::Equals(

     const nsSMILInstanceTime* aElem1,

     const nsSMILInstanceTime* aElem2) const

 {

   NS_ABORT_IF_FALSE(aElem1 && aElem2,

       "Trying to compare null instance time pointers");

   NS_ABORT_IF_FALSE(aElem1->Serial() && aElem2->Serial(),

       "Instance times have not been assigned serial numbers");

   NS_ABORT_IF_FALSE(aElem1 == aElem2 || aElem1->Serial() != aElem2->Serial(),

       "Serial numbers are not unique");

   return aElem1->Serial() == aElem2->Serial();

 }

 bool

 nsSMILTimedElement::InstanceTimeComparator::LessThan(

     const nsSMILInstanceTime* aElem1,

     const nsSMILInstanceTime* aElem2) const

 {

   NS_ABORT_IF_FALSE(aElem1 && aElem2,

       "Trying to compare null instance time pointers");

   NS_ABORT_IF_FALSE(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 nsRunnable

   {

   protected:

     nsRefPtr<nsIContent> mTarget;

     uint32_t             mMsg;

     int32_t              mDetail;

   public:

     AsyncTimeEventRunner(nsIContent* aTarget, uint32_t aMsg, int32_t aDetail)

       : mTarget(aTarget), mMsg(aMsg), mDetail(aDetail)

     {

     }

     NS_IMETHOD Run()

     {

       InternalUIEvent event(true, mMsg);

       event.eventStructType = NS_SMIL_TIME_EVENT;

       event.detail = mDetail;

       nsPresContext* context = nullptr;

       nsIDocument* doc = mTarget->GetCurrentDoc();

       if (doc) {

         nsCOMPtr<nsIPresShell> shell = doc->GetShell();

         if (shell) {

           context = shell->GetPresContext();

         }

       }

       return EventDispatcher::Dispatch(mTarget, context, &event);

     }

   };

 }

 //----------------------------------------------------------------------

 // Helper class: AutoIntervalUpdateBatcher

 // Stack-based helper class to set the mDeferIntervalUpdates flag on an

 // nsSMILTimedElement 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 nsSMILTimedElement is

 // destroyed.

 class MOZ_STACK_CLASS nsSMILTimedElement::AutoIntervalUpdateBatcher

 {

 public:

   AutoIntervalUpdateBatcher(nsSMILTimedElement& 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:

   nsSMILTimedElement& 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 nsSMILTimedElement::AutoIntervalUpdater

 {

 public:

   AutoIntervalUpdater(nsSMILTimedElement& aTimedElement)

     : mTimedElement(aTimedElement) { }

   ~AutoIntervalUpdater()

   {

     mTimedElement.UpdateCurrentInterval();

   }

 private:

   nsSMILTimedElement& mTimedElement;

 };

 //----------------------------------------------------------------------

 // Templated helper functions

 // Selectively remove elements from an array of type

 // nsTArray<nsRefPtr<nsSMILInstanceTime> > with O(n) performance.

 template <class TestFunctor>

 void

 nsSMILTimedElement::RemoveInstanceTimes(InstanceTimeList& aArray,

                                         TestFunctor& aTest)

 {

   InstanceTimeList newArray;

   for (uint32_t i = 0; i < aArray.Length(); ++i) {

     nsSMILInstanceTime* 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.

       NS_ABORT_IF_FALSE(!GetPreviousInterval() ||

         item != GetPreviousInterval()->End(),

         "Removing end instance time of previous interval");

       item->Unlink();

     } else {

       newArray.AppendElement(item);

     }

   }

   aArray.Clear();

   aArray.SwapElements(newArray);

 }

 //----------------------------------------------------------------------

 // Static members

 nsAttrValue::EnumTable nsSMILTimedElement::sFillModeTable[] = {

       {"remove", FILL_REMOVE},

       {"freeze", FILL_FREEZE},

       {nullptr, 0}

 };

 nsAttrValue::EnumTable nsSMILTimedElement::sRestartModeTable[] = {

       {"always", RESTART_ALWAYS},

       {"whenNotActive", RESTART_WHENNOTACTIVE},

       {"never", RESTART_NEVER},

       {nullptr, 0}

 };

 const nsSMILMilestone nsSMILTimedElement::sMaxMilestone(INT64_MAX, false);

 // The thresholds at which point we start filtering intervals and instance times

 // indiscriminately.

 // See FilterIntervals and FilterInstanceTimes.

 const uint8_t nsSMILTimedElement::sMaxNumIntervals = 20;

 const uint8_t nsSMILTimedElement::sMaxNumInstanceTimes = 100;

 // Detect if we arrive in some sort of undetected recursive syncbase dependency

 // relationship

 const uint8_t nsSMILTimedElement::sMaxUpdateIntervalRecursionDepth = 20;

 //----------------------------------------------------------------------

 // Ctor, dtor

 nsSMILTimedElement::nsSMILTimedElement()

 :

   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),

   mDeleteCount(0),

   mUpdateIntervalRecursionDepth(0)

 {

   mSimpleDur.SetIndefinite();

   mMin.SetMillis(0L);

   mMax.SetIndefinite();

 }

 nsSMILTimedElement::~nsSMILTimedElement()

 {

   // Unlink all instance times from dependent intervals

   for (uint32_t i = 0; i < mBeginInstances.Length(); ++i) {

     mBeginInstances[i]->Unlink();

   }

   mBeginInstances.Clear();

   for (uint32_t i = 0; i < mEndInstances.Length(); ++i) {

     mEndInstances[i]->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.

   NS_ABORT_IF_FALSE(!mDeferIntervalUpdates,

       "Interval updates should no longer be blocked when an nsSMILTimedElement "

       "disappears");

   NS_ABORT_IF_FALSE(!mDoDeferredUpdate,

       "There should no longer be any pending updates when an "

       "nsSMILTimedElement disappears");

 }

 void

 nsSMILTimedElement::SetAnimationElement(SVGAnimationElement* aElement)

 {

   NS_ABORT_IF_FALSE(aElement, "NULL owner element");

   NS_ABORT_IF_FALSE(!mAnimationElement, "Re-setting owner");

   mAnimationElement = aElement;

 }

 nsSMILTimeContainer*

 nsSMILTimedElement::GetTimeContainer()

 {

   return mAnimationElement ? mAnimationElement->GetTimeContainer() : nullptr;

 }

 dom::Element*

 nsSMILTimedElement::GetTargetElement()

 {

   return mAnimationElement ?

       mAnimationElement->GetTargetElementContent() :

       nullptr;

 }

 //----------------------------------------------------------------------

 // nsIDOMElementTimeControl 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:

 //

 // http://www.w3.org/2003/01/REC-SVG11-20030114-errata#elementtimecontrol-interface

 //

 // which favours the definition in SMIL, i.e. instance times are just added

 // without first checking the restart mode.

 nsresult

 nsSMILTimedElement::BeginElementAt(double aOffsetSeconds)

 {

   nsSMILTimeContainer* container = GetTimeContainer();

   if (!container)

     return NS_ERROR_FAILURE;

   nsSMILTime currentTime = container->GetCurrentTime();

   return AddInstanceTimeFromCurrentTime(currentTime, aOffsetSeconds, true);

 }

 nsresult

 nsSMILTimedElement::EndElementAt(double aOffsetSeconds)

 {

   nsSMILTimeContainer* container = GetTimeContainer();

   if (!container)

     return NS_ERROR_FAILURE;

   nsSMILTime currentTime = container->GetCurrentTime();

   return AddInstanceTimeFromCurrentTime(currentTime, aOffsetSeconds, false);

 }

 //----------------------------------------------------------------------

 // nsSVGAnimationElement methods

 nsSMILTimeValue

 nsSMILTimedElement::GetStartTime() const

 {

   return mElementState == STATE_WAITING || mElementState == STATE_ACTIVE

          ? mCurrentInterval->Begin()->Time()

          : nsSMILTimeValue();

 }

 //----------------------------------------------------------------------

 // Hyperlinking support

 nsSMILTimeValue

 nsSMILTimedElement::GetHyperlinkTime() const

 {

   nsSMILTimeValue hyperlinkTime; // Default ctor creates unresolved time

   if (mElementState == STATE_ACTIVE) {

     hyperlinkTime = mCurrentInterval->Begin()->Time();

   } else if (!mBeginInstances.IsEmpty()) {

     hyperlinkTime = mBeginInstances[0]->Time();

   }

   return hyperlinkTime;

 }

 //----------------------------------------------------------------------

 // nsSMILTimedElement

 void

 nsSMILTimedElement::AddInstanceTime(nsSMILInstanceTime* aInstanceTime,

                                     bool aIsBegin)

 {

   NS_ABORT_IF_FALSE(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

     NS_ABORT_IF_FALSE(!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;

   nsRefPtr<nsSMILInstanceTime>* inserted =

     instanceList.InsertElementSorted(aInstanceTime, InstanceTimeComparator());

   if (!inserted) {

     NS_WARNING("Insufficient memory to insert instance time");

     return;

   }

   UpdateCurrentInterval();

 }

 void

 nsSMILTimedElement::UpdateInstanceTime(nsSMILInstanceTime* aInstanceTime,

                                        nsSMILTimeValue& aUpdatedTime,

                                        bool aIsBegin)

 {

   NS_ABORT_IF_FALSE(aInstanceTime, "Attempting to update null instance time");

   // The reason we update the time here and not in the nsSMILTimeValueSpec 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

 nsSMILTimedElement::RemoveInstanceTime(nsSMILInstanceTime* aInstanceTime,

                                        bool aIsBegin)

 {

   NS_ABORT_IF_FALSE(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());

   NS_ABORT_IF_FALSE(found, "Couldn't find instance time to delete");

   UpdateCurrentInterval();

 }

 namespace

 {

   class MOZ_STACK_CLASS RemoveByCreator

   {

   public:

     RemoveByCreator(const nsSMILTimeValueSpec* aCreator) : mCreator(aCreator)

     { }

     bool operator()(nsSMILInstanceTime* 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 nsSMILTimeValueSpec* mCreator;

   };

 }

 void

 nsSMILTimedElement::RemoveInstanceTimesForCreator(

     const nsSMILTimeValueSpec* aCreator, bool aIsBegin)

 {

   NS_ABORT_IF_FALSE(aCreator, "Creator not set");

   InstanceTimeList& instances = aIsBegin ? mBeginInstances : mEndInstances;

   RemoveByCreator removeByCreator(aCreator);

   RemoveInstanceTimes(instances, removeByCreator);

   UpdateCurrentInterval();

 }

 void

 nsSMILTimedElement::SetTimeClient(nsSMILAnimationFunction* 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

 nsSMILTimedElement::SampleAt(nsSMILTime aContainerTime)

 {

   // Milestones are cleared before a sample

   mPrevRegisteredMilestone = sMaxMilestone;

   DoSampleAt(aContainerTime, false);

 }

 void

 nsSMILTimedElement::SampleEndAt(nsSMILTime aContainerTime)

 {

   // 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

 nsSMILTimedElement::DoSampleAt(nsSMILTime aContainerTime, bool aEndOnly)

 {

   NS_ABORT_IF_FALSE(mAnimationElement,

       "Got sample before being registered with an animation element");

   NS_ABORT_IF_FALSE(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(nsSMILTimeContainer::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;

   nsSMILTimeValue sampleTime(aContainerTime);

   do {

 #ifdef DEBUG

     // Check invariant

     if (mElementState == STATE_STARTUP || mElementState == STATE_POSTACTIVE) {

       NS_ABORT_IF_FALSE(!mCurrentInterval,

           "Shouldn't have current interval in startup or postactive states");

     } else {

       NS_ABORT_IF_FALSE(mCurrentInterval,

           "Should have current interval in waiting and active states");

     }

 #endif

     stateChanged = false;

     switch (mElementState)

     {

     case STATE_STARTUP:

       {

         nsSMILInterval firstInterval;

         mElementState = GetNextInterval(nullptr, nullptr, nullptr, firstInterval)

          ? STATE_WAITING

          : STATE_POSTACTIVE;

         stateChanged = true;

         if (mElementState == STATE_WAITING) {

           mCurrentInterval = new nsSMILInterval(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(NS_SMIL_BEGIN, 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) {

           nsSMILInterval newInterval;

           mElementState =

             GetNextInterval(mCurrentInterval, nullptr, nullptr, newInterval)

             ? STATE_WAITING

             : STATE_POSTACTIVE;

           if (mClient) {

             mClient->Inactivate(mFillMode == FILL_FREEZE);

           }

           mCurrentInterval->FixEnd();

           if (mSeekState == SEEK_NOT_SEEKING) {

             FireTimeEventAsync(NS_SMIL_END, 0);

           }

           mCurrentRepeatIteration = 0;

           mOldIntervals.AppendElement(mCurrentInterval.forget());

           SampleFillValue();

           if (mElementState == STATE_WAITING) {

             mCurrentInterval = new nsSMILInterval(newInterval);

           }

           // We are now in a consistent state to dispatch notifications

           if (didApplyEarlyEnd) {

             NotifyChangedInterval(

                 mOldIntervals[mOldIntervals.Length() - 1], false, true);

           }

           if (mElementState == STATE_WAITING) {

             NotifyNewInterval();

           }

           FilterHistory();

           stateChanged = true;

         } else {

           NS_ABORT_IF_FALSE(!didApplyEarlyEnd,

               "We got an early end, but didn't end");

           nsSMILTime beginTime = mCurrentInterval->Begin()->Time().GetMillis();

           NS_ASSERTION(aContainerTime >= beginTime,

                        "Sample time should not precede current interval");

           nsSMILTime 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() <= nsSMILTimeValue(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(NS_SMIL_REPEAT,

                             static_cast<int32_t>(mCurrentRepeatIteration));

             }

           }

         }

       }

       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

 nsSMILTimedElement::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 nsSMILTimeValueSpec 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, false, false);

   }

 }

 namespace

 {

   bool

   RemoveNonDynamic(nsSMILInstanceTime* aInstanceTime)

   {

     // Generally dynamically-generated instance times (DOM calls, event-based

     // times) are not associated with their creator nsSMILTimeValueSpec since

     // they may outlive them.

     NS_ABORT_IF_FALSE(!aInstanceTime->IsDynamic() ||

          !aInstanceTime->GetCreator(),

         "Dynamic instance time should be unlinked from its creator");

     return !aInstanceTime->IsDynamic() && !aInstanceTime->ShouldPreserve();

   }

 }

 void

 nsSMILTimedElement::Rewind()

 {

   NS_ABORT_IF_FALSE(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;

   }

   NS_ABORT_IF_FALSE(mSeekState == SEEK_BACKWARD_FROM_INACTIVE ||

                     mSeekState == SEEK_BACKWARD_FROM_ACTIVE,

                     "Rewind in the middle of a forwards seek?");

   // Putting us in the startup state will ensure we skip doing any interval

   // updates

   mElementState = STATE_STARTUP;

   ClearIntervals();

   UnsetBeginSpec(RemoveNonDynamic);

   UnsetEndSpec(RemoveNonDynamic);

   if (mClient) {

     mClient->Inactivate(false);

   }

   if (mAnimationElement->HasAnimAttr(nsGkAtoms::begin)) {

     nsAutoString attValue;

     mAnimationElement->GetAnimAttr(nsGkAtoms::begin, attValue);

     SetBeginSpec(attValue, mAnimationElement, RemoveNonDynamic);

   }

   if (mAnimationElement->HasAnimAttr(nsGkAtoms::end)) {

     nsAutoString attValue;

     mAnimationElement->GetAnimAttr(nsGkAtoms::end, attValue);

     SetEndSpec(attValue, mAnimationElement, RemoveNonDynamic);

   }

   mPrevRegisteredMilestone = sMaxMilestone;

   RegisterMilestone();

   NS_ABORT_IF_FALSE(!mCurrentInterval,

                     "Current interval is set at end of rewind");

 }

 namespace

 {

   bool

   RemoveNonDOM(nsSMILInstanceTime* aInstanceTime)

   {

     return !aInstanceTime->FromDOM() && !aInstanceTime->ShouldPreserve();

   }

 }

 bool

 nsSMILTimedElement::SetAttr(nsIAtom* aAttribute, const nsAString& aValue,

                             nsAttrValue& aResult,

                             Element* aContextNode,

                             nsresult* aParseResult)

 {

   bool foundMatch = true;

   nsresult parseResult = NS_OK;

   if (aAttribute == nsGkAtoms::begin) {

     parseResult = SetBeginSpec(aValue, aContextNode, RemoveNonDOM);

   } else if (aAttribute == nsGkAtoms::dur) {

     parseResult = SetSimpleDuration(aValue);

   } else if (aAttribute == nsGkAtoms::end) {

     parseResult = SetEndSpec(aValue, aContextNode, 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

 nsSMILTimedElement::UnsetAttr(nsIAtom* 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

 nsSMILTimedElement::SetBeginSpec(const nsAString& aBeginSpec,

                                  Element* aContextNode,

                                  RemovalTestFunction aRemove)

 {

   return SetBeginOrEndSpec(aBeginSpec, aContextNode, true /*isBegin*/,

                            aRemove);

 }

 void

 nsSMILTimedElement::UnsetBeginSpec(RemovalTestFunction aRemove)

 {

   ClearSpecs(mBeginSpecs, mBeginInstances, aRemove);

   UpdateCurrentInterval();

 }

 nsresult

 nsSMILTimedElement::SetEndSpec(const nsAString& aEndSpec,

                                Element* aContextNode,

                                RemovalTestFunction aRemove)

 {

   return SetBeginOrEndSpec(aEndSpec, aContextNode, false /*!isBegin*/,

                            aRemove);

 }

 void

 nsSMILTimedElement::UnsetEndSpec(RemovalTestFunction aRemove)

 {

   ClearSpecs(mEndSpecs, mEndInstances, aRemove);

   UpdateCurrentInterval();

 }

 nsresult

 nsSMILTimedElement::SetSimpleDuration(const nsAString& aDurSpec)

 {

   // Update the current interval before returning

   AutoIntervalUpdater updater(*this);

   nsSMILTimeValue duration;

   const nsAString& dur = nsSMILParserUtils::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 (!nsSMILParserUtils::ParseClockValue(dur, &duration) ||

         duration.GetMillis() == 0L) {

       mSimpleDur.SetIndefinite();

       return NS_ERROR_FAILURE;

     }

   }

   // mSimpleDur should never be unresolved. ParseClockValue will either set

   // duration to resolved or will return false.

   NS_ABORT_IF_FALSE(duration.IsResolved(),

     "Setting unresolved simple duration");

   mSimpleDur = duration;

   return NS_OK;

 }

 void

 nsSMILTimedElement::UnsetSimpleDuration()

 {

   mSimpleDur.SetIndefinite();

   UpdateCurrentInterval();

 }

 nsresult

 nsSMILTimedElement::SetMin(const nsAString& aMinSpec)

 {

   // Update the current interval before returning

   AutoIntervalUpdater updater(*this);

   nsSMILTimeValue duration;

   const nsAString& min = nsSMILParserUtils::TrimWhitespace(aMinSpec);

   if (min.EqualsLiteral("media")) {

     duration.SetMillis(0L);

   } else {

     if (!nsSMILParserUtils::ParseClockValue(min, &duration)) {

       mMin.SetMillis(0L);

       return NS_ERROR_FAILURE;

     }

   }

   NS_ABORT_IF_FALSE(duration.GetMillis() >= 0L, "Invalid duration");

   mMin = duration;

   return NS_OK;

 }

 void

 nsSMILTimedElement::UnsetMin()

 {

   mMin.SetMillis(0L);

   UpdateCurrentInterval();

 }

 nsresult

 nsSMILTimedElement::SetMax(const nsAString& aMaxSpec)

 {

   // Update the current interval before returning

   AutoIntervalUpdater updater(*this);

   nsSMILTimeValue duration;

   const nsAString& max = nsSMILParserUtils::TrimWhitespace(aMaxSpec);

   if (max.EqualsLiteral("media") || max.EqualsLiteral("indefinite")) {

     duration.SetIndefinite();

   } else {

     if (!nsSMILParserUtils::ParseClockValue(max, &duration) ||

         duration.GetMillis() == 0L) {

       mMax.SetIndefinite();

       return NS_ERROR_FAILURE;

     }

     NS_ABORT_IF_FALSE(duration.GetMillis() > 0L, "Invalid duration");

   }

   mMax = duration;

   return NS_OK;

 }

 void

 nsSMILTimedElement::UnsetMax()

 {

   mMax.SetIndefinite();

   UpdateCurrentInterval();

 }

 nsresult

 nsSMILTimedElement::SetRestart(const nsAString& aRestartSpec)

 {

   nsAttrValue temp;

   bool parseResult

     = temp.ParseEnumValue(aRestartSpec, sRestartModeTable, true);

   mRestartMode = parseResult

                ? nsSMILRestartMode(temp.GetEnumValue())

                : RESTART_ALWAYS;

   UpdateCurrentInterval();

   return parseResult ? NS_OK : NS_ERROR_FAILURE;

 }

 void

 nsSMILTimedElement::UnsetRestart()

 {

   mRestartMode = RESTART_ALWAYS;

   UpdateCurrentInterval();

 }

 nsresult

 nsSMILTimedElement::SetRepeatCount(const nsAString& aRepeatCountSpec)

 {

   // Update the current interval before returning

   AutoIntervalUpdater updater(*this);

   nsSMILRepeatCount newRepeatCount;

   if (nsSMILParserUtils::ParseRepeatCount(aRepeatCountSpec, newRepeatCount)) {

     mRepeatCount = newRepeatCount;

     return NS_OK;

   }

   mRepeatCount.Unset();

   return NS_ERROR_FAILURE;

 }

 void

 nsSMILTimedElement::UnsetRepeatCount()

 {

   mRepeatCount.Unset();

   UpdateCurrentInterval();

 }

 nsresult

 nsSMILTimedElement::SetRepeatDur(const nsAString& aRepeatDurSpec)

 {

   // Update the current interval before returning

   AutoIntervalUpdater updater(*this);

   nsSMILTimeValue duration;

   const nsAString& repeatDur =

     nsSMILParserUtils::TrimWhitespace(aRepeatDurSpec);

   if (repeatDur.EqualsLiteral("indefinite")) {

     duration.SetIndefinite();

   } else {

     if (!nsSMILParserUtils::ParseClockValue(repeatDur, &duration)) {

       mRepeatDur.SetUnresolved();

       return NS_ERROR_FAILURE;

     }

   }

   mRepeatDur = duration;

   return NS_OK;

 }

 void

 nsSMILTimedElement::UnsetRepeatDur()

 {

   mRepeatDur.SetUnresolved();

   UpdateCurrentInterval();

 }

 nsresult

 nsSMILTimedElement::SetFillMode(const nsAString& aFillModeSpec)

 {

   uint16_t previousFillMode = mFillMode;

   nsAttrValue temp;

   bool parseResult =

     temp.ParseEnumValue(aFillModeSpec, sFillModeTable, true);

   mFillMode = parseResult

             ? nsSMILFillMode(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

 nsSMILTimedElement::UnsetFillMode()

 {

   uint16_t previousFillMode = mFillMode;

   mFillMode = FILL_REMOVE;

   if (previousFillMode == FILL_FREEZE && HasClientInFillRange()) {

     mClient->Inactivate(false);

   }

 }

 void

 nsSMILTimedElement::AddDependent(nsSMILTimeValueSpec& aDependent)

 {

   // There's probably no harm in attempting to register a dependent

   // nsSMILTimeValueSpec twice, but we're not expecting it to happen.

   NS_ABORT_IF_FALSE(!mTimeDependents.GetEntry(&aDependent),

       "nsSMILTimeValueSpec 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

 nsSMILTimedElement::RemoveDependent(nsSMILTimeValueSpec& aDependent)

 {

   mTimeDependents.RemoveEntry(&aDependent);

 }

 bool

 nsSMILTimedElement::IsTimeDependent(const nsSMILTimedElement& aOther) const

 {

   const nsSMILInstanceTime* thisBegin = GetEffectiveBeginInstance();

   const nsSMILInstanceTime* otherBegin = aOther.GetEffectiveBeginInstance();

   if (!thisBegin || !otherBegin)

     return false;

   return thisBegin->IsDependentOn(*otherBegin);

 }

 void

 nsSMILTimedElement::BindToTree(nsIContent* aContextNode)

 {

   // 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

     uint32_t count = mBeginSpecs.Length();

     for (uint32_t i = 0; i < count; ++i) {

       mBeginSpecs[i]->ResolveReferences(aContextNode);

     }

     count = mEndSpecs.Length();

     for (uint32_t j = 0; j < count; ++j) {

       mEndSpecs[j]->ResolveReferences(aContextNode);

     }

   }

   RegisterMilestone();

 }

 void

 nsSMILTimedElement::HandleTargetElementChange(Element* aNewTarget)

 {

   AutoIntervalUpdateBatcher updateBatcher(*this);

   uint32_t count = mBeginSpecs.Length();

   for (uint32_t i = 0; i < count; ++i) {

     mBeginSpecs[i]->HandleTargetElementChange(aNewTarget);

   }

   count = mEndSpecs.Length();

   for (uint32_t j = 0; j < count; ++j) {

     mEndSpecs[j]->HandleTargetElementChange(aNewTarget);

   }

 }

 void

 nsSMILTimedElement::Traverse(nsCycleCollectionTraversalCallback* aCallback)

 {

   uint32_t count = mBeginSpecs.Length();

   for (uint32_t i = 0; i < count; ++i) {

     nsSMILTimeValueSpec* beginSpec = mBeginSpecs[i];

     NS_ABORT_IF_FALSE(beginSpec,

         "null nsSMILTimeValueSpec in list of begin specs");

     beginSpec->Traverse(aCallback);

   }

   count = mEndSpecs.Length();

   for (uint32_t j = 0; j < count; ++j) {

     nsSMILTimeValueSpec* endSpec = mEndSpecs[j];

     NS_ABORT_IF_FALSE(endSpec, "null nsSMILTimeValueSpec in list of end specs");

     endSpec->Traverse(aCallback);

   }

 }

 void

 nsSMILTimedElement::Unlink()

 {

   AutoIntervalUpdateBatcher updateBatcher(*this);

   // Remove dependencies on other elements

   uint32_t count = mBeginSpecs.Length();

   for (uint32_t i = 0; i < count; ++i) {

     nsSMILTimeValueSpec* beginSpec = mBeginSpecs[i];

     NS_ABORT_IF_FALSE(beginSpec,

         "null nsSMILTimeValueSpec in list of begin specs");

     beginSpec->Unlink();

   }

   count = mEndSpecs.Length();

   for (uint32_t j = 0; j < count; ++j) {

     nsSMILTimeValueSpec* endSpec = mEndSpecs[j];

     NS_ABORT_IF_FALSE(endSpec, "null nsSMILTimeValueSpec in list of end specs");

     endSpec->Unlink();

   }

   ClearIntervals();

   // Make sure we don't notify other elements of new intervals

   mTimeDependents.Clear();

 }

 //----------------------------------------------------------------------

 // Implementation helpers

 nsresult

 nsSMILTimedElement::SetBeginOrEndSpec(const nsAString& aSpec,

                                       Element* aContextNode,

                                       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;

   }

   nsresult rv = NS_OK;

   while (tokenizer.hasMoreTokens() && NS_SUCCEEDED(rv)) {

     nsAutoPtr<nsSMILTimeValueSpec>

       spec(new nsSMILTimeValueSpec(*this, aIsBegin));

     rv = spec->SetSpec(tokenizer.nextToken(), aContextNode);

     if (NS_SUCCEEDED(rv)) {

       timeSpecsList.AppendElement(spec.forget());

     }

   }

   if (NS_FAILED(rv)) {

     ClearSpecs(timeSpecsList, instances, aRemove);

   }

   return rv;

 }

 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:

     RemoveByFunction(nsSMILTimedElement::RemovalTestFunction aFunction)

       : mFunction(aFunction) { }

     bool operator()(nsSMILInstanceTime* aInstanceTime, uint32_t /*aIndex*/)

     {

       return mFunction(aInstanceTime);

     }

   private:

     nsSMILTimedElement::RemovalTestFunction mFunction;

   };

 }

 void

 nsSMILTimedElement::ClearSpecs(TimeValueSpecList& aSpecs,

                                InstanceTimeList& aInstances,

                                RemovalTestFunction aRemove)

 {

   AutoIntervalUpdateBatcher updateBatcher(*this);

   for (uint32_t i = 0; i < aSpecs.Length(); ++i) {

     aSpecs[i]->Unlink();

   }

   aSpecs.Clear();

   RemoveByFunction removeByFunction(aRemove);

   RemoveInstanceTimes(aInstances, removeByFunction);

 }

 void

 nsSMILTimedElement::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

 nsSMILTimedElement::ApplyEarlyEnd(const nsSMILTimeValue& aSampleTime)

 {

   // This should only be called within DoSampleAt as a helper function

   NS_ABORT_IF_FALSE(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) {

     nsSMILInstanceTime* 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.

         nsRefPtr<nsSMILInstanceTime> newEarlyEnd =

           new nsSMILInstanceTime(earlyEnd->Time());

         mCurrentInterval->SetEnd(*newEarlyEnd);

       } else {

         mCurrentInterval->SetEnd(*earlyEnd);

       }

       updated = true;

     }

   }

   return updated;

 }

 namespace

 {

   class MOZ_STACK_CLASS RemoveReset

   {

   public:

     RemoveReset(const nsSMILInstanceTime* aCurrentIntervalBegin)

       : mCurrentIntervalBegin(aCurrentIntervalBegin) { }

     bool operator()(nsSMILInstanceTime* 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 nsSMILInstanceTime* mCurrentIntervalBegin;

   };

 }

 void

 nsSMILTimedElement::Reset()

 {

   RemoveReset resetBegin(mCurrentInterval ? mCurrentInterval->Begin() : nullptr);

   RemoveInstanceTimes(mBeginInstances, resetBegin);

   RemoveReset resetEnd(nullptr);

   RemoveInstanceTimes(mEndInstances, resetEnd);

 }

 void

 nsSMILTimedElement::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(NS_SMIL_END, 0);

     }

     break;

   case SEEK_FORWARD_FROM_INACTIVE:

   case SEEK_BACKWARD_FROM_INACTIVE:

     if (mElementState == STATE_ACTIVE) {

       FireTimeEventAsync(NS_SMIL_BEGIN, 0);

     }

     break;

   case SEEK_NOT_SEEKING:

     /* Do nothing */

     break;

   }

   mSeekState = SEEK_NOT_SEEKING;

 }

 void

 nsSMILTimedElement::UnpreserveInstanceTimes(InstanceTimeList& aList)

 {

   const nsSMILInterval* prevInterval = GetPreviousInterval();

   const nsSMILInstanceTime* cutoff = mCurrentInterval ?

       mCurrentInterval->Begin() :

       prevInterval ? prevInterval->Begin() : nullptr;

   uint32_t count = aList.Length();

   for (uint32_t i = 0; i < count; ++i) {

     nsSMILInstanceTime* instance = aList[i].get();

     if (!cutoff || cutoff->Time().CompareTo(instance->Time()) < 0) {

       instance->UnmarkShouldPreserve();

     }

   }

 }

 void

 nsSMILTimedElement::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

 nsSMILTimedElement::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)

   {

     nsSMILInterval* 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(mOldIntervals[i].forget());

     }

   }

   mOldIntervals.Clear();

   mOldIntervals.SwapElements(filteredList);

 }

 namespace

 {

   class MOZ_STACK_CLASS RemoveFiltered

   {

   public:

     RemoveFiltered(nsSMILTimeValue aCutoff) : mCutoff(aCutoff) { }

     bool operator()(nsSMILInstanceTime* 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:

     nsSMILTimeValue mCutoff;

   };

   class MOZ_STACK_CLASS RemoveBelowThreshold

   {

   public:

     RemoveBelowThreshold(uint32_t aThreshold,

                          nsTArray<const nsSMILInstanceTime *>& aTimesToKeep)

       : mThreshold(aThreshold),

         mTimesToKeep(aTimesToKeep) { }

     bool operator()(nsSMILInstanceTime* aInstanceTime, uint32_t aIndex)

     {

       return aIndex < mThreshold && !mTimesToKeep.Contains(aInstanceTime);

     }

   private:

     uint32_t mThreshold;

     nsTArray<const nsSMILInstanceTime *>& mTimesToKeep;

   };

 }

 void

 nsSMILTimedElement::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 nsSMILInstanceTime *> timesToKeep;

     if (mCurrentInterval) {

       timesToKeep.AppendElement(mCurrentInterval->Begin());

     }

     const nsSMILInterval* 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:

 // http://www.w3.org/TR/2001/REC-smil-animation-20010904/#Timing-BeginEnd-LC-Start

 //

 bool

 nsSMILTimedElement::GetNextInterval(const nsSMILInterval* aPrevInterval,

                                     const nsSMILInterval* aReplacedInterval,

                                     const nsSMILInstanceTime* aFixedBeginTime,

                                     nsSMILInterval& aResult) const

 {

   NS_ABORT_IF_FALSE(!aFixedBeginTime || aFixedBeginTime->Time().IsDefinite(),

       "Unresolved or indefinite begin time specified for interval start");

   static const nsSMILTimeValue zeroTime(0L);

   if (mRestartMode == RESTART_NEVER && aPrevInterval)

     return false;

   // Calc starting point

   nsSMILTimeValue beginAfter;

   bool prevIntervalWasZeroDur = false;

   if (aPrevInterval) {

     beginAfter = aPrevInterval->End()->Time();

     prevIntervalWasZeroDur

       = aPrevInterval->End()->Time() == aPrevInterval->Begin()->Time();

   } else {

     beginAfter.SetMillis(INT64_MIN);

   }

   nsRefPtr<nsSMILInstanceTime> tempBegin;

   nsRefPtr<nsSMILInstanceTime> tempEnd;

   while (true) {

     // Calculate begin time

     if (aFixedBeginTime) {

       if (aFixedBeginTime->Time() < beginAfter) {

         return false;

       }

       // our ref-counting is not const-correct

       tempBegin = const_cast<nsSMILInstanceTime*>(aFixedBeginTime);

     } else if ((!mAnimationElement ||

                 !mAnimationElement->HasAnimAttr(nsGkAtoms::begin)) &&

                beginAfter <= zeroTime) {

       tempBegin = new nsSMILInstanceTime(nsSMILTimeValue(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());

     }

     NS_ABORT_IF_FALSE(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

         }

       }

       nsSMILTimeValue intervalEnd = tempEnd

                                   ? tempEnd->Time() : nsSMILTimeValue();

       nsSMILTimeValue activeEnd = CalcActiveEnd(tempBegin->Time(), intervalEnd);

       if (!tempEnd || intervalEnd != activeEnd) {

         tempEnd = new nsSMILInstanceTime(activeEnd);

       }

     }

     NS_ABORT_IF_FALSE(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) {

       if (prevIntervalWasZeroDur) {

         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();

   }

   NS_NOTREACHED("Hmm... we really shouldn't be here");

   return false;

 }

 nsSMILInstanceTime*

 nsSMILTimedElement::GetNextGreater(const InstanceTimeList& aList,

                                    const nsSMILTimeValue& aBase,

                                    int32_t& aPosition) const

 {

   nsSMILInstanceTime* result = nullptr;

   while ((result = GetNextGreaterOrEqual(aList, aBase, aPosition)) &&

          result->Time() == aBase) { }

   return result;

 }

 nsSMILInstanceTime*

 nsSMILTimedElement::GetNextGreaterOrEqual(const InstanceTimeList& aList,

                                           const nsSMILTimeValue& aBase,

                                           int32_t& aPosition) const

 {

   nsSMILInstanceTime* result = nullptr;

   int32_t count = aList.Length();

   for (; aPosition < count && !result; ++aPosition) {

     nsSMILInstanceTime* val = aList[aPosition].get();

     NS_ABORT_IF_FALSE(val, "NULL instance time in list");

     if (val->Time() >= aBase) {

       result = val;

     }

   }

   return result;

 }

 /**

  * @see SMILANIM 3.3.4

  */

 nsSMILTimeValue

 nsSMILTimedElement::CalcActiveEnd(const nsSMILTimeValue& aBegin,

                                   const nsSMILTimeValue& aEnd) const

 {

   nsSMILTimeValue result;

   NS_ABORT_IF_FALSE(mSimpleDur.IsResolved(),

     "Unresolved simple duration in CalcActiveEnd");

   NS_ABORT_IF_FALSE(aBegin.IsDefinite(),

     "Indefinite or unresolved begin time in CalcActiveEnd");

   result = GetRepeatDuration();

   if (aEnd.IsDefinite()) {

     nsSMILTime activeDur = aEnd.GetMillis() - aBegin.GetMillis();

     if (result.IsDefinite()) {

       result.SetMillis(std::min(result.GetMillis(), activeDur));

     } else {

       result.SetMillis(activeDur);

     }

   }

   result = ApplyMinAndMax(result);

   if (result.IsDefinite()) {

     nsSMILTime activeEnd = result.GetMillis() + aBegin.GetMillis();

     result.SetMillis(activeEnd);

   }

   return result;

 }

 nsSMILTimeValue

 nsSMILTimedElement::GetRepeatDuration() const

 {

   nsSMILTimeValue multipliedDuration;

   if (mRepeatCount.IsDefinite() && mSimpleDur.IsDefinite()) {

     multipliedDuration.SetMillis(

       nsSMILTime(mRepeatCount * double(mSimpleDur.GetMillis())));

   } else {

     multipliedDuration.SetIndefinite();

   }

   nsSMILTimeValue repeatDuration;

   if (mRepeatDur.IsResolved()) {

     repeatDuration = std::min(multipliedDuration, mRepeatDur);

   } else if (mRepeatCount.IsSet()) {

     repeatDuration = multipliedDuration;

   } else {

     repeatDuration = mSimpleDur;

   }

   return repeatDuration;

 }

 nsSMILTimeValue

 nsSMILTimedElement::ApplyMinAndMax(const nsSMILTimeValue& aDuration) const

 {

   if (!aDuration.IsResolved()) {

     return aDuration;

   }

   if (mMax < mMin) {

     return aDuration;

   }

   nsSMILTimeValue result;

   if (aDuration > mMax) {

     result = mMax;

   } else if (aDuration < mMin) {

     result = mMin;

   } else {

     result = aDuration;

   }

   return result;

 }

 nsSMILTime

 nsSMILTimedElement::ActiveTimeToSimpleTime(nsSMILTime aActiveTime,

                                            uint32_t& aRepeatIteration)

 {

   nsSMILTime result;

   NS_ABORT_IF_FALSE(mSimpleDur.IsResolved(),

       "Unresolved simple duration in ActiveTimeToSimpleTime");

   NS_ABORT_IF_FALSE(aActiveTime >= 0, "Expecting non-negative active time");

   // Note that a negative aActiveTime will give us a negative value for

   // aRepeatIteration, which is bad because aRepeatIteration is unsigned

   if (mSimpleDur.IsIndefinite() || mSimpleDur.GetMillis() == 0L) {

     aRepeatIteration = 0;

     result = aActiveTime;

   } else {

     result = aActiveTime % mSimpleDur.GetMillis();

     aRepeatIteration = (uint32_t)(aActiveTime / mSimpleDur.GetMillis());

   }

   return result;

 }

 //

 // Although in many cases it would be possible to check for an early end and

 // adjust the current interval well in advance the SMIL Animation spec seems to

 // indicate that we should only apply an early end at the latest possible

 // moment. In particular, this paragraph from section 3.6.8:

 //

 // 'If restart  is set to "always", then the current interval will end early if

 // there is an instance time in the begin list that is before (i.e. earlier

 // than) the defined end for the current interval. Ending in this manner will

 // also send a changed time notice to all time dependents for the current

 // interval end.'

 //

 nsSMILInstanceTime*

 nsSMILTimedElement::CheckForEarlyEnd(

     const nsSMILTimeValue& aContainerTime) const

 {

   NS_ABORT_IF_FALSE(mCurrentInterval,

       "Checking for an early end but the current interval is not set");

   if (mRestartMode != RESTART_ALWAYS)

     return nullptr;

   int32_t position = 0;

   nsSMILInstanceTime* nextBegin =

     GetNextGreater(mBeginInstances, mCurrentInterval->Begin()->Time(),

                    position);

   if (nextBegin &&

       nextBegin->Time() > mCurrentInterval->Begin()->Time() &&

       nextBegin->Time() < mCurrentInterval->End()->Time() &&

       nextBegin->Time() <= aContainerTime) {

     return nextBegin;

   }

   return nullptr;

 }

 void

 nsSMILTimedElement::UpdateCurrentInterval(bool aForceChangeNotice)

 {

   // Check if updates are currently blocked (batched)

   if (mDeferIntervalUpdates) {

     mDoDeferredUpdate = true;

     return;

   }

   // We adopt the convention of not resolving intervals until the first

   // sample. Otherwise, every time each attribute is set we'll re-resolve the

   // current interval and notify all our time dependents of the change.

   //

   // The disadvantage of deferring resolving the interval is that DOM calls to

   // to getStartTime will throw an INVALID_STATE_ERR exception until the

   // document timeline begins since the start time has not yet been resolved.

   if (mElementState == STATE_STARTUP)

     return;

   // Although SMIL gives rules for detecting cycles in change notifications,

   // some configurations can lead to create-delete-create-delete-etc. cycles

   // which SMIL does not consider.

   //

   // In order to provide consistent behavior in such cases, we detect two

   // deletes in a row and then refuse to create any further intervals. That is,

   // we say the configuration is invalid.

   if (mDeleteCount > 1) {

     // When we update the delete count we also set the state to post active, so

     // if we're not post active here then something other than

     // UpdateCurrentInterval has updated the element state in between and all

     // bets are off.

     NS_ABORT_IF_FALSE(mElementState == STATE_POSTACTIVE,

       "Expected to be in post-active state after performing double delete");

     return;

   }

   // Check that we aren't stuck in infinite recursion updating some syncbase

   // dependencies. Generally such situations should be detected in advance and

   // the chain broken in a sensible and predictable manner, so if we're hitting

   // this assertion we need to work out how to detect the case that's causing

   // it. In release builds, just bail out before we overflow the stack.

   AutoRestore<uint8_t> depthRestorer(mUpdateIntervalRecursionDepth);

   if (++mUpdateIntervalRecursionDepth > sMaxUpdateIntervalRecursionDepth) {

     NS_ABORT_IF_FALSE(false,

         "Update current interval recursion depth exceeded threshold");

     return;

   }

   // If the interval is active the begin time is fixed.

   const nsSMILInstanceTime* beginTime = mElementState == STATE_ACTIVE

                                       ? mCurrentInterval->Begin()

                                       : nullptr;

   nsSMILInterval updatedInterval;

   if (GetNextInterval(GetPreviousInterval(), mCurrentInterval,

                       beginTime, updatedInterval)) {

     if (mElementState == STATE_POSTACTIVE) {

       NS_ABORT_IF_FALSE(!mCurrentInterval,

           "In postactive state but the interval has been set");

       mCurrentInterval = new nsSMILInterval(updatedInterval);

       mElementState = STATE_WAITING;

       NotifyNewInterval();

     } else {

       bool beginChanged = false;

       bool endChanged   = false;

       if (mElementState != STATE_ACTIVE &&

           !updatedInterval.Begin()->SameTimeAndBase(

             *mCurrentInterval->Begin())) {

         mCurrentInterval->SetBegin(*updatedInterval.Begin());

         beginChanged = true;

       }

       if (!updatedInterval.End()->SameTimeAndBase(*mCurrentInterval->End())) {

         mCurrentInterval->SetEnd(*updatedInterval.End());

         endChanged = true;

       }

       if (beginChanged || endChanged || aForceChangeNotice) {

         NotifyChangedInterval(mCurrentInterval, beginChanged, endChanged);

       }

     }

     // There's a chance our next milestone has now changed, so update the time

     // container

     RegisterMilestone();

   } else { // GetNextInterval failed: Current interval is no longer valid

     if (mElementState == STATE_ACTIVE) {

       // The interval is active so we can't just delete it, instead trim it so

       // that begin==end.

       if (!mCurrentInterval->End()->SameTimeAndBase(*mCurrentInterval->Begin()))

       {

         mCurrentInterval->SetEnd(*mCurrentInterval->Begin());

         NotifyChangedInterval(mCurrentInterval, false, true);

       }

       // The transition to the postactive state will take place on the next

       // sample (along with firing end events, clearing intervals etc.)

       RegisterMilestone();

     } else if (mElementState == STATE_WAITING) {

       AutoRestore<uint8_t> deleteCountRestorer(mDeleteCount);

       ++mDeleteCount;

       mElementState = STATE_POSTACTIVE;

       ResetCurrentInterval();

     }

   }

 }

 void

 nsSMILTimedElement::SampleSimpleTime(nsSMILTime aActiveTime)

 {

   if (mClient) {

     uint32_t repeatIteration;

     nsSMILTime simpleTime =

       ActiveTimeToSimpleTime(aActiveTime, repeatIteration);

     mClient->SampleAt(simpleTime, mSimpleDur, repeatIteration);

   }

 }

 void

 nsSMILTimedElement::SampleFillValue()

 {

   if (mFillMode != FILL_FREEZE || !mClient)

     return;

   nsSMILTime activeTime;

   if (mElementState == STATE_WAITING || mElementState == STATE_POSTACTIVE) {

     const nsSMILInterval* prevInterval = GetPreviousInterval();

     NS_ABORT_IF_FALSE(prevInterval,

         "Attempting to sample fill value but there is no previous interval");

     NS_ABORT_IF_FALSE(prevInterval->End()->Time().IsDefinite() &&

         prevInterval->End()->IsFixedTime(),

         "Attempting to sample fill value but the endpoint of the previous "

         "interval is not resolved and fixed");

     activeTime = prevInterval->End()->Time().GetMillis() -

                  prevInterval->Begin()->Time().GetMillis();

     // If the interval's repeat duration was shorter than its active duration,

     // use the end of the repeat duration to determine the frozen animation's

     // state.

     nsSMILTimeValue repeatDuration = GetRepeatDuration();

     if (repeatDuration.IsDefinite()) {

       activeTime = std::min(repeatDuration.GetMillis(), activeTime);

     }

   } else {

     MOZ_ASSERT(mElementState == STATE_ACTIVE,

         "Attempting to sample fill value when we're in an unexpected state "

         "(probably STATE_STARTUP)");

     // If we are being asked to sample the fill value while active we *must*

     // have a repeat duration shorter than the active duration so use that.

     MOZ_ASSERT(GetRepeatDuration().IsDefinite(),

         "Attempting to sample fill value of an active animation with "

         "an indefinite repeat duration");

     activeTime = GetRepeatDuration().GetMillis();

   }

   uint32_t repeatIteration;

   nsSMILTime simpleTime =

     ActiveTimeToSimpleTime(activeTime, repeatIteration);

   if (simpleTime == 0L && repeatIteration) {

     mClient->SampleLastValue(--repeatIteration);

   } else {

     mClient->SampleAt(simpleTime, mSimpleDur, repeatIteration);

   }

 }

 nsresult

 nsSMILTimedElement::AddInstanceTimeFromCurrentTime(nsSMILTime aCurrentTime,

     double aOffsetSeconds, bool aIsBegin)

 {

   double offset = aOffsetSeconds * PR_MSEC_PER_SEC;

   // Check we won't overflow the range of nsSMILTime

   if (aCurrentTime + NS_round(offset) > INT64_MAX)

     return NS_ERROR_ILLEGAL_VALUE;

   nsSMILTimeValue timeVal(aCurrentTime + int64_t(NS_round(offset)));

   nsRefPtr<nsSMILInstanceTime> instanceTime =

     new nsSMILInstanceTime(timeVal, nsSMILInstanceTime::SOURCE_DOM);

   AddInstanceTime(instanceTime, aIsBegin);

   return NS_OK;

 }

 void

 nsSMILTimedElement::RegisterMilestone()

 {

   nsSMILTimeContainer* container = GetTimeContainer();

   if (!container)

     return;

   NS_ABORT_IF_FALSE(mAnimationElement,

       "Got a time container without an owning animation element");

   nsSMILMilestone nextMilestone;

   if (!GetNextMilestone(nextMilestone))

     return;

   // This method is called every time we might possibly have updated our

   // current interval, but since nsSMILTimeContainer makes no attempt to filter

   // out redundant milestones we do some rudimentary filtering here. It's not

   // perfect, but unnecessary samples are fairly cheap.

   if (nextMilestone >= mPrevRegisteredMilestone)

     return;

   container->AddMilestone(nextMilestone, *mAnimationElement);

   mPrevRegisteredMilestone = nextMilestone;

 }

 bool

 nsSMILTimedElement::GetNextMilestone(nsSMILMilestone& aNextMilestone) const

 {

   // Return the next key moment in our lifetime.

   //

   // XXX It may be possible in future to optimise this so that we only register

   // for milestones if:

   // a) We have time dependents, or

   // b) We are dependent on events or syncbase relationships, or

   // c) There are registered listeners for our events

   //

   // Then for the simple case where everything uses offset values we could

   // ignore milestones altogether.

   //

   // We'd need to be careful, however, that if one of those conditions became

   // true in between samples that we registered our next milestone at that

   // point.

   switch (mElementState)

   {

   case STATE_STARTUP:

     // All elements register for an initial end sample at t=0 where we resolve

     // our initial interval.

     aNextMilestone.mIsEnd = true; // Initial sample should be an end sample

     aNextMilestone.mTime = 0;

     return true;

   case STATE_WAITING:

     NS_ABORT_IF_FALSE(mCurrentInterval,

         "In waiting state but the current interval has not been set");

     aNextMilestone.mIsEnd = false;

     aNextMilestone.mTime = mCurrentInterval->Begin()->Time().GetMillis();

     return true;

   case STATE_ACTIVE:

     {

       // Work out what comes next: the interval end or the next repeat iteration

       nsSMILTimeValue nextRepeat;

       if (mSeekState == SEEK_NOT_SEEKING && mSimpleDur.IsDefinite()) {

         nsSMILTime nextRepeatActiveTime =

           (mCurrentRepeatIteration + 1) * mSimpleDur.GetMillis();

         // Check that the repeat fits within the repeat duration

         if (nsSMILTimeValue(nextRepeatActiveTime) < GetRepeatDuration()) {

           nextRepeat.SetMillis(mCurrentInterval->Begin()->Time().GetMillis() +

                                nextRepeatActiveTime);

         }

       }

       nsSMILTimeValue nextMilestone =

         std::min(mCurrentInterval->End()->Time(), nextRepeat);

       // Check for an early end before that time

       nsSMILInstanceTime* earlyEnd = CheckForEarlyEnd(nextMilestone);

       if (earlyEnd) {

         aNextMilestone.mIsEnd = true;

         aNextMilestone.mTime = earlyEnd->Time().GetMillis();

         return true;

       }

       // Apply the previously calculated milestone

       if (nextMilestone.IsDefinite()) {

         aNextMilestone.mIsEnd = nextMilestone != nextRepeat;

         aNextMilestone.mTime = nextMilestone.GetMillis();

         return true;

       }

       return false;

     }

   case STATE_POSTACTIVE:

     return false;

   }

   MOZ_CRASH("Invalid element state");

 }

 void

 nsSMILTimedElement::NotifyNewInterval()

 {

   NS_ABORT_IF_FALSE(mCurrentInterval,

       "Attempting to notify dependents of a new interval but the interval "

       "is not set");

   nsSMILTimeContainer* container = GetTimeContainer();

   if (container) {

     container->SyncPauseTime();

   }

   NotifyTimeDependentsParams params = { this, container };

   mTimeDependents.EnumerateEntries(NotifyNewIntervalCallback, &params);

 }

 void

 nsSMILTimedElement::NotifyChangedInterval(nsSMILInterval* aInterval,

                                           bool aBeginObjectChanged,

                                           bool aEndObjectChanged)

 {

   NS_ABORT_IF_FALSE(aInterval, "Null interval for change notification");

   nsSMILTimeContainer* container = GetTimeContainer();

   if (container) {

     container->SyncPauseTime();

   }

   // Copy the instance times list since notifying the instance times can result

   // in a chain reaction whereby our own interval gets deleted along with its

   // instance times.

   InstanceTimeList times;

   aInterval->GetDependentTimes(times);

   for (uint32_t i = 0; i < times.Length(); ++i) {

     times[i]->HandleChangedInterval(container, aBeginObjectChanged,

                                     aEndObjectChanged);

   }

 }

 void

 nsSMILTimedElement::FireTimeEventAsync(uint32_t aMsg, int32_t aDetail)

 {

   if (!mAnimationElement)

     return;

   nsCOMPtr<nsIRunnable> event =

     new AsyncTimeEventRunner(mAnimationElement, aMsg, aDetail);

   NS_DispatchToMainThread(event, NS_DISPATCH_NORMAL);

 }

 const nsSMILInstanceTime*

 nsSMILTimedElement::GetEffectiveBeginInstance() const

 {

   switch (mElementState)

   {

   case STATE_STARTUP:

     return nullptr;

   case STATE_ACTIVE:

     return mCurrentInterval->Begin();

   case STATE_WAITING:

   case STATE_POSTACTIVE:

     {

       const nsSMILInterval* prevInterval = GetPreviousInterval();

       return prevInterval ? prevInterval->Begin() : nullptr;

     }

   }

   MOZ_CRASH("Invalid element state");

 }

 const nsSMILInterval*

 nsSMILTimedElement::GetPreviousInterval() const

 {

   return mOldIntervals.IsEmpty()

     ? nullptr

     : mOldIntervals[mOldIntervals.Length()-1].get();

 }

 bool

 nsSMILTimedElement::HasClientInFillRange() const

 {

   // Returns true if we have a client that is in the range where it will fill

   return mClient &&

          ((mElementState != STATE_ACTIVE && HasPlayed()) ||

           (mElementState == STATE_ACTIVE && !mClient->IsActive()));

 }

 bool

 nsSMILTimedElement::EndHasEventConditions() const

 {

   for (uint32_t i = 0; i < mEndSpecs.Length(); ++i) {

     if (mEndSpecs[i]->IsEventBased())

       return true;

   }

   return false;

 }

 bool

 nsSMILTimedElement::AreEndTimesDependentOn(

   const nsSMILInstanceTime* aBase) const

 {

   if (mEndInstances.IsEmpty())

     return false;

   for (uint32_t i = 0; i < mEndInstances.Length(); ++i) {

     if (mEndInstances[i]->GetBaseTime() != aBase) {

       return false;

     }

   }

   return true;

 }

 //----------------------------------------------------------------------

 // Hashtable callback functions

 /* static */ PLDHashOperator

 nsSMILTimedElement::NotifyNewIntervalCallback(TimeValueSpecPtrKey* aKey,

                                               void* aData)

 {

   NS_ABORT_IF_FALSE(aKey, "Null hash key for time container hash table");

   NS_ABORT_IF_FALSE(aKey->GetKey(),

                     "null nsSMILTimeValueSpec in set of time dependents");

   NotifyTimeDependentsParams* params =

     static_cast<NotifyTimeDependentsParams*>(aData);

   NS_ABORT_IF_FALSE(params, "null data ptr while enumerating hashtable");

   nsSMILInterval* interval = params->mTimedElement->mCurrentInterval;

   // It's possible that in notifying one new time dependent of a new interval

   // that a chain reaction is triggered which results in the original interval

   // disappearing. If that's the case we can skip sending further notifications.

   if (!interval)

     return PL_DHASH_STOP;

   nsSMILTimeValueSpec* spec = aKey->GetKey();

   spec->HandleNewInterval(*interval, params->mTimeContainer);

   return PL_DHASH_NEXT;

 }