Fix AnimationBase::fractionalTime() to handle a scale of infinity

Source/core/page/animation/AnimationBase.cpp

 /*
  * Copyright (C) 2007, 2008, 2009 Apple Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  *
  * 1.  Redistributions of source code must retain the above copyright
  *     notice, this list of conditions and the following disclaimer.
  * 2.  Redistributions in binary form must reproduce the above copyright
@@ skipping 445 matching lines @@
     if (m_animation->iterationCount() != CSSAnimationData::IterationCountInfinite && !iterationCountHasFractional)
         integralTime = min(integralTime, integralIterationCount - 1);
 
     fractionalTime -= integralTime;
 
     if (((m_animation->direction() == CSSAnimationData::AnimationDirectionAlternate) && (integralTime & 1))
         || ((m_animation->direction() == CSSAnimationData::AnimationDirectionAlternateReverse) && !(integralTime & 1))
         || m_animation->direction() == CSSAnimationData::AnimationDirectionReverse)
         fractionalTime = 1 - fractionalTime;
 
-    if (scale != 1 || offset)
-        fractionalTime = (fractionalTime - offset) * scale;
+    if (offset)

[dstockwell, 2013/09/10 22:19:42]

I had a hard time understanding that the special case here is scale == infinity,
since the conditions don't explain that.

The code looks correct, but there might be a better way to write it. Some ideas:

if (std::isinf(scale)) {
  fractionalTime -= offset;
  ASSERT(fractionalTime == 0);
} else {
  ASSERT(scale >= 0);
  fractionalTime = (fractionalTime - offset) * scale;
}

Or even:
fractionalTime -= offset;
if (std::isinf(scale)) {
  ASSERT(fractionalTime == 0);
} else {
  ASSERT(scale >= 0);
  fractionalTime *= scale;
}

[Steve Block, 2013/09/11 00:11:52]

I guess I don't see scale == infinity as a special-case. We only need to apply
the scale if scale != 1.0 and fractionalTime != 0 (with offset already applied).
In this case, we can assert that the scale is finite. This seems the more
logical way to arrange the if statements, rather than testing scale. I'll add a
comment.

+        fractionalTime -= offset;
+    if (scale != 1.0 && fractionalTime) {
+        ASSERT(scale >= 0 && !std::isinf(scale));
+        fractionalTime *= scale;
+    }
 
+    ASSERT(fractionalTime >= 0 && fractionalTime <= 1);
     return fractionalTime;
 }
 
 double AnimationBase::progress(double scale, double offset, const TimingFunction* timingFunction) const
 {
     if (preActive())
         return 0;
 
     double dur = m_animation->duration();
     if (m_animation->iterationCount() > 0)
@@ skipping 93 matching lines @@
         return 0;
 
     double elapsedTime = beginAnimationUpdateTime() - m_startTime;
     // It's possible for the start time to be ahead of the last update time
     // if the compositor has just sent notification for the start of an
     // accelerated animation.
     return max(elapsedTime, 0.0);
 }
 
 } // namespace WebCore