The Tor Browser: dom/smil/nsSMILAnimationFunction.cpp@6474c204b198 (annotated)

dom/smil/nsSMILAnimationFunction.cpp@6474c204b198 (annotated)

dom/smil/nsSMILAnimationFunction.cpp

Wed, 31 Dec 2014 06:09:35 +0100

author: Michael Schloh von Bennewitz <michael@schloh.com>
date: Wed, 31 Dec 2014 06:09:35 +0100
changeset 0: 6474c204b198
permissions: -rw-r--r--

Cloned upstream origin tor-browser at tor-browser-31.3.0esr-4.5-1-build1
revision ID fc1c9ff7c1b2defdbc039f12214767608f46423f for hacking purpose.

 /* -*- 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/dom/SVGAnimationElement.h"
 #include "nsSMILAnimationFunction.h"
 #include "nsISMILAttr.h"
 #include "nsSMILParserUtils.h"
 #include "nsSMILNullType.h"
 #include "nsSMILTimedElement.h"
 #include "nsAttrValueInlines.h"
 #include "nsGkAtoms.h"
 #include "nsCOMPtr.h"
 #include "nsCOMArray.h"
 #include "nsIContent.h"
 #include "nsAutoPtr.h"
 #include "nsContentUtils.h"
 #include "nsReadableUtils.h"
 #include "nsString.h"
 #include <math.h>
 #include <algorithm>
 using namespace mozilla::dom;
 //----------------------------------------------------------------------
 // Static members
 nsAttrValue::EnumTable nsSMILAnimationFunction::sAccumulateTable[] = {
       {"none", false},
       {"sum", true},
       {nullptr, 0}
 };
 nsAttrValue::EnumTable nsSMILAnimationFunction::sAdditiveTable[] = {
       {"replace", false},
       {"sum", true},
       {nullptr, 0}
 };
 nsAttrValue::EnumTable nsSMILAnimationFunction::sCalcModeTable[] = {
       {"linear", CALC_LINEAR},
       {"discrete", CALC_DISCRETE},
       {"paced", CALC_PACED},
       {"spline", CALC_SPLINE},
       {nullptr, 0}
 };
 // Any negative number should be fine as a sentinel here,
 // because valid distances are non-negative.
 #define COMPUTE_DISTANCE_ERROR (-1)
 //----------------------------------------------------------------------
 // Constructors etc.
 nsSMILAnimationFunction::nsSMILAnimationFunction()
   : mSampleTime(-1),
     mRepeatIteration(0),
     mBeginTime(INT64_MIN),
     mAnimationElement(nullptr),
     mErrorFlags(0),
     mIsActive(false),
     mIsFrozen(false),
     mLastValue(false),
     mHasChanged(true),
     mValueNeedsReparsingEverySample(false),
     mPrevSampleWasSingleValueAnimation(false),
     mWasSkippedInPrevSample(false)
 {
 }
 void
 nsSMILAnimationFunction::SetAnimationElement(
     SVGAnimationElement* aAnimationElement)
 {
   mAnimationElement = aAnimationElement;
 }
 bool
 nsSMILAnimationFunction::SetAttr(nsIAtom* aAttribute, const nsAString& aValue,
                                  nsAttrValue& aResult, nsresult* aParseResult)
 {
   bool foundMatch = true;
   nsresult parseResult = NS_OK;
   // The attributes 'by', 'from', 'to', and 'values' may be parsed differently
   // depending on the element & attribute we're animating.  So instead of
   // parsing them now we re-parse them at every sample.
   if (aAttribute == nsGkAtoms::by ||
       aAttribute == nsGkAtoms::from ||
       aAttribute == nsGkAtoms::to ||
       aAttribute == nsGkAtoms::values) {
     // We parse to, from, by, values at sample time.
     // XXX Need to flag which attribute has changed and then when we parse it at
     // sample time, report any errors and reset the flag
     mHasChanged = true;
     aResult.SetTo(aValue);
   } else if (aAttribute == nsGkAtoms::accumulate) {
     parseResult = SetAccumulate(aValue, aResult);
   } else if (aAttribute == nsGkAtoms::additive) {
     parseResult = SetAdditive(aValue, aResult);
   } else if (aAttribute == nsGkAtoms::calcMode) {
     parseResult = SetCalcMode(aValue, aResult);
   } else if (aAttribute == nsGkAtoms::keyTimes) {
     parseResult = SetKeyTimes(aValue, aResult);
   } else if (aAttribute == nsGkAtoms::keySplines) {
     parseResult = SetKeySplines(aValue, aResult);
   } else {
     foundMatch = false;
   }
   if (foundMatch && aParseResult) {
     *aParseResult = parseResult;
   }
   return foundMatch;
 }
 bool
 nsSMILAnimationFunction::UnsetAttr(nsIAtom* aAttribute)
 {
   bool foundMatch = true;
   if (aAttribute == nsGkAtoms::by ||
       aAttribute == nsGkAtoms::from ||
       aAttribute == nsGkAtoms::to ||
       aAttribute == nsGkAtoms::values) {
     mHasChanged = true;
   } else if (aAttribute == nsGkAtoms::accumulate) {
     UnsetAccumulate();
   } else if (aAttribute == nsGkAtoms::additive) {
     UnsetAdditive();
   } else if (aAttribute == nsGkAtoms::calcMode) {
     UnsetCalcMode();
   } else if (aAttribute == nsGkAtoms::keyTimes) {
     UnsetKeyTimes();
   } else if (aAttribute == nsGkAtoms::keySplines) {
     UnsetKeySplines();
   } else {
     foundMatch = false;
   }
   return foundMatch;
 }
 void
 nsSMILAnimationFunction::SampleAt(nsSMILTime aSampleTime,
                                   const nsSMILTimeValue& aSimpleDuration,
                                   uint32_t aRepeatIteration)
 {
   // * Update mHasChanged ("Might this sample be different from prev one?")
   // Were we previously sampling a fill="freeze" final val? (We're not anymore.)
   mHasChanged |= mLastValue;
   // Are we sampling at a new point in simple duration? And does that matter?
   mHasChanged |=
     (mSampleTime != aSampleTime || mSimpleDuration != aSimpleDuration) &&
     !IsValueFixedForSimpleDuration();
   // Are we on a new repeat and accumulating across repeats?
   if (!mErrorFlags) { // (can't call GetAccumulate() if we've had parse errors)
     mHasChanged |= (mRepeatIteration != aRepeatIteration) && GetAccumulate();
   }
   mSampleTime       = aSampleTime;
   mSimpleDuration   = aSimpleDuration;
   mRepeatIteration  = aRepeatIteration;
   mLastValue        = false;
 }
 void
 nsSMILAnimationFunction::SampleLastValue(uint32_t aRepeatIteration)
 {
   if (mHasChanged || !mLastValue || mRepeatIteration != aRepeatIteration) {
     mHasChanged = true;
   }
   mRepeatIteration  = aRepeatIteration;
   mLastValue        = true;
 }
 void
 nsSMILAnimationFunction::Activate(nsSMILTime aBeginTime)
 {
   mBeginTime = aBeginTime;
   mIsActive = true;
   mIsFrozen = false;
   mHasChanged = true;
 }
 void
 nsSMILAnimationFunction::Inactivate(bool aIsFrozen)
 {
   mIsActive = false;
   mIsFrozen = aIsFrozen;
   mHasChanged = true;
 }
 void
 nsSMILAnimationFunction::ComposeResult(const nsISMILAttr& aSMILAttr,
                                        nsSMILValue& aResult)
 {
   mHasChanged = false;
   mPrevSampleWasSingleValueAnimation = false;
   mWasSkippedInPrevSample = false;
   // Skip animations that are inactive or in error
   if (!IsActiveOrFrozen() || mErrorFlags != 0)
     return;
   // Get the animation values
   nsSMILValueArray values;
   nsresult rv = GetValues(aSMILAttr, values);
   if (NS_FAILED(rv))
     return;
   // Check that we have the right number of keySplines and keyTimes
   CheckValueListDependentAttrs(values.Length());
   if (mErrorFlags != 0)
     return;
   // If this interval is active, we must have a non-negative mSampleTime
   NS_ABORT_IF_FALSE(mSampleTime >= 0 || !mIsActive,
       "Negative sample time for active animation");
   NS_ABORT_IF_FALSE(mSimpleDuration.IsResolved() || mLastValue,
       "Unresolved simple duration for active or frozen animation");
   // If we want to add but don't have a base value then just fail outright.
   // This can happen when we skipped getting the base value because there's an
   // animation function in the sandwich that should replace it but that function
   // failed unexpectedly.
   bool isAdditive = IsAdditive();
   if (isAdditive && aResult.IsNull())
     return;
   nsSMILValue result;
   if (values.Length() == 1 && !IsToAnimation()) {
     // Single-valued animation
     result = values[0];
     mPrevSampleWasSingleValueAnimation = true;
   } else if (mLastValue) {
     // Sampling last value
     const nsSMILValue& last = values[values.Length() - 1];
     result = last;
     // See comment in AccumulateResult: to-animation does not accumulate
     if (!IsToAnimation() && GetAccumulate() && mRepeatIteration) {
       // If the target attribute type doesn't support addition Add will
       // fail leaving result = last
       result.Add(last, mRepeatIteration);
     }
   } else {
     // Interpolation
     if (NS_FAILED(InterpolateResult(values, result, aResult)))
       return;
     if (NS_FAILED(AccumulateResult(values, result)))
       return;
   }
   // If additive animation isn't required or isn't supported, set the value.
   if (!isAdditive || NS_FAILED(aResult.SandwichAdd(result))) {
     aResult.Swap(result);
     // Note: The old value of aResult is now in |result|, and it will get
     // cleaned up when |result| goes out of scope, when this function returns.
   }
 }
 int8_t
 nsSMILAnimationFunction::CompareTo(const nsSMILAnimationFunction* aOther) const
 {
   NS_ENSURE_TRUE(aOther, 0);
   NS_ASSERTION(aOther != this, "Trying to compare to self");
   // Inactive animations sort first
   if (!IsActiveOrFrozen() && aOther->IsActiveOrFrozen())
     return -1;
   if (IsActiveOrFrozen() && !aOther->IsActiveOrFrozen())
     return 1;
   // Sort based on begin time
   if (mBeginTime != aOther->GetBeginTime())
     return mBeginTime > aOther->GetBeginTime() ? 1 : -1;
   // Next sort based on syncbase dependencies: the dependent element sorts after
   // its syncbase
   const nsSMILTimedElement& thisTimedElement =
     mAnimationElement->TimedElement();
   const nsSMILTimedElement& otherTimedElement =
     aOther->mAnimationElement->TimedElement();
   if (thisTimedElement.IsTimeDependent(otherTimedElement))
     return 1;
   if (otherTimedElement.IsTimeDependent(thisTimedElement))
     return -1;
   // Animations that appear later in the document sort after those earlier in
   // the document
   NS_ABORT_IF_FALSE(mAnimationElement != aOther->mAnimationElement,
       "Two animations cannot have the same animation content element!");
   return (nsContentUtils::PositionIsBefore(mAnimationElement, aOther->mAnimationElement))
           ? -1 : 1;
 }
 bool
 nsSMILAnimationFunction::WillReplace() const
 {
   /*
    * In IsAdditive() we don't consider to-animation to be additive as it is
    * a special case that is dealt with differently in the compositing method.
    * Here, however, we return FALSE for to-animation (i.e. it will NOT replace
    * the underlying value) as it builds on the underlying value.
    */
   return !mErrorFlags && !(IsAdditive() || IsToAnimation());
 }
 bool
 nsSMILAnimationFunction::HasChanged() const
 {
   return mHasChanged || mValueNeedsReparsingEverySample;
 }
 bool
 nsSMILAnimationFunction::UpdateCachedTarget(
   const nsSMILTargetIdentifier& aNewTarget)
 {
   if (!mLastTarget.Equals(aNewTarget)) {
     mLastTarget = aNewTarget;
     return true;
   }
   return false;
 }
 //----------------------------------------------------------------------
 // Implementation helpers
 nsresult
 nsSMILAnimationFunction::InterpolateResult(const nsSMILValueArray& aValues,
                                            nsSMILValue& aResult,
                                            nsSMILValue& aBaseValue)
 {
   // Sanity check animation values
   if ((!IsToAnimation() && aValues.Length() < 2) ||
       (IsToAnimation()  && aValues.Length() != 1)) {
     NS_ERROR("Unexpected number of values");
     return NS_ERROR_FAILURE;
   }
   if (IsToAnimation() && aBaseValue.IsNull()) {
     return NS_ERROR_FAILURE;
   }
   // Get the normalised progress through the simple duration.
   //
   // If we have an indefinite simple duration, just set the progress to be
   // 0 which will give us the expected behaviour of the animation being fixed at
   // its starting point.
   double simpleProgress = 0.0;
   if (mSimpleDuration.IsDefinite()) {
     nsSMILTime dur = mSimpleDuration.GetMillis();
     NS_ABORT_IF_FALSE(dur >= 0, "Simple duration should not be negative");
     NS_ABORT_IF_FALSE(mSampleTime >= 0, "Sample time should not be negative");
     if (mSampleTime >= dur || mSampleTime < 0) {
       NS_ERROR("Animation sampled outside interval");
       return NS_ERROR_FAILURE;
     }
     if (dur > 0) {
       simpleProgress = (double)mSampleTime / dur;
     } // else leave simpleProgress at 0.0 (e.g. if mSampleTime == dur == 0)
   }
   nsresult rv = NS_OK;
   nsSMILCalcMode calcMode = GetCalcMode();
   if (calcMode != CALC_DISCRETE) {
     // Get the normalised progress between adjacent values
     const nsSMILValue* from = nullptr;
     const nsSMILValue* to = nullptr;
     // Init to -1 to make sure that if we ever forget to set this, the
     // NS_ABORT_IF_FALSE that tests that intervalProgress is in range will fail.
     double intervalProgress = -1.f;
     if (IsToAnimation()) {
       from = &aBaseValue;
       to = &aValues[0];
       if (calcMode == CALC_PACED) {
         // Note: key[Times/Splines/Points] are ignored for calcMode="paced"
         intervalProgress = simpleProgress;
       } else {
         double scaledSimpleProgress =
           ScaleSimpleProgress(simpleProgress, calcMode);
         intervalProgress = ScaleIntervalProgress(scaledSimpleProgress, 0);
       }
     } else if (calcMode == CALC_PACED) {
       rv = ComputePacedPosition(aValues, simpleProgress,
                                 intervalProgress, from, to);
       // Note: If the above call fails, we'll skip the "from->Interpolate"
       // call below, and we'll drop into the CALC_DISCRETE section
       // instead. (as the spec says we should, because our failure was
       // presumably due to the values being non-additive)
     } else { // calcMode == CALC_LINEAR or calcMode == CALC_SPLINE
       double scaledSimpleProgress =
         ScaleSimpleProgress(simpleProgress, calcMode);
       uint32_t index = (uint32_t)floor(scaledSimpleProgress *
                                        (aValues.Length() - 1));
       from = &aValues[index];
       to = &aValues[index + 1];
       intervalProgress =
         scaledSimpleProgress * (aValues.Length() - 1) - index;
       intervalProgress = ScaleIntervalProgress(intervalProgress, index);
     }
     if (NS_SUCCEEDED(rv)) {
       NS_ABORT_IF_FALSE(from, "NULL from-value during interpolation");
       NS_ABORT_IF_FALSE(to, "NULL to-value during interpolation");
       NS_ABORT_IF_FALSE(0.0f <= intervalProgress && intervalProgress < 1.0f,
                       "Interval progress should be in the range [0, 1)");
       rv = from->Interpolate(*to, intervalProgress, aResult);
     }
   }
   // Discrete-CalcMode case
   // Note: If interpolation failed (isn't supported for this type), the SVG
   // spec says to force discrete mode.
   if (calcMode == CALC_DISCRETE || NS_FAILED(rv)) {
     double scaledSimpleProgress =
       ScaleSimpleProgress(simpleProgress, CALC_DISCRETE);
     // Floating-point errors can mean that, for example, a sample time of 29s in
     // a 100s duration animation gives us a simple progress of 0.28999999999
     // instead of the 0.29 we'd expect. Normally this isn't a noticeable
     // problem, but when we have sudden jumps in animation values (such as is
     // the case here with discrete animation) we can get unexpected results.
     //
     // To counteract this, before we perform a floor() on the animation
     // progress, we add a tiny fudge factor to push us into the correct interval
     // in cases where floating-point errors might cause us to fall short.
     static const double kFloatingPointFudgeFactor = 1.0e-16;
     if (scaledSimpleProgress + kFloatingPointFudgeFactor <= 1.0) {
       scaledSimpleProgress += kFloatingPointFudgeFactor;
     }
     if (IsToAnimation()) {
       // We don't follow SMIL 3, 12.6.4, where discrete to animations
       // are the same as <set> animations.  Instead, we treat it as a
       // discrete animation with two values (the underlying value and
       // the to="" value), and honor keyTimes="" as well.
       uint32_t index = (uint32_t)floor(scaledSimpleProgress * 2);
       aResult = index == 0 ? aBaseValue : aValues[0];
     } else {
       uint32_t index = (uint32_t)floor(scaledSimpleProgress * aValues.Length());
       aResult = aValues[index];
     }
     rv = NS_OK;
   }
   return rv;
 }
 nsresult
 nsSMILAnimationFunction::AccumulateResult(const nsSMILValueArray& aValues,
                                           nsSMILValue& aResult)
 {
   if (!IsToAnimation() && GetAccumulate() && mRepeatIteration) {
     const nsSMILValue& lastValue = aValues[aValues.Length() - 1];
     // If the target attribute type doesn't support addition, Add will
     // fail and we leave aResult untouched.
     aResult.Add(lastValue, mRepeatIteration);
   }
   return NS_OK;
 }
 /*
  * Given the simple progress for a paced animation, this method:
  *  - determines which two elements of the values array we're in between
  *    (returned as aFrom and aTo)
  *  - determines where we are between them
  *    (returned as aIntervalProgress)
  *
  * Returns NS_OK, or NS_ERROR_FAILURE if our values don't support distance
  * computation.
  */
 nsresult
 nsSMILAnimationFunction::ComputePacedPosition(const nsSMILValueArray& aValues,
                                               double aSimpleProgress,
                                               double& aIntervalProgress,
                                               const nsSMILValue*& aFrom,
                                               const nsSMILValue*& aTo)
 {
   NS_ASSERTION(0.0f <= aSimpleProgress && aSimpleProgress < 1.0f,
                "aSimpleProgress is out of bounds");
   NS_ASSERTION(GetCalcMode() == CALC_PACED,
                "Calling paced-specific function, but not in paced mode");
   NS_ABORT_IF_FALSE(aValues.Length() >= 2, "Unexpected number of values");
   // Trivial case: If we have just 2 values, then there's only one interval
   // for us to traverse, and our progress across that interval is the exact
   // same as our overall progress.
   if (aValues.Length() == 2) {
     aIntervalProgress = aSimpleProgress;
     aFrom = &aValues[0];
     aTo = &aValues[1];
     return NS_OK;
   }
   double totalDistance = ComputePacedTotalDistance(aValues);
   if (totalDistance == COMPUTE_DISTANCE_ERROR)
     return NS_ERROR_FAILURE;
   // If we have 0 total distance, then it's unclear where our "paced" position
   // should be.  We can just fail, which drops us into discrete animation mode.
   // (That's fine, since our values are apparently indistinguishable anyway.)
   if (totalDistance == 0.0) {
     return NS_ERROR_FAILURE;
   }
   // total distance we should have moved at this point in time.
   // (called 'remainingDist' due to how it's used in loop below)
   double remainingDist = aSimpleProgress * totalDistance;
   // Must be satisfied, because totalDistance is a sum of (non-negative)
   // distances, and aSimpleProgress is non-negative
   NS_ASSERTION(remainingDist >= 0, "distance values must be non-negative");
   // Find where remainingDist puts us in the list of values
   // Note: We could optimize this next loop by caching the
   // interval-distances in an array, but maybe that's excessive.
   for (uint32_t i = 0; i < aValues.Length() - 1; i++) {
     // Note: The following assertion is valid because remainingDist should
     // start out non-negative, and this loop never shaves off more than its
     // current value.
     NS_ASSERTION(remainingDist >= 0, "distance values must be non-negative");
     double curIntervalDist;
 #ifdef DEBUG
     nsresult rv =
 #endif
       aValues[i].ComputeDistance(aValues[i+1], curIntervalDist);
     NS_ABORT_IF_FALSE(NS_SUCCEEDED(rv),
                       "If we got through ComputePacedTotalDistance, we should "
                       "be able to recompute each sub-distance without errors");
     NS_ASSERTION(curIntervalDist >= 0, "distance values must be non-negative");
     // Clamp distance value at 0, just in case ComputeDistance is evil.
     curIntervalDist = std::max(curIntervalDist, 0.0);
     if (remainingDist >= curIntervalDist) {
       remainingDist -= curIntervalDist;
     } else {
       // NOTE: If we get here, then curIntervalDist necessarily is not 0. Why?
       // Because this clause is only hit when remainingDist < curIntervalDist,
       // and if curIntervalDist were 0, that would mean remainingDist would
       // have to be < 0.  But that can't happen, because remainingDist (as
       // a distance) is non-negative by definition.
       NS_ASSERTION(curIntervalDist != 0,
                    "We should never get here with this set to 0...");
       // We found the right spot -- an interpolated position between
       // values i and i+1.
       aFrom = &aValues[i];
       aTo = &aValues[i+1];
       aIntervalProgress = remainingDist / curIntervalDist;
       return NS_OK;
     }
   }
   NS_NOTREACHED("shouldn't complete loop & get here -- if we do, "
                 "then aSimpleProgress was probably out of bounds");
   return NS_ERROR_FAILURE;
 }
 /*
  * Computes the total distance to be travelled by a paced animation.
  *
  * Returns the total distance, or returns COMPUTE_DISTANCE_ERROR if
  * our values don't support distance computation.
  */
 double
 nsSMILAnimationFunction::ComputePacedTotalDistance(
     const nsSMILValueArray& aValues) const
 {
   NS_ASSERTION(GetCalcMode() == CALC_PACED,
                "Calling paced-specific function, but not in paced mode");
   double totalDistance = 0.0;
   for (uint32_t i = 0; i < aValues.Length() - 1; i++) {
     double tmpDist;
     nsresult rv = aValues[i].ComputeDistance(aValues[i+1], tmpDist);
     if (NS_FAILED(rv)) {
       return COMPUTE_DISTANCE_ERROR;
     }
     // Clamp distance value to 0, just in case we have an evil ComputeDistance
     // implementation somewhere
     NS_ABORT_IF_FALSE(tmpDist >= 0.0f, "distance values must be non-negative");
     tmpDist = std::max(tmpDist, 0.0);
     totalDistance += tmpDist;
   }
   return totalDistance;
 }
 double
 nsSMILAnimationFunction::ScaleSimpleProgress(double aProgress,
                                              nsSMILCalcMode aCalcMode)
 {
   if (!HasAttr(nsGkAtoms::keyTimes))
     return aProgress;
   uint32_t numTimes = mKeyTimes.Length();
   if (numTimes < 2)
     return aProgress;
   uint32_t i = 0;
   for (; i < numTimes - 2 && aProgress >= mKeyTimes[i+1]; ++i) { }
   if (aCalcMode == CALC_DISCRETE) {
     // discrete calcMode behaviour differs in that each keyTime defines the time
     // from when the corresponding value is set, and therefore the last value
     // needn't be 1. So check if we're in the last 'interval', that is, the
     // space between the final value and 1.0.
     if (aProgress >= mKeyTimes[i+1]) {
       NS_ABORT_IF_FALSE(i == numTimes - 2,
           "aProgress is not in range of the current interval, yet the current"
           " interval is not the last bounded interval either.");
       ++i;
     }
     return (double)i / numTimes;
   }
   double& intervalStart = mKeyTimes[i];
   double& intervalEnd   = mKeyTimes[i+1];
   double intervalLength = intervalEnd - intervalStart;
   if (intervalLength <= 0.0)
     return intervalStart;
   return (i + (aProgress - intervalStart) / intervalLength) /
          double(numTimes - 1);
 }
 double
 nsSMILAnimationFunction::ScaleIntervalProgress(double aProgress,
                                                uint32_t aIntervalIndex)
 {
   if (GetCalcMode() != CALC_SPLINE)
     return aProgress;
   if (!HasAttr(nsGkAtoms::keySplines))
     return aProgress;
   NS_ABORT_IF_FALSE(aIntervalIndex < mKeySplines.Length(),
                     "Invalid interval index");
   nsSMILKeySpline const &spline = mKeySplines[aIntervalIndex];
   return spline.GetSplineValue(aProgress);
 }
 bool
 nsSMILAnimationFunction::HasAttr(nsIAtom* aAttName) const
 {
   return mAnimationElement->HasAnimAttr(aAttName);
 }
 const nsAttrValue*
 nsSMILAnimationFunction::GetAttr(nsIAtom* aAttName) const
 {
   return mAnimationElement->GetAnimAttr(aAttName);
 }
 bool
 nsSMILAnimationFunction::GetAttr(nsIAtom* aAttName, nsAString& aResult) const
 {
   return mAnimationElement->GetAnimAttr(aAttName, aResult);
 }
 /*
  * A utility function to make querying an attribute that corresponds to an
  * nsSMILValue a little neater.
  *
  * @param aAttName    The attribute name (in the global namespace).
  * @param aSMILAttr   The SMIL attribute to perform the parsing.
  * @param[out] aResult        The resulting nsSMILValue.
  * @param[out] aPreventCachingOfSandwich
  *                    If |aResult| contains dependencies on its context that
  *                    should prevent the result of the animation sandwich from
  *                    being cached and reused in future samples (as reported
  *                    by nsISMILAttr::ValueFromString), then this outparam
  *                    will be set to true. Otherwise it is left unmodified.
  *
  * Returns false if a parse error occurred, otherwise returns true.
  */
 bool
 nsSMILAnimationFunction::ParseAttr(nsIAtom* aAttName,
                                    const nsISMILAttr& aSMILAttr,
                                    nsSMILValue& aResult,
                                    bool& aPreventCachingOfSandwich) const
 {
   nsAutoString attValue;
   if (GetAttr(aAttName, attValue)) {
     bool preventCachingOfSandwich = false;
     nsresult rv = aSMILAttr.ValueFromString(attValue, mAnimationElement,
                                             aResult, preventCachingOfSandwich);
     if (NS_FAILED(rv))
       return false;
     if (preventCachingOfSandwich) {
       aPreventCachingOfSandwich = true;
     }
   }
   return true;
 }
 /*
  * SMILANIM specifies the following rules for animation function values:
  *
  * (1) if values is set, it overrides everything
  * (2) for from/to/by animation at least to or by must be specified, from on its
  *     own (or nothing) is an error--which we will ignore
  * (3) if both by and to are specified only to will be used, by will be ignored
  * (4) if by is specified without from (by animation), forces additive behaviour
  * (5) if to is specified without from (to animation), special care needs to be
  *     taken when compositing animation as such animations are composited last.
  *
  * This helper method applies these rules to fill in the values list and to set
  * some internal state.
  */
 nsresult
 nsSMILAnimationFunction::GetValues(const nsISMILAttr& aSMILAttr,
                                    nsSMILValueArray& aResult)
 {
   if (!mAnimationElement)
     return NS_ERROR_FAILURE;
   mValueNeedsReparsingEverySample = false;
   nsSMILValueArray result;
   // If "values" is set, use it
   if (HasAttr(nsGkAtoms::values)) {
     nsAutoString attValue;
     GetAttr(nsGkAtoms::values, attValue);
     bool preventCachingOfSandwich = false;
     if (!nsSMILParserUtils::ParseValues(attValue, mAnimationElement,
                                         aSMILAttr, result,
                                         preventCachingOfSandwich)) {
       return NS_ERROR_FAILURE;
     }
     if (preventCachingOfSandwich) {
       mValueNeedsReparsingEverySample = true;
     }
   // Else try to/from/by
   } else {
     bool preventCachingOfSandwich = false;
     bool parseOk = true;
     nsSMILValue to, from, by;
     parseOk &= ParseAttr(nsGkAtoms::to,   aSMILAttr, to,
                          preventCachingOfSandwich);
     parseOk &= ParseAttr(nsGkAtoms::from, aSMILAttr, from,
                          preventCachingOfSandwich);
     parseOk &= ParseAttr(nsGkAtoms::by,   aSMILAttr, by,
                          preventCachingOfSandwich);
     if (preventCachingOfSandwich) {
       mValueNeedsReparsingEverySample = true;
     }
     if (!parseOk)
       return NS_ERROR_FAILURE;
     result.SetCapacity(2);
     if (!to.IsNull()) {
       if (!from.IsNull()) {
         result.AppendElement(from);
         result.AppendElement(to);
       } else {
         result.AppendElement(to);
       }
     } else if (!by.IsNull()) {
       nsSMILValue effectiveFrom(by.mType);
       if (!from.IsNull())
         effectiveFrom = from;
       // Set values to 'from; from + by'
       result.AppendElement(effectiveFrom);
       nsSMILValue effectiveTo(effectiveFrom);
       if (!effectiveTo.IsNull() && NS_SUCCEEDED(effectiveTo.Add(by))) {
         result.AppendElement(effectiveTo);
       } else {
         // Using by-animation with non-additive type or bad base-value
         return NS_ERROR_FAILURE;
       }
     } else {
       // No values, no to, no by -- call it a day
       return NS_ERROR_FAILURE;
     }
   }
   result.SwapElements(aResult);
   return NS_OK;
 }
 void
 nsSMILAnimationFunction::CheckValueListDependentAttrs(uint32_t aNumValues)
 {
   CheckKeyTimes(aNumValues);
   CheckKeySplines(aNumValues);
 }
 /**
  * Performs checks for the keyTimes attribute required by the SMIL spec but
  * which depend on other attributes and therefore needs to be updated as
  * dependent attributes are set.
  */
 void
 nsSMILAnimationFunction::CheckKeyTimes(uint32_t aNumValues)
 {
   if (!HasAttr(nsGkAtoms::keyTimes))
     return;
   nsSMILCalcMode calcMode = GetCalcMode();
   // attribute is ignored for calcMode = paced
   if (calcMode == CALC_PACED) {
     SetKeyTimesErrorFlag(false);
     return;
   }
   uint32_t numKeyTimes = mKeyTimes.Length();
   if (numKeyTimes < 1) {
     // keyTimes isn't set or failed preliminary checks
     SetKeyTimesErrorFlag(true);
     return;
   }
   // no. keyTimes == no. values
   // For to-animation the number of values is considered to be 2.
   bool matchingNumOfValues =
     numKeyTimes == (IsToAnimation() ? 2 : aNumValues);
   if (!matchingNumOfValues) {
     SetKeyTimesErrorFlag(true);
     return;
   }
   // first value must be 0
   if (mKeyTimes[0] != 0.0) {
     SetKeyTimesErrorFlag(true);
     return;
   }
   // last value must be 1 for linear or spline calcModes
   if (calcMode != CALC_DISCRETE && numKeyTimes > 1 &&
       mKeyTimes[numKeyTimes - 1] != 1.0) {
     SetKeyTimesErrorFlag(true);
     return;
   }
   SetKeyTimesErrorFlag(false);
 }
 void
 nsSMILAnimationFunction::CheckKeySplines(uint32_t aNumValues)
 {
   // attribute is ignored if calc mode is not spline
   if (GetCalcMode() != CALC_SPLINE) {
     SetKeySplinesErrorFlag(false);
     return;
   }
   // calc mode is spline but the attribute is not set
   if (!HasAttr(nsGkAtoms::keySplines)) {
     SetKeySplinesErrorFlag(false);
     return;
   }
   if (mKeySplines.Length() < 1) {
     // keyTimes isn't set or failed preliminary checks
     SetKeySplinesErrorFlag(true);
     return;
   }
   // ignore splines if there's only one value
   if (aNumValues == 1 && !IsToAnimation()) {
     SetKeySplinesErrorFlag(false);
     return;
   }
   // no. keySpline specs == no. values - 1
   uint32_t splineSpecs = mKeySplines.Length();
   if ((splineSpecs != aNumValues - 1 && !IsToAnimation()) ||
       (IsToAnimation() && splineSpecs != 1)) {
     SetKeySplinesErrorFlag(true);
     return;
   }
   SetKeySplinesErrorFlag(false);
 }
 bool
 nsSMILAnimationFunction::IsValueFixedForSimpleDuration() const
 {
   return mSimpleDuration.IsIndefinite() ||
     (!mHasChanged && mPrevSampleWasSingleValueAnimation);
 }
 //----------------------------------------------------------------------
 // Property getters
 bool
 nsSMILAnimationFunction::GetAccumulate() const
 {
   const nsAttrValue* value = GetAttr(nsGkAtoms::accumulate);
   if (!value)
     return false;
   return value->GetEnumValue();
 }
 bool
 nsSMILAnimationFunction::GetAdditive() const
 {
   const nsAttrValue* value = GetAttr(nsGkAtoms::additive);
   if (!value)
     return false;
   return value->GetEnumValue();
 }
 nsSMILAnimationFunction::nsSMILCalcMode
 nsSMILAnimationFunction::GetCalcMode() const
 {
   const nsAttrValue* value = GetAttr(nsGkAtoms::calcMode);
   if (!value)
     return CALC_LINEAR;
   return nsSMILCalcMode(value->GetEnumValue());
 }
 //----------------------------------------------------------------------
 // Property setters / un-setters:
 nsresult
 nsSMILAnimationFunction::SetAccumulate(const nsAString& aAccumulate,
                                        nsAttrValue& aResult)
 {
   mHasChanged = true;
   bool parseResult =
     aResult.ParseEnumValue(aAccumulate, sAccumulateTable, true);
   SetAccumulateErrorFlag(!parseResult);
   return parseResult ? NS_OK : NS_ERROR_FAILURE;
 }
 void
 nsSMILAnimationFunction::UnsetAccumulate()
 {
   SetAccumulateErrorFlag(false);
   mHasChanged = true;
 }
 nsresult
 nsSMILAnimationFunction::SetAdditive(const nsAString& aAdditive,
                                      nsAttrValue& aResult)
 {
   mHasChanged = true;
   bool parseResult
     = aResult.ParseEnumValue(aAdditive, sAdditiveTable, true);
   SetAdditiveErrorFlag(!parseResult);
   return parseResult ? NS_OK : NS_ERROR_FAILURE;
 }
 void
 nsSMILAnimationFunction::UnsetAdditive()
 {
   SetAdditiveErrorFlag(false);
   mHasChanged = true;
 }
 nsresult
 nsSMILAnimationFunction::SetCalcMode(const nsAString& aCalcMode,
                                      nsAttrValue& aResult)
 {
   mHasChanged = true;
   bool parseResult
     = aResult.ParseEnumValue(aCalcMode, sCalcModeTable, true);
   SetCalcModeErrorFlag(!parseResult);
   return parseResult ? NS_OK : NS_ERROR_FAILURE;
 }
 void
 nsSMILAnimationFunction::UnsetCalcMode()
 {
   SetCalcModeErrorFlag(false);
   mHasChanged = true;
 }
 nsresult
 nsSMILAnimationFunction::SetKeySplines(const nsAString& aKeySplines,
                                        nsAttrValue& aResult)
 {
   mKeySplines.Clear();
   aResult.SetTo(aKeySplines);
   mHasChanged = true;
   if (!nsSMILParserUtils::ParseKeySplines(aKeySplines, mKeySplines)) {
     mKeySplines.Clear();
     return NS_ERROR_FAILURE;
   }
   return NS_OK;
 }
 void
 nsSMILAnimationFunction::UnsetKeySplines()
 {
   mKeySplines.Clear();
   SetKeySplinesErrorFlag(false);
   mHasChanged = true;
 }
 nsresult
 nsSMILAnimationFunction::SetKeyTimes(const nsAString& aKeyTimes,
                                      nsAttrValue& aResult)
 {
   mKeyTimes.Clear();
   aResult.SetTo(aKeyTimes);
   mHasChanged = true;
   if (!nsSMILParserUtils::ParseSemicolonDelimitedProgressList(aKeyTimes, true,
                                                               mKeyTimes)) {
     mKeyTimes.Clear();
     return NS_ERROR_FAILURE;
   }
   return NS_OK;
 }
 void
 nsSMILAnimationFunction::UnsetKeyTimes()
 {
   mKeyTimes.Clear();
   SetKeyTimesErrorFlag(false);
   mHasChanged = true;
 }

The Tor Browser / annotate

dom/smil/nsSMILAnimationFunction.cpp@6474c204b198 (annotated)

dom/smil/nsSMILAnimationFunction.cpp