selenium-webdriver 2.47.0 → 2.52.0

package/lib/goog/async/run.js

@@ -1,139 +0,0 @@
-// 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');
-goog.require('goog.testing.watchers');
-
-
-/**
- * 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.
-  if (goog.global.Promise && goog.global.Promise.resolve) {
-    var promise = goog.global.Promise.resolve();
-    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.
-   * @private
-   */
-  goog.async.run.resetQueue_ = function() {
-    goog.async.run.workQueueScheduled_ = false;
-    goog.async.run.workQueue_ = new goog.async.WorkQueue();
-  };
-
-  // If there is a clock implemenation in use for testing
-  // and it is reset, reset the queue.
-  goog.testing.watchers.watchClockReset(goog.async.run.resetQueue_);
-}
-
-
-/**
- * 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;
-};

package/lib/goog/async/workqueue.js

@@ -1,139 +0,0 @@
-// Copyright 2015 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.WorkItem');
-goog.provide('goog.async.WorkQueue');
-
-goog.require('goog.asserts');
-goog.require('goog.async.FreeList');
-
-
-// TODO(johnlenz): generalize the WorkQueue if this is used by more
-// than goog.async.run.
-
-
-
-/**
- * A low GC workqueue. The key elements of this design:
- *   - avoids the need for goog.bind or equivalent by carrying scope
- *   - avoids the need for array reallocation by using a linked list
- *   - minimizes work entry objects allocation by recycling objects
- * @constructor
- * @final
- * @struct
- */
-goog.async.WorkQueue = function() {
-  this.workHead_ = null;
-  this.workTail_ = null;
-};
-
-
-/** @define {number} The maximum number of entries to keep for recycling. */
-goog.define('goog.async.WorkQueue.DEFAULT_MAX_UNUSED', 100);
-
-
-/** @const @private {goog.async.FreeList<goog.async.WorkItem>} */
-goog.async.WorkQueue.freelist_ = new goog.async.FreeList(
-    function() {return new goog.async.WorkItem(); },
-    function(item) {item.reset()},
-    goog.async.WorkQueue.DEFAULT_MAX_UNUSED);
-
-
-/**
- * @param {function()} fn
- * @param {Object|null|undefined} scope
- */
-goog.async.WorkQueue.prototype.add = function(fn, scope) {
-  var item = this.getUnusedItem_();
-  item.set(fn, scope);
-
-  if (this.workTail_) {
-    this.workTail_.next = item;
-    this.workTail_ = item;
-  } else {
-    goog.asserts.assert(!this.workHead_);
-    this.workHead_ = item;
-    this.workTail_ = item;
-  }
-};
-
-
-/**
- * @return {goog.async.WorkItem}
- */
-goog.async.WorkQueue.prototype.remove = function() {
-  var item = null;
-
-  if (this.workHead_) {
-    item = this.workHead_;
-    this.workHead_ = this.workHead_.next;
-    if (!this.workHead_) {
-      this.workTail_ = null;
-    }
-    item.next = null;
-  }
-  return item;
-};
-
-
-/**
- * @param {goog.async.WorkItem} item
- */
-goog.async.WorkQueue.prototype.returnUnused = function(item) {
-  goog.async.WorkQueue.freelist_.put(item);
-};
-
-
-/**
- * @return {goog.async.WorkItem}
- * @private
- */
-goog.async.WorkQueue.prototype.getUnusedItem_ = function() {
-  return goog.async.WorkQueue.freelist_.get();
-};
-
-
-
-/**
- * @constructor
- * @final
- * @struct
- */
-goog.async.WorkItem = function() {
-  /** @type {?function()} */
-  this.fn = null;
-  /** @type {Object|null|undefined} */
-  this.scope = null;
-  /** @type {?goog.async.WorkItem} */
-  this.next = null;
-};
-
-
-/**
- * @param {function()} fn
- * @param {Object|null|undefined} scope
- */
-goog.async.WorkItem.prototype.set = function(fn, scope) {
-  this.fn = fn;
-  this.scope = scope;
-  this.next = null;
-};
-
-
-/** Reset the work item so they don't prevent GC before reuse */
-goog.async.WorkItem.prototype.reset = function() {
-  this.fn = null;
-  this.scope = null;
-  this.next = null;
-};