diff --git a/user/src/com/google/gwt/animation/Animation.gwt.xml b/user/src/com/google/gwt/animation/Animation.gwt.xml
index a34f63d..bc2a47c 100644
--- a/user/src/com/google/gwt/animation/Animation.gwt.xml
+++ b/user/src/com/google/gwt/animation/Animation.gwt.xml
@@ -18,7 +18,25 @@
 <!--                                                                        -->
 <module>
   <inherits name="com.google.gwt.core.Core"/>
+  <inherits name="com.google.gwt.user.UserAgent"/>
   
   <!-- Include User module to inherit Timer -->
   <inherits name="com.google.gwt.user.User"/>
+
+  <!-- Fallback implementation, based on a timer -->
+  <replace-with class="com.google.gwt.animation.client.AnimationSchedulerImplTimer">
+    <when-type-is class="com.google.gwt.animation.client.AnimationScheduler"/>
+  </replace-with>
+
+  <!-- Implementation based on mozRequestAnimationFrame -->
+  <replace-with class="com.google.gwt.animation.client.AnimationSchedulerImplMozilla">
+    <when-type-is class="com.google.gwt.animation.client.AnimationScheduler"/>
+    <when-property-is name="user.agent" value="gecko1_8"/>
+  </replace-with>
+
+  <!-- Implementation based on webkitRequestAnimationFrame -->
+  <replace-with class="com.google.gwt.animation.client.AnimationSchedulerImplWebkit">
+    <when-type-is class="com.google.gwt.animation.client.AnimationScheduler"/>
+    <when-property-is name="user.agent" value="safari"/>
+  </replace-with>
 </module>
diff --git a/user/src/com/google/gwt/animation/client/Animation.java b/user/src/com/google/gwt/animation/client/Animation.java
index f4225b2..cf3530e 100644
--- a/user/src/com/google/gwt/animation/client/Animation.java
+++ b/user/src/com/google/gwt/animation/client/Animation.java
@@ -15,56 +15,28 @@
  */
 package com.google.gwt.animation.client;
 
+import com.google.gwt.animation.client.AnimationScheduler.AnimationCallback;
+import com.google.gwt.animation.client.AnimationScheduler.AnimationHandle;
 import com.google.gwt.core.client.Duration;
