137 lines
4.2 KiB
JavaScript
137 lines
4.2 KiB
JavaScript
// Copyright 2013 The Closure Library Authors. All Rights Reserved.
|
|
//
|
|
// 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.
|
|
|
|
goog.provide('goog.async.run');
|
|
|
|
goog.require('goog.async.WorkQueue');
|
|
goog.require('goog.async.nextTick');
|
|
goog.require('goog.async.throwException');
|
|
|
|
|
|
/**
|
|
* Fires the provided callback just before the current callstack unwinds, or as
|
|
* soon as possible after the current JS execution context.
|
|
* @param {function(this:THIS)} callback
|
|
* @param {THIS=} opt_context Object to use as the "this value" when calling
|
|
* the provided function.
|
|
* @template THIS
|
|
*/
|
|
goog.async.run = function(callback, opt_context) {
|
|
if (!goog.async.run.schedule_) {
|
|
goog.async.run.initializeRunner_();
|
|
}
|
|
if (!goog.async.run.workQueueScheduled_) {
|
|
// Nothing is currently scheduled, schedule it now.
|
|
goog.async.run.schedule_();
|
|
goog.async.run.workQueueScheduled_ = true;
|
|
}
|
|
|
|
goog.async.run.workQueue_.add(callback, opt_context);
|
|
};
|
|
|
|
|
|
/**
|
|
* Initializes the function to use to process the work queue.
|
|
* @private
|
|
*/
|
|
goog.async.run.initializeRunner_ = function() {
|
|
// If native Promises are available in the browser, just schedule the callback
|
|
// on a fulfilled promise, which is specified to be async, but as fast as
|
|
// possible. Use goog.global.Promise instead of just Promise because the
|
|
// relevant externs may be missing, and don't alias it because this could
|
|
// confuse the compiler into thinking the polyfill is required when it should
|
|
// be treated as optional.
|
|
if (String(goog.global.Promise).indexOf('[native code]') != -1) {
|
|
var promise = goog.global.Promise.resolve(undefined);
|
|
goog.async.run.schedule_ = function() {
|
|
promise.then(goog.async.run.processWorkQueue);
|
|
};
|
|
} else {
|
|
goog.async.run.schedule_ = function() {
|
|
goog.async.nextTick(goog.async.run.processWorkQueue);
|
|
};
|
|
}
|
|
};
|
|
|
|
|
|
/**
|
|
* Forces goog.async.run to use nextTick instead of Promise.
|
|
*
|
|
* This should only be done in unit tests. It's useful because MockClock
|
|
* replaces nextTick, but not the browser Promise implementation, so it allows
|
|
* Promise-based code to be tested with MockClock.
|
|
*
|
|
* However, we also want to run promises if the MockClock is no longer in
|
|
* control so we schedule a backup "setTimeout" to the unmocked timeout if
|
|
* provided.
|
|
*
|
|
* @param {function(function())=} opt_realSetTimeout
|
|
*/
|
|
goog.async.run.forceNextTick = function(opt_realSetTimeout) {
|
|
goog.async.run.schedule_ = function() {
|
|
goog.async.nextTick(goog.async.run.processWorkQueue);
|
|
if (opt_realSetTimeout) {
|
|
opt_realSetTimeout(goog.async.run.processWorkQueue);
|
|
}
|
|
};
|
|
};
|
|
|
|
|
|
/**
|
|
* The function used to schedule work asynchronousely.
|
|
* @private {function()}
|
|
*/
|
|
goog.async.run.schedule_;
|
|
|
|
|
|
/** @private {boolean} */
|
|
goog.async.run.workQueueScheduled_ = false;
|
|
|
|
|
|
/** @private {!goog.async.WorkQueue} */
|
|
goog.async.run.workQueue_ = new goog.async.WorkQueue();
|
|
|
|
|
|
if (goog.DEBUG) {
|
|
/**
|
|
* Reset the work queue. Only available for tests in debug mode.
|
|
*/
|
|
goog.async.run.resetQueue = function() {
|
|
goog.async.run.workQueueScheduled_ = false;
|
|
goog.async.run.workQueue_ = new goog.async.WorkQueue();
|
|
};
|
|
}
|
|
|
|
|
|
/**
|
|
* Run any pending goog.async.run work items. This function is not intended
|
|
* for general use, but for use by entry point handlers to run items ahead of
|
|
* goog.async.nextTick.
|
|
*/
|
|
goog.async.run.processWorkQueue = function() {
|
|
// NOTE: additional work queue items may be added while processing.
|
|
var item = null;
|
|
while (item = goog.async.run.workQueue_.remove()) {
|
|
try {
|
|
item.fn.call(item.scope);
|
|
} catch (e) {
|
|
goog.async.throwException(e);
|
|
}
|
|
goog.async.run.workQueue_.returnUnused(item);
|
|
}
|
|
|
|
// There are no more work items, allow processing to be scheduled again.
|
|
goog.async.run.workQueueScheduled_ = false;
|
|
};
|