goog.async.AnimationDelay

Provided By	`goog.async.AnimationDelay`
Extends	`goog.Disposable`
All Implemented Interfaces	`goog.disposable.IDisposable`

A delayed callback that pegs to the next animation frame instead of a user configurable timeout. By design, this should have the same interface as goog.async.Delay.

Uses requestAnimationFrame and friends when available, but falls back to a timeout of goog.async.AnimationDelay.TIMEOUT.

For more on requestAnimationFrame and how you can use it to create smoother animations, see:

new AnimationDelay`<THIS>`( `listener`, `opt_window`, `opt_handler` )

Parameters

`listener`	`function(number): undefined`
	Function to call when the delay completes. Will be passed the timestamp when it's called, in unix ms.
`opt_window`	`(Window\|null)=`
	The window object to execute the delay in. Defaults to the global object.
`opt_handler`	`(THIS\|null)=`
	The object scope to invoke the function in.

Instance Methods

Invokes a callback function when this object is disposed. Callbacks are invoked in the order in which they were added. If a callback is added to an already disposed Disposable, it will be called immediately.

Defined by

goog.Disposable

Parameters

`callback`	`function(): ?`
	The callback function.
`opt_scope`	`(T\|null)=`
	An optional scope to call the callback in.

VIEW SOURCE

Disposes of the object and its resources.

Overrides

goog.Disposable

Specified by

goog.disposable.IDisposable

Parameters

None.

Returns

Nothing.

VIEW SOURCE

Performs appropriate cleanup. See description of goog.disposable.IDisposable for examples. Classes that extend goog.Disposable should override this method. Not reentrant. To avoid calling it twice, it must only be called from the subclass' disposeInternal method. Everywhere else the public dispose method must be used. For example:

 mypackage.MyClass = function() {
 mypackage.MyClass.base(this, 'constructor');
     // Constructor logic specific to MyClass.
     ...
   };
   goog.inherits(mypackage.MyClass, goog.Disposable);

   mypackage.MyClass.prototype.disposeInternal = function() {
     // Dispose logic specific to MyClass.
     ...
     // Call superclass's disposeInternal at the end of the subclass's, like
     // in C++, to avoid hard-to-catch issues.
     mypackage.MyClass.base(this, 'disposeInternal');
   };