-import com.google.gwt.user.client.Timer;
-
-import java.util.ArrayList;
-import java.util.List;
+import com.google.gwt.dom.client.Element;
 
 /**
  * An {@link Animation} is a continuous event that updates progressively over
  * time at a non-fixed frame rate.
  */
 public abstract class Animation {
-  /**
-   * The default time in milliseconds between frames.
-   */
-  private static final int DEFAULT_FRAME_DELAY = 25;
 
-  /**
-   * The {@link Animation Animations} that are currently in progress.
-   */
-  private static List<Animation> animations = null;
-
-  /**
-   * The {@link Timer} that applies the animations.
-   */
-  private static Timer animationTimer = null;
-
-  /**
-   * Update all {@link Animation Animations}.
-   */
-  private static void updateAnimations() {
-    // Duplicate the animations list in case it changes as we iterate over it
-    Animation[] curAnimations = new Animation[animations.size()];
-    curAnimations = animations.toArray(curAnimations);
-
-    // Iterator through the animations
-    double curTime = Duration.currentTimeMillis();
-    for (Animation animation : curAnimations) {
-      if (animation.running && animation.update(curTime)) {
-        // We can't just remove the animation at the index, because calling
-        // animation.update may have the side effect of canceling this
-        // animation, running new animations, or canceling other animations.
-        animations.remove(animation);
+  private final AnimationCallback callback = new AnimationCallback() {
+    @Override
+    public void execute(double timestamp) {
+      if (update(timestamp)) {
+        // Schedule the next animation frame.
+        requestHandle = scheduler.requestAnimationFrame(callback, element);
+      } else {
+        requestHandle = null;
       }
     }
-
-    // Reschedule the timer
-    if (animations.size() > 0) {
-      animationTimer.schedule(DEFAULT_FRAME_DELAY);
-    }
-  }
+  };
 
   /**
    * The duration of the {@link Animation} in milliseconds.
@@ -72,15 +44,32 @@
   private int duration = -1;
 
   /**
-   * Is the {@link Animation} running, even if {@link #onStart()} has not yet
-   * been called.
+   * The element being animated.
    */
-  private boolean running = false;
+  private Element element;
+
+  /**
+   * Is the animation running, even if it hasn't started yet.
+   */
+  private boolean isRunning = false;
 
   /**
    * Has the {@link Animation} actually started.
    */
-  private boolean started = false;
+  private boolean isStarted = false;
+
+  /**
+   * The ID of the pending animation request.
+   */
+  private AnimationHandle requestHandle;
+
+  /**
+   * The unique ID of the current run. Used to handle cases where an animation
+   * is restarted within an execution block.
+   */
+  private int runId = -1;
+
+  private final AnimationScheduler scheduler;
 
   /**
    * The start time of the {@link Animation}.
@@ -88,73 +77,126 @@
   private double startTime = -1;
 
   /**
+   * Did the animation start before {@link #cancel()} was called.
+   */
+  private boolean wasStarted = false;
+
+  /**
+   * Construct a new {@link Animation}.
+   */
+  public Animation() {
+    this(AnimationScheduler.get());
+  }
+
+  /**
+   * Construct a new {@link AnimationScheduler} using the specified scheduler to
+   * sheduler request frames.
+   * 
+   * @param scheduler an {@link AnimationScheduler} instance
+   */
+  protected Animation(AnimationScheduler scheduler) {
+    this.scheduler = scheduler;
+  }
+
+  /**
    * Immediately cancel this animation. If the animation is running or is
    * scheduled to run, {@link #onCancel()} will be called.
    */
   public void cancel() {
-    // Ignore if the animation is not currently running
-    if (!running) {
+    // Ignore if the animation is not currently running.
+    if (!isRunning) {
       return;
     }
 
-    animations.remove(this);
+    // Reset the state.
+    wasStarted = isStarted; // Used by onCancel.
+    element = null;
+    isRunning = false;
+    isStarted = false;
+
+    // Cancel the animation request.
+    if (requestHandle != null) {
+      requestHandle.cancel();
+      requestHandle = null;
+    }
+
     onCancel();
-    started = false;
-    running = false;
   }
 
   /**
    * Immediately run this animation. If the animation is already running, it
    * will be canceled first.
+   * <p>
+   * This is equivalent to <code>run(duration, null)</code>.
    * 
    * @param duration the duration of the animation in milliseconds
+   * @see #run(int, Element)
    */
   public void run(int duration) {
-    run(duration, Duration.currentTimeMillis());
+    run(duration, null);
+  }
+
+  /**
+   * Immediately run this animation. If the animation is already running, it
+   * will be canceled first.
+   * <p>
+   * If the element is not <code>null</code>, the {@link #onUpdate(double)}
+   * method might be called only if the element may be visible (generally left
+   * at the appreciation of the browser). Otherwise, it will be called
+   * unconditionally.
+   * 
+   * @param duration the duration of the animation in milliseconds
+   * @param element the element that visually bounds the entire animation
+   */
+  public void run(int duration, Element element) {
+    run(duration, Duration.currentTimeMillis(), element);
   }
 
   /**
    * Run this animation at the given startTime. If the startTime has already
-   * passed, the animation will be synchronize as if it started at the specified
-   * start time. If the animation is already running, it will be canceled first.
+   * passed, the animation will run synchronously as if it started at the
+   * specified start time. If the animation is already running, it will be
+   * canceled first.
+   * <p>
+   * This is equivalent to <code>run(duration, startTime, null)</code>.
    * 
    * @param duration the duration of the animation in milliseconds
    * @param startTime the synchronized start time in milliseconds
+   * @see #run(int, double, Element)
    */
   public void run(int duration, double startTime) {
+    run(duration, startTime, null);
+  }
+
+  /**
+   * Run this animation at the given startTime. If the startTime has already
+   * passed, the animation will run synchronously as if it started at the
+   * specified start time. If the animation is already running, it will be
+   * canceled first.
+   * <p>
+   * If the element is not <code>null</code>, the {@link #onUpdate(double)}
+   * method might be called only if the element may be visible (generally left
+   * at the appreciation of the browser). Otherwise, it will be called
+   * unconditionally.
+   * 
+   * @param duration the duration of the animation in milliseconds
+   * @param startTime the synchronized start time in milliseconds
+   * @param element the element that visually bounds the entire animation
+   */
+  public void run(int duration, double startTime, Element element) {
     // Cancel the animation if it is running
     cancel();
 
     // Save the duration and startTime
-    this.running = true;
+    isRunning = true;
+    isStarted = false;
     this.duration = duration;
     this.startTime = startTime;
+    this.element = element;
+    ++runId;
 
-    // Start synchronously if start time has passed
-    if (update(Duration.currentTimeMillis())) {
-      return;
-    }
-
-    // Add to the list of animations
-
-    // We use a static list of animations and a single timer, and create them
-    // only if we are the only active animation. This is safe since JS is
-    // single-threaded.
-    if (animations == null) {
-      animations = new ArrayList<Animation>();
-      animationTimer = new Timer() {
-        @Override
-        public void run() {
-          updateAnimations();
-        }
-      };
-    }
-    animations.add(this);
-
-    // Restart the timer if there is the only animation
-    if (animations.size() == 1) {
-      animationTimer.schedule(DEFAULT_FRAME_DELAY);
-    }
+    // Execute the first callback.
+    callback.execute(Duration.currentTimeMillis());
   }
 
   /**
@@ -176,7 +218,7 @@
    * animation has actually started running.
    */
   protected void onCancel() {
-    if (started) {
+    if (wasStarted) {
       onComplete();
     }
   }
@@ -208,32 +250,55 @@
   protected abstract void onUpdate(double progress);
 
   /**
+   * Check if the specified run ID is still being run.
+   * 
+   * @param curRunId the current run ID to check
+   * @return true if running, false if canceled or restarted
+   */
+  private boolean isRunning(int curRunId) {
+    return isRunning && (runId == curRunId);
+  }
+
+  /**
    * Update the {@link Animation}.
    * 
    * @param curTime the current time
-   * @return true if the animation is complete, false if still running
+   * @return true if the animation should run again, false if it is complete
    */
   private boolean update(double curTime) {
+    /*
+     * Save the run id. If the runId is incremented during this execution block,
+     * we know that this run has been canceled.
+     */
+    final int curRunId = runId;
+
     boolean finished = curTime >= startTime + duration;
-    if (started && !finished) {
+    if (isStarted && !finished) {
       // Animation is in progress.
       double progress = (curTime - startTime) / duration;
       onUpdate(interpolate(progress));
-      return false;
+      return isRunning(curRunId); // Check if this run was canceled.
     }
-    if (!started && curTime >= startTime) {
-      // Start the animation.
-      started = true;
+    if (!isStarted && curTime >= startTime) {
+      /*
+       * Start the animation. We do not call onUpdate() because onStart() calls
+       * onUpdate() by default.
+       */
+      isStarted = true;
       onStart();
+      if (!isRunning(curRunId)) {
+        // This run was canceled.
+        return false;
+      }
       // Intentional fall through to possibly end the animation.
     }
     if (finished) {
       // Animation is complete.
+      isRunning = false;
+      isStarted = false;
       onComplete();
-      started = false;
-      running = false;
-      return true;
+      return false;
     }
-    return false;
+    return true;
   }
 }
diff --git a/user/src/com/google/gwt/animation/client/AnimationScheduler.java b/user/src/com/google/gwt/animation/client/AnimationScheduler.java
new file mode 100644
index 0000000..1432ce8
--- /dev/null
+++ b/user/src/com/google/gwt/animation/client/AnimationScheduler.java
@@ -0,0 +1,102 @@
+/*
+ * Copyright 2011 Google Inc.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ * 
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+package com.google.gwt.animation.client;
+
+import com.google.gwt.dom.client.Element;
+
+/**
+ * This class provides task scheduling for animations. Any exceptions thrown by
+ * the command objects executed by the scheduler will be passed to the
+ * {@link com.google.gwt.core.client.GWT.UncaughtExceptionHandler} if one is
+ * installed.
+ */
+public abstract class AnimationScheduler {
+
+  /**
+   * The callback used when an animation frame becomes available.
+   */
+  public interface AnimationCallback {
+    /**
+     * Invokes the command.
+     * 
+     * @param timestamp the current timestamp
+     */
+    void execute(double timestamp);
+  }
+
+  /**
+   * A handle to the requested animation frame created by
+   * {@link #requestAnimationFrame(AnimationCallback, Element)}.
+   */
+  public abstract static class AnimationHandle {
+    /**
+     * Cancel the requested animation frame. If the animation frame is already
+     * canceled, do nothing.
+     */
+    public abstract void cancel();
+  }
+
+  /**
+   * Returns the default implementation of the AnimationScheduler API.
+   */
+  public static AnimationScheduler get() {
+    return AnimationSchedulerImpl.INSTANCE;
+  }
+
+  /**
+   * Schedule an animation, letting the browser decide when to trigger the next
+   * step in the animation.
+   * 
+   * <p>
+   * NOTE: If you are animating an element, use
+   * {@link #requestAnimationFrame(AnimationCallback, Element)} instead so the
+   * browser can optimize for the specified element.
+   * </p>
+   * 
+   * <p>
+   * Using this method instead of a timeout is preferred because the browser is
+   * in the best position to decide how frequently to trigger the callback for
+   * an animation of the specified element. The browser can balance multiple
+   * animations and trigger callbacks at the optimal rate for smooth
+   * performance.
+   * </p>
+   * 
+   * @param callback the callback to fire
+   * @return a handle to the requested animation frame
+   * @see #requestAnimationFrame(AnimationCallback, Element)
+   */
+  public AnimationHandle requestAnimationFrame(AnimationCallback callback) {
+    return requestAnimationFrame(callback, null);
+  }
+
+  /**
+   * Schedule an animation, letting the browser decide when to trigger the next
+   * step in the animation.
+   * 
+   * <p>
+   * Using this method instead of a timeout is preferred because the browser is
+   * in the best position to decide how frequently to trigger the callback for
+   * an animation of the specified element. The browser can balance multiple
+   * animations and trigger callbacks at the optimal rate for smooth
+   * performance.
+   * </p>
+   * 
+   * @param callback the callback to fire
+   * @return a handle to the requested animation frame
+   * @param element the element being animated
+   */
+  public abstract AnimationHandle requestAnimationFrame(AnimationCallback callback, Element element);
+}
diff --git a/user/src/com/google/gwt/animation/client/AnimationSchedulerImpl.java b/user/src/com/google/gwt/animation/client/AnimationSchedulerImpl.java
new file mode 100644
index 0000000..fc36fc9
--- /dev/null
+++ b/user/src/com/google/gwt/animation/client/AnimationSchedulerImpl.java
@@ -0,0 +1,55 @@
+/*
+ * Copyright 2011 Google Inc.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ * 
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+package com.google.gwt.animation.client;
+
+import com.google.gwt.core.client.GWT;
+
+/**
+ * Base class for animation implementations.
+ */
+abstract class AnimationSchedulerImpl extends AnimationScheduler {
+
+  /**
+   * The singleton instance of animation scheduler.
+   */
+  static final AnimationScheduler INSTANCE;
+
+  static {
+    AnimationScheduler impl = GWT.create(AnimationScheduler.class);
+
+    /*
+     * If the implementation isn't natively supported, revert back to the timer
+     * based implementation.
+     * 
+     * If impl==null (such as with GWTMockUitlities.disarm()), use null. We
+     * don't want to create a new AnimationSchedulerImplTimer in this case.
+     */
+    if (impl instanceof AnimationSchedulerImpl) {
+      if (!((AnimationSchedulerImpl) impl).isNativelySupported()) {
+        impl = new AnimationSchedulerImplTimer();
+      }
+    }
+
+    INSTANCE = impl;
+  }
+
+  /**
+   * Check if the implementation is natively supported.
+   * 
+   * @return true if natively supported, false if not
+   */
+  protected abstract boolean isNativelySupported();
+}
diff --git a/user/src/com/google/gwt/animation/client/AnimationSchedulerImplMozilla.java b/user/src/com/google/gwt/animation/client/AnimationSchedulerImplMozilla.java
new file mode 100644
index 0000000..68d4247
--- /dev/null
+++ b/user/src/com/google/gwt/animation/client/AnimationSchedulerImplMozilla.java
@@ -0,0 +1,74 @@
+/*
+ * Copyright 2011 Google Inc.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ * 
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+package com.google.gwt.animation.client;
+
+import com.google.gwt.dom.client.Element;
+
+/**
+ * Implementation using <code>mozRequestAnimationFrame</code>.
+ * 
+ * @see <a
+ *      href="https://developer.mozilla.org/en/DOM/window.mozRequestAnimationFrame">
+ *      Documentation on the MDN</a>
+ */
+class AnimationSchedulerImplMozilla extends AnimationSchedulerImpl {
+
+  /**
+   * Mozilla implementation of {@link AnimationScheduler.AnimationHandle}.
+   * Mozilla does not provide a request ID, so we mark a boolean in the handle
+   * and check it in the callback wrapper.
+   */
+  private class AnimationHandleImpl extends AnimationHandle {
+    @SuppressWarnings("unused")
+    private boolean canceled;
+
+    @Override
+    public void cancel() {
+      canceled = true;
+    }
+  }
+
+  @Override
+  public AnimationHandle requestAnimationFrame(AnimationCallback callback, Element element) {
+    AnimationHandleImpl handle = new AnimationHandleImpl();
+    requestAnimationFrameImpl(callback, handle);
+    return handle;
+  }
+
+  @Override
+  protected native boolean isNativelySupported() /*-{
+    return !!$wnd.mozRequestAnimationFrame;
+  }-*/;
+
+  /**
+   * Request an animation frame. Firefox does not return a request ID, so we
+   * create a JavaScriptObject and add an expando named "canceled" to inidicate
+   * if the request was canceled. The callback wrapper checks the expando before
+   * executing the user callback.
+   * 
+   * @param callback the user callback to execute
+   * @param handle the handle object
+   */
+  private native void requestAnimationFrameImpl(AnimationCallback callback,
+      AnimationHandleImpl handle) /*-{
+    var wrapper = $entry(function(time) {
+      if (!handle.@com.google.gwt.animation.client.AnimationSchedulerImplMozilla.AnimationHandleImpl::canceled) {
+        callback.@com.google.gwt.animation.client.AnimationScheduler.AnimationCallback::execute(D)(time);
+      }
+    });
+    $wnd.mozRequestAnimationFrame(wrapper);
+  }-*/;
+}
diff --git a/user/src/com/google/gwt/animation/client/AnimationSchedulerImplTimer.java b/user/src/com/google/gwt/animation/client/AnimationSchedulerImplTimer.java
new file mode 100644
index 0000000..ef2ef05
--- /dev/null
+++ b/user/src/com/google/gwt/animation/client/AnimationSchedulerImplTimer.java
@@ -0,0 +1,135 @@
+/*
+ * Copyright 2011 Google Inc.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ * 
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+package com.google.gwt.animation.client;
+
+import com.google.gwt.core.client.Duration;
+import com.google.gwt.dom.client.Element;
+import com.google.gwt.user.client.Timer;
+
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * Implementation using a timer for browsers that do not support animation
+ * frames.
+ */
+class AnimationSchedulerImplTimer extends AnimationSchedulerImpl {
+
+  /**
+   * Timer based implementation of {@link AnimationScheduler.AnimationHandle}.
+   */
+  private class AnimationHandleImpl extends AnimationHandle {
+    private final AnimationCallback callback;
+
+    public AnimationHandleImpl(AnimationCallback callback) {
+      this.callback = callback;
+    }
+
+    @Override
+    public void cancel() {
+      cancelAnimationFrame(this);
+    }
+
+    public AnimationCallback getCallback() {
+      return callback;
+    }
+  }
+
+  /**
+   * The default time in milliseconds between frames. 60 fps == 16.67 ms.
+   */
+  private static final int DEFAULT_FRAME_DELAY = 16;
+
+  /**
+   * The minimum delay in milliseconds between frames. The minimum delay is
+   * imposed to prevent freezing the UI.
+   */
+  private static final int MIN_FRAME_DELAY = 5;
+
+  /**
+   * The list of animations that are currently running.
+   */
+  private final List<AnimationHandleImpl> animationRequests = new ArrayList<AnimationHandleImpl>();
+
+  /**
+   * The singleton timer that updates all animations.
+   */
+  private final Timer timer = new Timer() {
+    @Override
+    public void run() {
+      updateAnimations();
+    }
+  };
+
+  @Override
+  public AnimationHandle requestAnimationFrame(final AnimationCallback callback, Element element) {
+    // Save the animation frame request.
+    AnimationHandleImpl requestId = new AnimationHandleImpl(callback);
+    animationRequests.add(requestId);
+
+    // Start the timer if it isn't started.
+    if (animationRequests.size() == 1) {
+      timer.schedule(DEFAULT_FRAME_DELAY);
+    }
+
+    // Return the request id.
+    return requestId;
+  }
+
+  @Override
+  protected boolean isNativelySupported() {
+    return true;
+  }
+
+  private void cancelAnimationFrame(AnimationHandle requestId) {
+    // Remove the request from the list.
+    animationRequests.remove(requestId);
+
+    // Stop the timer if there are no more requests.
+    if (animationRequests.size() == 0) {
+      timer.cancel();
+    }
+  }
+
+  /**
+   * Iterate over all animations and update them.
+   */
+  private void updateAnimations() {
+    // Copy the animation requests to avoid concurrent modifications.
+    AnimationHandleImpl[] curAnimations = new AnimationHandleImpl[animationRequests.size()];
+    curAnimations = animationRequests.toArray(curAnimations);
+
+    // Iterate over the animation requests.
+    Duration duration = new Duration();
+    for (AnimationHandleImpl requestId : curAnimations) {
+      // Remove the current request.
+      animationRequests.remove(requestId);
+
+      // Execute the callback.
+      requestId.getCallback().execute(duration.getStartMillis());
+    }
+
+    // Reschedule the timer if there are more animation requests.
+    if (animationRequests.size() > 0) {
+      /*
+       * In order to achieve as close to 60fps as possible, we calculate the new
+       * delay based on the execution time of this method. The delay will be
+       * less than 16ms, assuming this method takes more than 1ms to complete.
+       */
+      timer.schedule(Math.max(MIN_FRAME_DELAY, DEFAULT_FRAME_DELAY - duration.elapsedMillis()));
+    }
+  }
+}
diff --git a/user/src/com/google/gwt/animation/client/AnimationSchedulerImplWebkit.java b/user/src/com/google/gwt/animation/client/AnimationSchedulerImplWebkit.java
new file mode 100644
index 0000000..82e8b36
--- /dev/null
+++ b/user/src/com/google/gwt/animation/client/AnimationSchedulerImplWebkit.java
@@ -0,0 +1,73 @@
+/*
+ * Copyright 2011 Google Inc.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ * 
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+package com.google.gwt.animation.client;
+
+import com.google.gwt.dom.client.Element;
+
+/**
+ * Implementation using <code>webkitRequestAnimationFrame</code> and
+ * <code>webkitCancelRequestAnimationFrame</code>.
+ * 
+ * @see <a
+ *      href="http://www.chromium.org/developers/web-platform-status#TOC-requestAnimationFrame">
+ *      Chromium Web Platform Status</a>
+ * @see <a href="http://webstuff.nfshost.com/anim-timing/Overview.html"> webkit
+ *      draft spec</a>
+ */
+class AnimationSchedulerImplWebkit extends AnimationSchedulerImpl {
+
+  /**
+   * Webkit implementation of {@link AnimationScheduler.AnimationHandle}. Webkit
+   * provides the request ID as a double.
+   */
+  private class AnimationHandleImpl extends AnimationHandle {
+    private final double requestId;
+
+    public AnimationHandleImpl(double requestId) {
+      this.requestId = requestId;
+    }
+
+    @Override
+    public void cancel() {
+      cancelAnimationFrameImpl(requestId);
+    }
+  }
+
+  @Override
+  public AnimationHandle requestAnimationFrame(AnimationCallback callback, Element element) {
+    double requestId = requestAnimationFrameImpl(callback, element);
+    return new AnimationHandleImpl(requestId);
+  }
+
+  @Override
+  protected native boolean isNativelySupported() /*-{
+    return !!($wnd.webkitRequestAnimationFrame && $wnd.webkitCancelRequestAnimationFrame);
+  }-*/;
+
+  private native void cancelAnimationFrameImpl(double requestId) /*-{
+    $wnd.webkitCancelRequestAnimationFrame(requestId);
+  }-*/;
+
+  private native double requestAnimationFrameImpl(AnimationCallback callback, Element element) /*-{
+    var _callback = callback;
+    var wrapper = $entry(function(time) {
+      // Chrome 10 does not pass the 'time' argument, so we fake it.
+      time = time || @com.google.gwt.core.client.Duration::currentTimeMillis()();
+      _callback.@com.google.gwt.animation.client.AnimationScheduler.AnimationCallback::execute(D)(time);
+    });
+    return $wnd.webkitRequestAnimationFrame(wrapper, element);
+  }-*/;
+}
diff --git a/user/src/com/google/gwt/animation/client/testing/StubAnimationScheduler.java b/user/src/com/google/gwt/animation/client/testing/StubAnimationScheduler.java
new file mode 100644
index 0000000..148207e
--- /dev/null
+++ b/user/src/com/google/gwt/animation/client/testing/StubAnimationScheduler.java
@@ -0,0 +1,66 @@
+/*
+ * Copyright 2011 Google Inc.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ * 
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+package com.google.gwt.animation.client.testing;
+
+import com.google.gwt.animation.client.AnimationScheduler;
+import com.google.gwt.dom.client.Element;
+
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * A stub implementation of {@link AnimationScheduler} that does not execute the
+ * callbacks. Use {@link StubAnimationScheduler#getAnimationCallbacks()} to
+ * retrieve and execute callbacks manually.
+ */
+public class StubAnimationScheduler extends AnimationScheduler {
+
+  /**
+   * A handle to the requested animation frame created by
+   * {@link #requestAnimationFrame(AnimationCallback, Element)}.
+   */
+  public class StubAnimationHandle extends AnimationHandle {
+
+    private final AnimationCallback callback;
+
+    public StubAnimationHandle(AnimationCallback callback) {
+      this.callback = callback;
+    }
+
+    @Override
+    public void cancel() {
+      callbacks.remove(callback);
+    }
+  }
+
+  private final List<AnimationCallback> callbacks = new ArrayList<AnimationCallback>();
+
+  /**
+   * Get the list of all animation callbacks that have been requested and have
+   * not been canceled.
+   * 
+   * @return the list of callbacks.
+   */
+  public List<AnimationCallback> getAnimationCallbacks() {
+    return callbacks;
+  }
+
+  @Override
+  public StubAnimationHandle requestAnimationFrame(AnimationCallback callback, Element element) {
+    callbacks.add(callback);
+    return new StubAnimationHandle(callback);
+  }
+}
diff --git a/user/src/com/google/gwt/core/client/Scheduler.java b/user/src/com/google/gwt/core/client/Scheduler.java
index 7fceb6f..9620c48 100644
--- a/user/src/com/google/gwt/core/client/Scheduler.java
+++ b/user/src/com/google/gwt/core/client/Scheduler.java
@@ -22,6 +22,12 @@
  * thrown by the command objects executed by the scheduler will be passed to the
  * {@link GWT.UncaughtExceptionHandler} if one is installed.
  * 
+ * <p>
+ * NOTE: If you are using a timer to schedule a UI animation, use
+ * {@link com.google.gwt.animation.client.AnimationScheduler} instead. The
+ * browser can optimize your animation for maximum performance.
+ * </p>
+ * 
  * @see com.google.gwt.core.client.testing.StubScheduler
  */
 public abstract class Scheduler {
diff --git a/user/src/com/google/gwt/layout/client/Layout.java b/user/src/com/google/gwt/layout/client/Layout.java
index df84b04..218432a 100644
--- a/user/src/com/google/gwt/layout/client/Layout.java
+++ b/user/src/com/google/gwt/layout/client/Layout.java
@@ -578,7 +578,7 @@
       }
     };
 
-    animation.run(duration);
+    animation.run(duration, parentElem);
   }
 
   /**
diff --git a/user/src/com/google/gwt/user/cellview/client/CellBrowser.java b/user/src/com/google/gwt/user/cellview/client/CellBrowser.java
index 26e53ee..f0d25cd 100644
--- a/user/src/com/google/gwt/user/cellview/client/CellBrowser.java
+++ b/user/src/com/google/gwt/user/cellview/client/CellBrowser.java
@@ -712,7 +712,7 @@
       if (isAnimationEnabled()) {
         // Animate the scrolling.
         startScrollLeft = elem.getScrollLeft();
-        run(250);
+        run(250, elem);
       } else {
         // Scroll instantly.
         onComplete();
diff --git a/user/src/com/google/gwt/user/client/Timer.java b/user/src/com/google/gwt/user/client/Timer.java
index d75e2a6..13333b1 100644
--- a/user/src/com/google/gwt/user/client/Timer.java
+++ b/user/src/com/google/gwt/user/client/Timer.java
@@ -25,8 +25,16 @@
  * java.util.Timer, but is simplified because of the single-threaded
  * environment.
  * 
+ * <p>
  * To schedule a timer, simply create a subclass of it (overriding {@link #run})
  * and call {@link #schedule} or {@link #scheduleRepeating}.
+ * </p>
+ * 
+ * <p>
+ * NOTE: If you are using a timer to schedule a UI animation, use
+ * {@link com.google.gwt.animation.client.AnimationScheduler} instead. The
+ * browser can optimize your animation for maximum performance.
+ * </p>
  * 
  * <p>
  * <h3>Example</h3>
diff --git a/user/src/com/google/gwt/user/client/ui/DeckPanel.java b/user/src/com/google/gwt/user/client/ui/DeckPanel.java
index b0fd606..393a1ed 100644
--- a/user/src/com/google/gwt/user/client/ui/DeckPanel.java
+++ b/user/src/com/google/gwt/user/client/ui/DeckPanel.java
@@ -105,7 +105,25 @@
 
       // Start the animation
       if (animate) {
-        run(ANIMATION_DURATION);
+        // Figure out if the deck panel has a fixed height
+        com.google.gwt.dom.client.Element deckElem = container1.getParentElement();
+        int deckHeight = deckElem.getOffsetHeight();
+        if (growing) {
+          fixedHeight = container2.getOffsetHeight();
+          container2.getStyle().setPropertyPx("height",
+              Math.max(1, fixedHeight - 1));
+        } else {
+          fixedHeight = container1.getOffsetHeight();
+          container1.getStyle().setPropertyPx("height",
+              Math.max(1, fixedHeight - 1));
+        }
+        if (deckElem.getOffsetHeight() != deckHeight) {
+          fixedHeight = -1;
+        }
+
+        // Only scope to the deck if it's fixed height, otherwise it can affect
+        // the rest of the page, even if it's not visible to the user.
+        run(ANIMATION_DURATION, fixedHeight == -1 ? null : deckElem);
       } else {
         onInstantaneousRun();
       }
@@ -139,22 +157,6 @@
 
     @Override
     protected void onStart() {
-      // Figure out if the deck panel has a fixed height
-      com.google.gwt.dom.client.Element deckElem = container1.getParentElement();
-      int deckHeight = deckElem.getOffsetHeight();
-      if (growing) {
-        fixedHeight = container2.getOffsetHeight();
-        container2.getStyle().setPropertyPx("height",
-            Math.max(1, fixedHeight - 1));
-      } else {
-        fixedHeight = container1.getOffsetHeight();
-        container1.getStyle().setPropertyPx("height",
-            Math.max(1, fixedHeight - 1));
-      }
-      if (deckElem.getOffsetHeight() != deckHeight) {
-        fixedHeight = -1;
-      }
-
       // Start the animation
       DOM.setStyleAttribute(container1, "overflow", "hidden");
       DOM.setStyleAttribute(container2, "overflow", "hidden");
diff --git a/user/test/com/google/gwt/animation/AnimationSuite.java b/user/test/com/google/gwt/animation/AnimationSuite.java
new file mode 100644
index 0000000..ef8551f
--- /dev/null
+++ b/user/test/com/google/gwt/animation/AnimationSuite.java
@@ -0,0 +1,36 @@
+/*
+ * Copyright 2011 Google Inc.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ * 
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+package com.google.gwt.animation;
+
+import com.google.gwt.animation.client.AnimationSchedulerImplTimerTest;
+import com.google.gwt.animation.client.AnimationTest;
+
+import junit.framework.Test;
+import junit.framework.TestSuite;
+
+/**
+ * Tests of the animation package.
+ */
+public class AnimationSuite {
+  public static Test suite() {
+    TestSuite suite = new TestSuite("Tests of the animation package");
+
+    suite.addTestSuite(AnimationSchedulerImplTimerTest.class);
+    suite.addTestSuite(AnimationTest.class);
+
+    return suite;
+  }
+}
diff --git a/user/test/com/google/gwt/animation/client/AnimationSchedulerImplTimerTest.java b/user/test/com/google/gwt/animation/client/AnimationSchedulerImplTimerTest.java
new file mode 100644
index 0000000..fffa3fe
--- /dev/null
+++ b/user/test/com/google/gwt/animation/client/AnimationSchedulerImplTimerTest.java
@@ -0,0 +1,100 @@
+/*
+ * Copyright 2011 Google Inc.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ * 
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+package com.google.gwt.animation.client;
+
+import com.google.gwt.animation.client.AnimationScheduler.AnimationCallback;
+import com.google.gwt.animation.client.AnimationScheduler.AnimationHandle;
+import com.google.gwt.dom.client.DivElement;
+import com.google.gwt.dom.client.Document;
+import com.google.gwt.junit.client.GWTTestCase;
+import com.google.gwt.user.client.Timer;
+
+/**
+ * Tests the {@link AnimationSchedulerImplTimer} class.
+ */
+public class AnimationSchedulerImplTimerTest extends GWTTestCase {
+
+  /**
+   * The default timeout of asynchronous tests.
+   */
+  private static final int TEST_TIMEOUT = 60000;
+
+  /**
+   * Test maximum expected delay before the scheduler calls the callback. If the
+   * browser tab does not have focus, the browser may dramatically reduce the
+   * rate that timers fire, down to 1000ms.
+   */
+  private static final int TIMER_DELAY = 3000;
+
+  private AnimationSchedulerImplTimer scheduler;
+
+  @Override
+  public String getModuleName() {
+    return "com.google.gwt.animation.Animation";
+  }
+
+  public void testCancel() {
+    delayTestFinish(TEST_TIMEOUT);
+    AnimationHandle handle = scheduler.requestAnimationFrame(new AnimationCallback() {
+      @Override
+      public void execute(double timestamp) {
+        fail("The animation frame was cancelled and should not execute.");
+      }
+    }, null);
+
+    // Cancel the animation frame.
+    handle.cancel();
+
+    // Wait to make sure it doesn't execute.
+    new Timer() {
+      @Override
+      public void run() {
+        finishTest();
+      }
+    }.schedule(TIMER_DELAY);
+  }
+
+  public void testRequestAnimationFrame() {
+    delayTestFinish(TEST_TIMEOUT);
+    DivElement element = Document.get().createDivElement();
+    scheduler.requestAnimationFrame(new AnimationCallback() {
+      @Override
+      public void execute(double timestamp) {
+        finishTest();
+      }
+    }, element);
+  }
+
+  public void testRequestAnimationFrameWithoutElement() {
+    delayTestFinish(TEST_TIMEOUT);
+    scheduler.requestAnimationFrame(new AnimationCallback() {
+      @Override
+      public void execute(double timestamp) {
+        finishTest();
+      }
+    }, null);
+  }
+
+  @Override
+  protected void gwtSetUp() throws Exception {
+    scheduler = new AnimationSchedulerImplTimer();
+  }
+
+  @Override
+  protected void gwtTearDown() throws Exception {
+    scheduler = null;
+  }
+}
diff --git a/user/test/com/google/gwt/animation/client/AnimationTest.java b/user/test/com/google/gwt/animation/client/AnimationTest.java
index 2aebc0a..eb9465b 100644
--- a/user/test/com/google/gwt/animation/client/AnimationTest.java
+++ b/user/test/com/google/gwt/animation/client/AnimationTest.java
@@ -1,12 +1,12 @@
 /*
  * Copyright 2008 Google Inc.
- *
+ * 
  * Licensed under the Apache License, Version 2.0 (the "License"); you may not
  * use this file except in compliance with the License. You may obtain a copy of
  * the License at
- *
+ * 
  * http://www.apache.org/licenses/LICENSE-2.0
- *
+ * 
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
  * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
@@ -15,28 +15,36 @@
  */
 package com.google.gwt.animation.client;
 
+import com.google.gwt.animation.client.AnimationScheduler.AnimationCallback;
+import com.google.gwt.animation.client.testing.StubAnimationScheduler;
 import com.google.gwt.core.client.Duration;
 import com.google.gwt.junit.client.GWTTestCase;
-import com.google.gwt.user.client.Timer;
+
+import java.util.List;
 
 /**
  * Tests the {@link Animation} class.
+ * 
+ * <p>
+ * This class uses the {@link StubAnimationScheduler} to manually trigger
+ * callbacks.
+ * </p>
  */
 public class AnimationTest extends GWTTestCase {
-  /**
-   * Increase this multiplier to increase the duration of the tests, reducing
-   * the potential of an error caused by timing issues.
-   */
-  private static int DELAY_MULTIPLIER = 100;
 
   /**
    * A default implementation of {@link Animation} used for testing.
    */
-  private static class DefaultAnimation extends Animation {
+  private class DefaultAnimation extends Animation {
     protected boolean canceled = false;
     protected boolean completed = false;
-    protected boolean started = false;
     protected double curProgress = -1.0;
+    protected boolean started = false;
+    protected boolean updated = false;
+
+    public DefaultAnimation() {
+      super(scheduler);
+    }
 
     /**
      * Assert the value of canceled.
@@ -60,32 +68,28 @@
     }
 
     /**
-     * Assert that the progress falls between min and max, inclusively.
-     */
-    public void assertProgressRange(double min, double max) {
-      assertTrue(curProgress >= min && curProgress <= max);
-    }
-
-    /**
      * Assert the value of started.
      */
     public void assertStarted(boolean expected) {
       assertEquals(expected, started);
     }
 
+    /**
+     * Assert the value of updated.
+     */
+    public void assertUpdated(boolean expected) {
+      assertEquals(expected, updated);
+    }
+
     public void reset() {
       canceled = false;
       completed = false;
+      updated = false;
       started = false;
       curProgress = -1.0;
     }
 
     @Override
-    protected void onUpdate(double progress) {
-      curProgress = progress;
-    }
-
-    @Override
     protected void onCancel() {
       super.onCancel();
       canceled = true;
@@ -102,18 +106,18 @@
       super.onStart();
       started = true;
     }
+
+    @Override
+    protected void onUpdate(double progress) {
+      updated = true;
+      curProgress = progress;
+    }
   }
 
   /**
    * A custom {@link Animation} used for testing.
    */
-  private static class TestAnimation extends DefaultAnimation {
-    /*
-     * TODO: Consider timing issues for test system. Specifically, onUpdate is
-     * not guaranteed to be called in the Animation timer if we miss our
-     * deadline.
-     */
-
+  private class TestAnimation extends DefaultAnimation {
     @Override
     protected void onCancel() {
       canceled = true;
@@ -130,140 +134,208 @@
     }
   }
 
+  /**
+   * The maximum delay before an animation will run. Animations may run slowly
+   * if the browser tab is not focused.
+   * 
+   * Increase this multiplier to increase the duration of the tests, reducing
+   * the potential of an error caused by timing issues.
+   */
+  private static int DELAY_MULTIPLIER = 3000;
+
+  private List<AnimationCallback> callbacks;
+  private double curTime;
+  private StubAnimationScheduler scheduler;
+
   @Override
   public String getModuleName() {
-    return "com.google.gwt.user.User";
-  }
-
-  /**
-   * Test canceling an {@link Animation} before it starts.
-   */
-  public void testCancelBeforeStarted() {
-    final TestAnimation anim = new TestAnimation();
-    double curTime = Duration.currentTimeMillis();
-    delayTestFinish(20 * DELAY_MULTIPLIER);
-    anim.run(10 * DELAY_MULTIPLIER, curTime + 10 * DELAY_MULTIPLIER);
-
-    // Check progress
-    new Timer() {
-      @Override
-      public void run() {
-        anim.assertStarted(false);
-        anim.assertCompleted(false);
-        anim.assertProgress(-1.0);
-        anim.cancel();
-        anim.assertStarted(false);
-        anim.assertCancelled(true);
-        anim.assertCompleted(false);
-        anim.reset();
-      }
-    }.schedule(5 * DELAY_MULTIPLIER);
-
-    // Check progress
-    new Timer() {
-      @Override
-      public void run() {
-        anim.assertStarted(false);
-        anim.assertCompleted(false);
-        anim.assertProgress(-1.0);
-        finishTest();
-      }
-    }.schedule(15 * DELAY_MULTIPLIER);
+    return "com.google.gwt.animation.Animation";
   }
 
   /**
    * Test canceling an {@link Animation} after it completes.
    */
-  public void testCancelWhenComplete() {
+  public void testCancelAfterOnComplete() {
     final TestAnimation anim = new TestAnimation();
-    delayTestFinish(25 * DELAY_MULTIPLIER);
+    anim.run(DELAY_MULTIPLIER);
+    anim.assertStarted(true);
+    anim.assertUpdated(false);
+    anim.assertCompleted(false);
+    anim.assertCancelled(false);
+    anim.reset();
+
+    // Complete the animation.
+    executeLastCallbackAt(curTime + DELAY_MULTIPLIER + 100);
+    anim.assertStarted(false);
+    anim.assertUpdated(false);
+    anim.assertCompleted(true);
+    anim.assertCancelled(false);
+    assertEquals(0, callbacks.size());
+    anim.reset();
+
+    // Cancel the animation.
+    anim.cancel(); // no-op.
+    anim.assertStarted(false);
+    anim.assertUpdated(false);
+    anim.assertProgress(-1);
+    anim.assertCancelled(false);
+  }
+
+  /**
+   * Test canceling an {@link Animation} before onStart is called.
+   */
+  public void testCancelBeforeOnStart() {
+    final TestAnimation anim = new TestAnimation();
+
+    // Run the animation in the future.
+    anim.run(DELAY_MULTIPLIER, curTime + 1000);
+    anim.assertStarted(false);
+    anim.assertUpdated(false);
+    anim.assertCompleted(false);
+    anim.assertCancelled(false);
+    assertEquals(1, callbacks.size());
+    anim.reset();
+
+    // Cancel the animation before it starts.
+    anim.cancel();
+    anim.assertStarted(false);
+    anim.assertUpdated(false);
+    anim.assertCompleted(false);
+    anim.assertCancelled(true);
+    assertEquals(0, callbacks.size());
+  }
+
+  /**
+   * Test canceling an {@link Animation} between updates.
+   */
+  public void testCancelBetweenUpdates() {
+    TestAnimation anim = new TestAnimation();
     anim.run(10 * DELAY_MULTIPLIER);
+    anim.assertStarted(true);
+    anim.assertUpdated(false);
+    anim.assertCompleted(false);
+    anim.assertCancelled(false);
+    anim.reset();
 
-    // Check progress
-    new Timer() {
-      @Override
-      public void run() {
-        anim.assertStarted(true);
-        anim.assertCompleted(true);
-        anim.assertProgressRange(0.0, 1.0);
-        anim.cancel();
-        anim.assertCancelled(false);
-        anim.assertCompleted(true);
-        anim.reset();
-      }
-    }.schedule(15 * DELAY_MULTIPLIER);
+    // Update the animation.
+    executeLastCallbackAt(curTime + DELAY_MULTIPLIER);
+    anim.assertStarted(false);
+    anim.assertUpdated(true);
+    anim.assertCompleted(false);
+    anim.assertCancelled(false);
+    anim.reset();
 
-    // Check progress
-    new Timer() {
-      @Override
-      public void run() {
-        anim.assertStarted(false);
-        anim.assertCompleted(false);
-        anim.assertProgress(-1.0);
-        finishTest();
-      }
-    }.schedule(20 * DELAY_MULTIPLIER);
+    // Cancel the animation.
+    assertEquals(1, callbacks.size());
+    anim.cancel();
+    anim.assertStarted(false);
+    anim.assertUpdated(false);
+    anim.assertCompleted(false);
+    anim.assertCancelled(true);
+    anim.assertProgress(-1.0);
+    assertEquals(0, callbacks.size());
   }
 
   /**
-   * Test canceling an {@link Animation} while it is running.
+   * Test canceling an {@link Animation} within onComplete.
    */
-  public void testCancelWhileRunning() {
-    final TestAnimation anim = new TestAnimation();
-    delayTestFinish(20 * DELAY_MULTIPLIER);
-    anim.run(50 * DELAY_MULTIPLIER);
-
-    // Check progress
-    new Timer() {
+  public void testCancelDuringOnComplete() {
+    final TestAnimation anim = new TestAnimation() {
       @Override
-      public void run() {
-        anim.assertStarted(true);
-        anim.assertCompleted(false);
-        anim.cancel();
-        anim.assertCancelled(true);
-        anim.assertCompleted(false);
-        anim.reset();
-      }
-    }.schedule(5 * DELAY_MULTIPLIER);
+      protected void onComplete() {
+        super.onComplete();
+        assertStarted(false);
+        assertUpdated(false);
+        assertCompleted(true);
+        assertCancelled(false);
+        reset();
 
-    // Check progress
-    new Timer() {
-      @Override
-      public void run() {
-        anim.assertStarted(false);
-        anim.assertCompleted(false);
-        anim.assertProgress(-1.0);
-        finishTest();
+        // Cancel the animation.
+        cancel(); // no-op.
       }
-    }.schedule(15 * DELAY_MULTIPLIER);
+    };
+
+    // Run the animation.
+    anim.run(DELAY_MULTIPLIER);
+    anim.assertStarted(true);
+    anim.assertUpdated(false);
+    anim.assertCompleted(false);
+    anim.assertCancelled(false);
+    anim.reset();
+
+    // Force the animation to complete.
+    executeLastCallbackAt(curTime + DELAY_MULTIPLIER + 100);
+    anim.assertStarted(false);
+    anim.assertUpdated(false);
+    anim.assertCompleted(false);
+    anim.assertCancelled(false);
+    assertEquals(0, callbacks.size());
   }
 
   /**
-   * Test that an animation runs synchronously if its duration is 0.
+   * Test canceling an {@link Animation} within onStart.
    */
-  public void testNoDelay() {
-    final TestAnimation animNow = new TestAnimation();
-    final TestAnimation animPast = new TestAnimation();
-    final TestAnimation animFuture = new TestAnimation();
+  public void testCancelDuringOnStart() {
+    final TestAnimation anim = new TestAnimation() {
+      @Override
+      protected void onStart() {
+        super.onStart();
+        assertStarted(true);
+        assertUpdated(false);
+        assertCompleted(false);
+        assertCancelled(false);
+        reset();
 
-    // Run animations
-    double curTime = Duration.currentTimeMillis();
-    animNow.run(0);
-    animPast.run(0, curTime - 15 * DELAY_MULTIPLIER);
-    animFuture.run(0, curTime + 15 * DELAY_MULTIPLIER);
+        // Cancel the animation.
+        cancel();
+      }
+    };
 
-    // Test synchronous start
-    animNow.assertStarted(true);
-    animNow.assertCompleted(true);
-    animNow.assertProgress(-1.0);
+    // Run the animation.
+    anim.run(DELAY_MULTIPLIER);
+    anim.assertStarted(false);
+    anim.assertUpdated(false);
+    anim.assertCancelled(true);
+    anim.assertCompleted(false);
+    assertEquals(0, callbacks.size());
+  }
 
-    animPast.assertStarted(true);
-    animPast.assertCompleted(true);
-    animPast.assertProgress(-1.0);
+  /**
+   * Test canceling an {@link Animation} during an update.
+   */
+  public void testCancelDuringOnUpdate() {
+    final TestAnimation anim = new TestAnimation() {
+      @Override
+      protected void onUpdate(double progress) {
+        super.onUpdate(progress);
+        assertStarted(false);
+        assertUpdated(true);
+        assertCompleted(false);
+        assertCancelled(false);
+        reset();
 
-    animFuture.assertStarted(false);
-    animFuture.assertCompleted(false);
-    animFuture.assertProgress(-1.0);
+        // Cancel the test while it is running.
+        cancel();
+      }
+    };
+
+    // Run the animation.
+    anim.run(10 * DELAY_MULTIPLIER);
+    anim.assertStarted(true);
+    anim.assertUpdated(false);
+    anim.assertCompleted(false);
+    anim.assertCancelled(false);
+    anim.assertProgress(-1.0);
+    anim.reset();
+
+    // Force the update.
+    executeLastCallbackAt(curTime + DELAY_MULTIPLIER);
+    anim.assertStarted(false);
+    anim.assertUpdated(false);
+    anim.assertCompleted(false);
+    anim.assertCancelled(true);
+    anim.assertProgress(-1.0);
+    assertEquals(0, callbacks.size());
   }
 
   /**
@@ -272,10 +344,10 @@
   public void testDefaultAnimation() {
     // Verify initial state
     final DefaultAnimation anim = new DefaultAnimation();
-    anim.assertProgress(-1.0);
     anim.assertStarted(false);
-    anim.assertCompleted(false);
+    anim.assertUpdated(false);
     anim.assertCancelled(false);
+    anim.assertCompleted(false);
 
     // Starting an animation calls onUpdate(interpolate(0.0))
     anim.reset();
@@ -305,8 +377,7 @@
     // Canceling an animation before it starts does not call onStart or
     // onComplete
     anim.reset();
-    anim.run(20 * DELAY_MULTIPLIER, Duration.currentTimeMillis() + 100
-        * DELAY_MULTIPLIER);
+    anim.run(10 * DELAY_MULTIPLIER, curTime + DELAY_MULTIPLIER);
     anim.cancel();
     anim.assertProgress(-1.0);
     anim.assertStarted(false);
@@ -315,123 +386,164 @@
   }
 
   /**
-   * Test general functionality.
+   * Test that restarting an {@link Animation} within onComplete does not break.
+   * See issue 5639.
    */
-  public void testRun() {
-    final TestAnimation animNow = new TestAnimation();
-    final TestAnimation animPast = new TestAnimation();
-    final TestAnimation animFuture = new TestAnimation();
-
-    delayTestFinish(50 * DELAY_MULTIPLIER);
-    // Run animations
-    double curTime = Duration.currentTimeMillis();
-    animNow.run(30 * DELAY_MULTIPLIER);
-    animPast.run(30 * DELAY_MULTIPLIER, curTime - 10 * DELAY_MULTIPLIER);
-    animFuture.run(30 * DELAY_MULTIPLIER, curTime + 10 * DELAY_MULTIPLIER);
-
-    // Test synchronous start
-    animNow.assertStarted(true);
-    animNow.assertCompleted(false);
-    animNow.assertProgress(-1.0);
-
-    animPast.assertStarted(true);
-    animPast.assertCompleted(false);
-    animPast.assertProgress(-1.0);
-
-    animFuture.assertStarted(false);
-    animFuture.assertCompleted(false);
-    animFuture.assertProgress(-1.0);
-
-    // Check progress
-    new Timer() {
+  public void testRunDuringOnComplete() {
+    final TestAnimation anim = new TestAnimation() {
       @Override
-      public void run() {
-        animNow.assertStarted(true);
-        animNow.assertCompleted(false);
-        animNow.assertProgressRange(0.0, 1.0);
+      protected void onComplete() {
+        super.onComplete();
+        assertStarted(false);
+        assertUpdated(false);
+        assertCompleted(true);
+        assertCancelled(false);
+        reset();
 
-        animPast.assertStarted(true);
-        animPast.assertCompleted(false);
-        animPast.assertProgressRange(0.0, 1.0);
-
-        animFuture.assertStarted(false);
-        animFuture.assertCompleted(false);
-        animFuture.assertProgress(-1.0);
+        // Run the animation.
+        run(DELAY_MULTIPLIER);
       }
-    }.schedule(5 * DELAY_MULTIPLIER);
+    };
 
-    // Check progress
-    new Timer() {
-      @Override
-      public void run() {
-        animNow.assertStarted(true);
-        animNow.assertCompleted(false);
-        animNow.assertProgressRange(0.0, 1.0);
+    // Run the animation.
+    anim.run(DELAY_MULTIPLIER);
+    anim.assertStarted(true);
+    anim.assertUpdated(false);
+    anim.assertCompleted(false);
+    anim.assertCancelled(false);
+    anim.reset();
 
-        animPast.assertStarted(true);
-        animPast.assertCompleted(false);
-        animPast.assertProgressRange(0.0, 1.0);
+    // Force the animation to complete.
+    executeLastCallbackAt(curTime + DELAY_MULTIPLIER + 100);
+    anim.assertStarted(true);
+    anim.assertUpdated(false);
+    anim.assertCompleted(false);
+    anim.assertCancelled(false);
+    assertEquals(1, callbacks.size());
+  }
 
-        animFuture.assertStarted(true);
-        animFuture.assertCompleted(false);
-        animFuture.assertProgressRange(0.0, 1.0);
-      }
-    }.schedule(15 * DELAY_MULTIPLIER);
+  /**
+   * Test that an animation runs in the future.
+   */
+  public void testRunFuture() {
+    final TestAnimation anim = new TestAnimation();
+    anim.run(2 * DELAY_MULTIPLIER, curTime + 2 * DELAY_MULTIPLIER);
+    anim.assertStarted(false);
+    anim.assertUpdated(false);
+    anim.assertCompleted(false);
+    anim.reset();
 
-    // Check progress
-    new Timer() {
-      @Override
-      public void run() {
-        animNow.assertStarted(true);
-        animNow.assertCompleted(false);
-        animNow.assertProgressRange(0.0, 1.0);
+    // Update, but still before the start time.
+    executeLastCallbackAt(curTime + DELAY_MULTIPLIER);
+    anim.assertStarted(false);
+    anim.assertUpdated(false);
+    anim.assertCompleted(false);
+    anim.reset();
 
-        animPast.assertStarted(true);
-        animPast.assertCompleted(true);
-        animPast.assertProgressRange(0.0, 1.0);
+    // Start the animation.
+    executeLastCallbackAt(curTime + 2 * DELAY_MULTIPLIER);
+    anim.assertStarted(true);
+    anim.assertUpdated(false);
+    anim.assertCompleted(false);
+    anim.reset();
 
-        animFuture.assertStarted(true);
-        animFuture.assertCompleted(false);
-        animFuture.assertProgressRange(0.0, 1.0);
-      }
-    }.schedule(25 * DELAY_MULTIPLIER);
+    // Update the animation.
+    executeLastCallbackAt(curTime + 3 * DELAY_MULTIPLIER);
+    anim.assertStarted(false);
+    anim.assertUpdated(true);
+    anim.assertCompleted(false);
+    anim.reset();
 
-    // Check progress
-    new Timer() {
-      @Override
-      public void run() {
-        animNow.assertStarted(true);
-        animNow.assertCompleted(true);
-        animNow.assertProgressRange(0.0, 1.0);
+    // Complete the animation.
+    executeLastCallbackAt(curTime + 4 * DELAY_MULTIPLIER + 100);
+    anim.assertStarted(false);
+    anim.assertUpdated(false);
+    anim.assertCompleted(true);
+  }
 
-        animPast.assertStarted(true);
-        animPast.assertCompleted(true);
-        animPast.assertProgressRange(0.0, 1.0);
+  /**
+   * Test that an animation runs synchronously if its duration is 0.
+   */
+  public void testRunNow() {
+    final TestAnimation anim = new TestAnimation();
+    anim.run(2 * DELAY_MULTIPLIER);
+    anim.assertStarted(true);
+    anim.assertUpdated(false);
+    anim.assertCompleted(false);
+    anim.reset();
 
-        animFuture.assertStarted(true);
-        animFuture.assertCompleted(false);
-        animFuture.assertProgressRange(0.0, 1.0);
-      }
-    }.schedule(35 * DELAY_MULTIPLIER);
+    // Update the progress.
+    executeLastCallbackAt(curTime + DELAY_MULTIPLIER);
+    anim.assertStarted(false);
+    anim.assertUpdated(true);
+    anim.assertCompleted(false);
+    anim.reset();
 
-    // Check progress
-    new Timer() {
-      @Override
-      public void run() {
-        animNow.assertStarted(true);
-        animNow.assertCompleted(true);
-        animNow.assertProgressRange(0.0, 1.0);
+    // Complete the animation.
+    executeLastCallbackAt(curTime + 2 * DELAY_MULTIPLIER + 100);
+    anim.assertStarted(false);
+    anim.assertUpdated(false);
+    anim.assertCompleted(true);
+  }
 
-        animPast.assertStarted(true);
-        animPast.assertCompleted(true);
-        animPast.assertProgressRange(0.0, 1.0);
+  /**
+   * Test running an animation that started in the past.
+   */
+  public void testRunPast() {
+    final TestAnimation anim = new TestAnimation();
+    anim.run(3 * DELAY_MULTIPLIER, curTime - DELAY_MULTIPLIER);
+    anim.assertStarted(true);
+    anim.assertUpdated(false);
+    anim.assertCompleted(false);
+    anim.reset();
 
-        animFuture.assertStarted(true);
-        animFuture.assertCompleted(true);
-        animFuture.assertProgressRange(0.0, 1.0);
+    // Update the progress.
+    executeLastCallbackAt(curTime + DELAY_MULTIPLIER);
+    anim.assertStarted(false);
+    anim.assertUpdated(true);
+    anim.assertCompleted(false);
+    anim.reset();
 
-        finishTest();
-      }
-    }.schedule(45 * DELAY_MULTIPLIER);
+    // Complete the animation.
+    executeLastCallbackAt(curTime + 2 * DELAY_MULTIPLIER + 100);
+    anim.assertStarted(false);
+    anim.assertUpdated(false);
+    anim.assertCompleted(true);
+  }
+
+  /**
+   * Test running an animation that started and finished in the past.
+   */
+  public void testRunPaster() {
+    final TestAnimation anim = new TestAnimation();
+    anim.run(DELAY_MULTIPLIER, curTime - 2 * DELAY_MULTIPLIER);
+    anim.assertStarted(true);
+    anim.assertUpdated(false);
+    anim.assertCompleted(true);
+  }
+
+  @Override
+  protected void gwtSetUp() throws Exception {
+    scheduler = new StubAnimationScheduler();
+    callbacks = scheduler.getAnimationCallbacks();
+    curTime = Duration.currentTimeMillis();
+  }
+
+  @Override
+  protected void gwtTearDown() throws Exception {
+    scheduler = null;
+    callbacks = null;
+  }
+
+  /**
+   * Execute the last callback requested from the scheduler at the specified
+   * time.
+   * 
+   * @param timestamp the time to pass to the callback
+   */
+  private void executeLastCallbackAt(double timestamp) {
+    assertTrue(callbacks.size() > 0);
+    AnimationCallback callback = callbacks.remove(callbacks.size() - 1);
+    callback.execute(timestamp);
   }
 }