Make AnimationEffectReadOnly.getComputedTiming() consistent with Web Animations spec

third_party/WebKit/Source/core/animation/AnimationEffect.cpp

 /*
  * Copyright (C) 2013 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 76 matching lines @@
 void AnimationEffect::updateSpecifiedTiming(const Timing& timing)
 {
     // FIXME: Test whether the timing is actually different?
     m_timing = timing;
     invalidate();
     if (m_animation)
         m_animation->setOutdated();
     specifiedTimingChanged();
 }
 
-void AnimationEffect::computedTiming(ComputedTimingProperties& computedTiming)
+void AnimationEffect::getComputedTiming(ComputedTimingProperties& computedTiming)
 {
     // ComputedTimingProperties members.
-    computedTiming.setStartTime(0);
     computedTiming.setEndTime(endTimeInternal() * 1000);
     computedTiming.setActiveDuration(activeDurationInternal() * 1000);
 
-    // FIXME: These should be null if not in effect, but current dictionary API
-    // will treat these as undefined.
     if (ensureCalculated().isInEffect) {
         computedTiming.setLocalTime(ensureCalculated().localTime * 1000);
-        computedTiming.setTimeFraction(ensureCalculated().timeFraction);
+        computedTiming.setProgress(ensureCalculated().progress);
         computedTiming.setCurrentIteration(ensureCalculated().currentIteration);
+    } else {
+        computedTiming.setLocalTimeToNull();
+        computedTiming.setProgressToNull();
+        computedTiming.setCurrentIterationToNull();
     }
 
     // KeyframeEffectOptions members.
     computedTiming.setDelay(specifiedTiming().startDelay * 1000);
     computedTiming.setEndDelay(specifiedTiming().endDelay * 1000);
     computedTiming.setFill(Timing::fillModeString(resolvedFillMode(specifiedTiming().fillMode, isKeyframeEffect())));
     computedTiming.setIterationStart(specifiedTiming().iterationStart);
     computedTiming.setIterations(specifiedTiming().iterationCount);
 
     UnrestrictedDoubleOrString duration;
     duration.setUnrestrictedDouble(iterationDuration() * 1000);
     computedTiming.setDuration(duration);
 
     computedTiming.setPlaybackRate(specifiedTiming().playbackRate);
     computedTiming.setDirection(Timing::playbackDirectionString(specifiedTiming().direction));
     computedTiming.setEasing(specifiedTiming().timingFunction->toString());
 }
 
-ComputedTimingProperties AnimationEffect::computedTiming()
+ComputedTimingProperties AnimationEffect::getComputedTiming()
 {
     ComputedTimingProperties result;
-    computedTiming(result);
+    getComputedTiming(result);
     return result;
 }
 
 
 void AnimationEffect::updateInheritedTime(double inheritedTime, TimingUpdateReason reason) const
 {
     bool needsUpdate = m_needsUpdate || (m_lastUpdateTime != inheritedTime && !(isNull(m_lastUpdateTime) && isNull(inheritedTime))) || (animation() && animation()->effectSuppressed());
     m_needsUpdate = false;
     m_lastUpdateTime = inheritedTime;
 
     const double localTime = inheritedTime;
     double timeToNextIteration = std::numeric_limits<double>::infinity();
     if (needsUpdate) {
         const double activeDuration = this->activeDurationInternal();
 
         const Phase currentPhase = calculatePhase(activeDuration, localTime, m_timing);
         // FIXME: parentPhase depends on groups being implemented.
         const AnimationEffect::Phase parentPhase = AnimationEffect::PhaseActive;
         const double activeTime = calculateActiveTime(activeDuration, resolvedFillMode(m_timing.fillMode, isKeyframeEffect()), localTime, parentPhase, currentPhase, m_timing);
 
         double currentIteration;
-        double timeFraction;
+        double progress;
         if (const double iterationDuration = this->iterationDuration()) {
             const double startOffset = multiplyZeroAlwaysGivesZero(m_timing.iterationStart, iterationDuration);
             ASSERT(startOffset >= 0);
             const double scaledActiveTime = calculateScaledActiveTime(activeDuration, activeTime, startOffset, m_timing);
             const double iterationTime = calculateIterationTime(iterationDuration, repeatedDuration(), scaledActiveTime, startOffset, m_timing);
 
             currentIteration = calculateCurrentIteration(iterationDuration, iterationTime, scaledActiveTime, m_timing);
             const double transformedTime = calculateTransformedTime(currentIteration, iterationDuration, iterationTime, m_timing);
 
             // The infinite iterationDuration case here is a workaround because
             // the specified behaviour does not handle infinite durations well.
             // There is an open issue against the spec to fix this:
             // https://github.com/w3c/web-animations/issues/142
             if (!std::isfinite(iterationDuration))
-                timeFraction = fmod(m_timing.iterationStart, 1.0);
+                progress = fmod(m_timing.iterationStart, 1.0);
             else
-                timeFraction = transformedTime / iterationDuration;
+                progress = transformedTime / iterationDuration;
 
             if (!isNull(iterationTime)) {
                 timeToNextIteration = (iterationDuration - iterationTime) / std::abs(m_timing.playbackRate);
                 if (activeDuration - activeTime < timeToNextIteration)
                     timeToNextIteration = std::numeric_limits<double>::infinity();
             }
         } else {
             const double localIterationDuration = 1;
             const double localRepeatedDuration = localIterationDuration * m_timing.iterationCount;
             ASSERT(localRepeatedDuration >= 0);
             const double localActiveDuration = m_timing.playbackRate ? localRepeatedDuration / std::abs(m_timing.playbackRate) : std::numeric_limits<double>::infinity();
             ASSERT(localActiveDuration >= 0);
             const double localLocalTime = localTime < m_timing.startDelay ? localTime : localActiveDuration + m_timing.startDelay;
             const AnimationEffect::Phase localCurrentPhase = calculatePhase(localActiveDuration, localLocalTime, m_timing);
             const double localActiveTime = calculateActiveTime(localActiveDuration, resolvedFillMode(m_timing.fillMode, isKeyframeEffect()), localLocalTime, parentPhase, localCurrentPhase, m_timing);
             const double startOffset = m_timing.iterationStart * localIterationDuration;
             ASSERT(startOffset >= 0);
             const double scaledActiveTime = calculateScaledActiveTime(localActiveDuration, localActiveTime, startOffset, m_timing);
             const double iterationTime = calculateIterationTime(localIterationDuration, localRepeatedDuration, scaledActiveTime, startOffset, m_timing);
 
             currentIteration = calculateCurrentIteration(localIterationDuration, iterationTime, scaledActiveTime, m_timing);
-            timeFraction = calculateTransformedTime(currentIteration, localIterationDuration, iterationTime, m_timing);
+            progress = calculateTransformedTime(currentIteration, localIterationDuration, iterationTime, m_timing);
         }
 
         m_calculated.currentIteration = currentIteration;
-        m_calculated.timeFraction = timeFraction;
+        m_calculated.progress = progress;
 
         m_calculated.phase = currentPhase;
         m_calculated.isInEffect = !isNull(activeTime);
         m_calculated.isInPlay = getPhase() == PhaseActive;
         m_calculated.isCurrent = getPhase() == PhaseBefore || isInPlay();
         m_calculated.localTime = m_lastUpdateTime;
     }
 
     // Test for events even if timing didn't need an update as the animation may have gained a start time.
     // FIXME: Refactor so that we can ASSERT(m_animation) here, this is currently required to be nullable for testing.
@@ skipping 25 matching lines @@
     return AnimationEffectTiming::create(this);
 }
 
 DEFINE_TRACE(AnimationEffect)
 {
     visitor->trace(m_animation);
     visitor->trace(m_eventDelegate);
 }
 
 } // namespace blink