Animations: Add the effect clipping primitive to web animations

Source/core/animation/Animation.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 64 matching lines @@
 
     return animation.release();
 }
 
 Animation::Animation(ExecutionContext* executionContext, AnimationTimeline& timeline, AnimationEffect* content)
     : ActiveDOMObject(executionContext)
     , m_playState(Idle)
     , m_playbackRate(1)
     , m_startTime(nullValue())
     , m_holdTime(0)
+    , m_startClip(-std::numeric_limits<double>::infinity())
+    , m_endClip(std::numeric_limits<double>::infinity())
     , m_sequenceNumber(nextSequenceNumber())
     , m_content(content)
     , m_timeline(&timeline)
     , m_paused(false)
     , m_held(true)
     , m_isPausedForTesting(false)
     , m_outdated(false)
     , m_finished(true)
     , m_compositorState(nullptr)
     , m_compositorPending(false)
@@ skipping 336 matching lines @@
 
     if (previousCurrentTime != newCurrentTime) {
         setOutdated();
     } else if (!hadStartTime && m_timeline) {
         // Even though this animation is not outdated, time to effect change is
         // infinity until start time is set.
         m_timeline->wake();
     }
 }
 
+bool Animation::clipped(double time)
+{
+    ASSERT(!isNull(time));
+    return time <= m_startClip || time > m_endClip + sourceEnd();
+}
+
 void Animation::setSource(AnimationEffect* newSource)
 {
     if (m_content == newSource)
         return;
     PlayStateUpdateScope updateScope(*this, TimingUpdateOnDemand, SetCompositorPendingWithSourceChanged);
 
     double storedCurrentTime = currentTimeInternal();
     if (m_content)
         m_content->detach();
     m_content = newSource;
@@ skipping 325 matching lines @@
 {
     if (!m_timeline)
         return false;
 
     PlayStateUpdateScope updateScope(*this, reason, DoNotSetCompositorPending);
 
     m_outdated = false;
     bool idle = playStateInternal() == Idle;
 
     if (m_content) {
-        double inheritedTime = idle || isNull(m_timeline->currentTimeInternal()) ? nullValue() : currentTimeInternal();
+        double inheritedTime = idle || isNull(m_timeline->currentTimeInternal())
+            ? nullValue()
+            : currentTimeInternal();
+
+        // When the animation is limited, is held but we need to use the calculated current time.
+        // When the start time is null, the held time needs to be used, which is in inherited time.
+        if (!isNull(inheritedTime) && clipped(m_held && (!limited(inheritedTime) || isNull(m_startTime)) ? inheritedTime : calculateCurrentTime()))

[dstockwell, 2015/06/04 01:32:06]

This might be better:

if (!isNull(inheritedTime)) {
  double timeForClipping = m_held && (!limited(inheritedTime) ||
isNull(m_startTime))
      // comment
      ? inheritedTime
      // other comment
      : calculateCurrentTime();
  if (clipped(timeForClipping))
    inheritedTime = nullValue();
}

[samli, 2015/06/09 01:23:53]

Done.

+            inheritedTime = nullValue();
         // Special case for end-exclusivity when playing backwards.
         if (inheritedTime == 0 && m_playbackRate < 0)
             inheritedTime = -1;

[dstockwell, 2015/06/04 01:32:06]

this probably breaks clipping when clipStart is between -1 and 0

[samli, 2015/06/09 01:23:53]

Yay, this isn't a problem.

         m_content->updateInheritedTime(inheritedTime, reason);
     }
 
     if ((idle || limited()) && !m_finished) {
         if (reason == TimingUpdateForAnimationFrame && (idle || hasStartTime())) {
             const AtomicString& eventType = EventTypeNames::finish;
             if (executionContext() && hasEventListeners(eventType)) {
                 double eventCurrentTime = currentTimeInternal() * 1000;
                 m_pendingFinishedEvent = AnimationPlayerEvent::create(eventType, eventCurrentTime, timeline()->currentTime());
                 m_pendingFinishedEvent->setTarget(this);
                 m_pendingFinishedEvent->setCurrentTarget(this);
                 m_timeline->document()->enqueueAnimationFrameEvent(m_pendingFinishedEvent);
             }
             m_finished = true;
         }
     }
     ASSERT(!m_outdated);
-    return !m_finished;
+    return !m_finished || std::isfinite(timeToEffectChange());
 }
 
 double Animation::timeToEffectChange()
 {
     ASSERT(!m_outdated);
-    if (m_held || !hasStartTime())
+    if (!hasStartTime())
         return std::numeric_limits<double>::infinity();
+
+    double currentTime = calculateCurrentTime();
+    if (m_held) {
+        if (limited(currentTime)) {
+            if (m_playbackRate > 0 && m_endClip + sourceEnd() > currentTime)
+                return m_endClip + sourceEnd() - currentTime;
+            if (m_playbackRate < 0 && m_startClip <= currentTime)
+                return m_startClip - currentTime;
+        }
+        return std::numeric_limits<double>::infinity();
+    }
+
     if (!m_content)
         return -currentTimeInternal() / m_playbackRate;
     double result = m_playbackRate > 0
         ? m_content->timeToForwardsEffectChange() / m_playbackRate
         : m_content->timeToReverseEffectChange() / -m_playbackRate;
+
     return !hasActiveAnimationsOnCompositor() && m_content->phase() == AnimationEffect::PhaseActive
         ? 0
-        : result;
+        : clipTimeToEffectChange(result);
+}
+
+double Animation::clipTimeToEffectChange(double result)

[dstockwell, 2015/06/04 01:32:06]

const?

[samli, 2015/06/09 01:23:53]

Done.

+{
+    double currentTime = calculateCurrentTime();
+    if (m_playbackRate > 0) {
+        if (currentTime <= m_startClip)
+            result = std::min(result, (m_startClip - currentTime) / m_playbackRate);
+        else if (currentTime < m_endClip + sourceEnd())
+            result = std::min(result, (m_endClip + sourceEnd() - currentTime) / m_playbackRate);

[dstockwell, 2015/06/04 01:32:06]

This might prevent firing the finish event.

[samli, 2015/06/09 01:23:53]

It shouldn't. This function always returns as smaller time than before since no
optimisations are made.

+    } else {
+        if (currentTime >= m_endClip + sourceEnd())
+            result = std::min(result, (currentTime - m_endClip + sourceEnd()) / -m_playbackRate);
+        else if (currentTime > m_startClip)
+            result = std::min(result, (currentTime - m_startClip) / -m_playbackRate);
+    }
+    return result;
 }
 
 void Animation::cancel()
 {
     PlayStateUpdateScope updateScope(*this, TimingUpdateOnDemand);
 
     if (playStateInternal() == Idle)
         return;
 
     m_holdTime = currentTimeInternal();
@@ skipping 190 matching lines @@
     visitor->trace(m_content);
     visitor->trace(m_timeline);
     visitor->trace(m_pendingFinishedEvent);
     visitor->trace(m_finishedPromise);
     visitor->trace(m_readyPromise);
     EventTargetWithInlineData::trace(visitor);
     ActiveDOMObject::trace(visitor);
 }
 
 } // namespace