selenium-webdriver 2.48.2 → 2.53.3

package/lib/{webdriver/promise.js → promise.js}

@@ -15,44 +15,15 @@
 // specific language governing permissions and limitations
 // under the License.
 
-/**
- * @license Portions of this code are from the Dojo toolkit, received under the
- * BSD License:
- * 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 copyright notice,
- *     this list of conditions and the following disclaimer in the documentation
- *     and/or other materials provided with the distribution.
- *   * Neither the name of the Dojo Foundation nor the names of its contributors
- *     may be used to endorse or promote products derived from this software
- *     without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
- * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
- * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
- * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
- * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
- * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
- * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
- * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
- * POSSIBILITY OF SUCH DAMAGE.
- */
-
 /**
  * @fileoverview
- * The promise module is centered around the
- * {@linkplain webdriver.promise.ControlFlow ControlFlow}, a class that
- * coordinates the execution of asynchronous tasks. The ControlFlow allows users
- * to focus on the imperative commands for their script without worrying about
- * chaining together every single asynchronous action, which can be tedious and
- * verbose. APIs may be layered on top of the control flow to read as if they
- * were synchronous. For instance, the core
- * {@linkplain webdriver.WebDriver WebDriver} API is built on top of the
+ * The promise module is centered around the {@linkplain ControlFlow}, a class
+ * that coordinates the execution of asynchronous tasks. The ControlFlow allows
+ * users to focus on the imperative commands for their script without worrying
+ * about chaining together every single asynchronous action, which can be
+ * tedious and verbose. APIs may be layered on top of the control flow to read
+ * as if they were synchronous. For instance, the core
+ * {@linkplain ./webdriver.WebDriver WebDriver} API is built on top of the
  * control flow, allowing users to write
  *
  *     driver.get('http://www.google.com/ncr');
@@ -79,10 +50,9 @@
  *
  * The control flow is based on the concept of tasks and task queues. Tasks are
  * functions that define the basic unit of work for the control flow to execute.
- * Each task is scheduled via
- * {@link webdriver.promise.ControlFlow#execute() ControlFlow#execute()}, which
- * will return a {@link webdriver.promise.Promise Promise} that will be resolved
- * with the task's result.
+ * Each task is scheduled via {@link ControlFlow#execute()}, which will return
+ * a {@link ManagedPromise ManagedPromise} that will be resolved with the task's
+ * result.
  *
  * A task queue contains all of the tasks scheduled within a single turn of the
  * [JavaScript event loop][JSEL]. The control flow will create a new task queue
@@ -98,12 +68,12 @@
  * Whenever the control flow creates a new task queue, it will automatically
  * begin executing tasks in the next available turn of the event loop. This
  * execution is scheduled using a "micro-task" timer, such as a (native)
- * `Promise.then()` callback.
+ * `ManagedPromise.then()` callback.
  *
  *     setTimeout(() => console.log('a'));
- *     Promise.resolve().then(() => console.log('b'));  // A native promise.
+ *     ManagedPromise.resolve().then(() => console.log('b'));  // A native promise.
  *     flow.execute(() => console.log('c'));
- *     Promise.resolve().then(() => console.log('d'));
+ *     ManagedPromise.resolve().then(() => console.log('d'));
  *     setTimeout(() => console.log('fin'));
  *     // b
  *     // c
@@ -127,14 +97,13 @@
  * There are several important events that may occur while executing a task
  * function:
  *
- * 1. A new task queue is created by a call to
- *    {@link webdriver.promise.ControlFlow#execute ControlFlow#execute()}. Any
- *    tasks scheduled within this task queue are considered subtasks of the
+ * 1. A new task queue is created by a call to {@link ControlFlow#execute()}.
+ *    Any tasks scheduled within this task queue are considered subtasks of the
  *    current task.
  * 2. The task function throws an error. Any scheduled tasks are immediately
  *    discarded and the task's promised result (previously returned by
- *    {@link webdriver.promise.ControlFlow#execute ControlFlow#execute()}) is
- *    immediately rejected with the thrown error.
+ *    {@link ControlFlow#execute()}) is immediately rejected with the thrown
+ *    error.
  * 3. The task function returns sucessfully.
  *
  * If a task function created a new task queue, the control flow will wait for
@@ -153,13 +122,12 @@
  *     // b
  *     // c
  *
- * ## Promise Integration
+ * ## ManagedPromise Integration
  *
- * In addition to the {@link webdriver.promise.ControlFlow ControlFlow} class,
- * the promise module also exports a [Promise/A+]
- * {@linkplain webdriver.promise.Promise implementation} that is deeply
+ * In addition to the {@link ControlFlow} class, the promise module also exports
+ * a [ManagedPromise/A+] {@linkplain ManagedPromise implementation} that is deeply
  * integrated with the ControlFlow. First and foremost, each promise
- * {@linkplain webdriver.promise.Promise#then() callback} is scheduled with the
+ * {@linkplain ManagedPromise#then() callback} is scheduled with the
  * control flow as a task. As a result, each callback is invoked in its own turn
  * of the JavaScript event loop with its own task queue. If any tasks are
  * scheduled within a callback, the callback's promised result will not be
@@ -173,7 +141,7 @@
  *     // b
  *     // a
  *
- * ### Scheduling Promise Callbacks <a id="scheduling_callbacks"></a>
+ * ### Scheduling ManagedPromise Callbacks <a id="scheduling_callbacks"></a>
  *
  * How callbacks are scheduled in the control flow depends on when they are
  * attached to the promise. Callbacks attached to a _previously_ resolved
@@ -463,18 +431,17 @@
  *
  * ES6 promises do not require users to handle a promise rejections. This can
  * result in subtle bugs as the rejections are silently "swallowed" by the
- * Promise class.
+ * ManagedPromise class.
  *
- *     Promise.reject(Error('boom'));
+ *     ManagedPromise.reject(Error('boom'));
  *     // ... *crickets* ...
  *
- * Selenium's {@link webdriver.promise promise} module, on the other hand,
- * requires that every rejection be explicitly handled. When a
- * {@linkplain webdriver.promise.Promise Promise} is rejected and no callbacks
- * are defined on that promise, it is considered an _unhandled rejection_ and
- * reproted to the active task queue. If the rejection remains unhandled after
- * a single turn of the [event loop][JSEL] (scheduled with a micro-task), it
- * will propagate up the stack.
+ * Selenium's promise module, on the other hand, requires that every rejection
+ * be explicitly handled. When a {@linkplain ManagedPromise ManagedPromise} is
+ * rejected and no callbacks are defined on that promise, it is considered an
+ * _unhandled rejection_ and reproted to the active task queue. If the rejection
+ * remains unhandled after a single turn of the [event loop][JSEL] (scheduled
+ * with a micro-task), it will propagate up the stack.
  *
  * ## Error Propagation
  *
@@ -485,7 +452,7 @@
  *       // No callbacks registered on promise -> unhandled rejection
  *       promise.rejected(Error('boom'));
  *       flow.execute(function() { console.log('this will never run'); });
- *     }).thenCatch(function(e) {
+ *     }).catch(function(e) {
  *       console.log(e.message);
  *     });
  *     // boom
@@ -497,7 +464,7 @@
  *       promise.rejected(Error('boom'));
  *       flow.execute(function() { console.log('a'); }).
  *           then(function() { console.log('b'); });
- *     }).thenCatch(function(e) {
+ *     }).catch(function(e) {
  *       console.log(e.message);
  *     });
  *     // boom
@@ -508,21 +475,20 @@
  *     flow.execute(function() {
  *       promise.rejected(Error('boom'));
  *       return flow.execute(someOtherTask);
- *     }).thenCatch(function(e) {
+ *     }).catch(function(e) {
  *       console.log(e.message);
  *     });
  *     // boom
  *
  * If there are multiple unhandled rejections within a task, they are packaged
- * in a {@link webdriver.promise.MultipleUnhandledRejectionError
- * MultipleUnhandledRejectionError}, which has an `errors` property that is a
- * `Set` of the recorded unhandled rejections:
+ * in a {@link MultipleUnhandledRejectionError}, which has an `errors` property
+ * that is a `Set` of the recorded unhandled rejections:
  *
  *     flow.execute(function() {
  *       promise.rejected(Error('boom1'));
  *       promise.rejected(Error('boom2'));
- *     }).thenCatch(function(ex) {
- *       console.log(ex instanceof promise.MultipleUnhandledRejectionError);
+ *     }).catch(function(ex) {
+ *       console.log(ex instanceof MultipleUnhandledRejectionError);
  *       for (var e of ex.errors) {
  *         console.log(e.message);
  *       }
@@ -542,7 +508,7 @@
  *     flow.execute(function() {
  *       promise.rejected(Error('boom'));
  *       subTask = flow.execute(function() {});
- *     }).thenCatch(function(e) {
+ *     }).catch(function(e) {
  *       console.log(e.message);
  *     }).then(function() {
  *       return subTask.then(
@@ -564,7 +530,7 @@
  *           throw Error('fail!');
  *         });
  *       });
- *     }).thenCatch(function(e) {
+ *     }).catch(function(e) {
  *       console.log(e.message);
  *     });
  *     // fail!
@@ -580,9 +546,9 @@
  *
  * Bottom line: you __*must*__ handle rejected promises.
  *
- * # Promise/A+ Compatibility
+ * # ManagedPromise/A+ Compatibility
  *
- * This `promise` module is compliant with the [Promise/A+][] specification
+ * This `promise` module is compliant with the [ManagedPromise/A+][] specification
  * except for sections `2.2.6.1` and `2.2.6.2`:
  *
  * >
@@ -596,7 +562,7 @@
  * Specifically, the conformance tests contains the following scenario (for
  * brevity, only the fulfillment version is shown):
  *
- *     var p1 = Promise.resolve();
+ *     var p1 = ManagedPromise.resolve();
  *     p1.then(function() {
  *       console.log('A');
  *       p1.then(() => console.log('B'));
@@ -621,36 +587,73 @@
  *
  * [JSEL]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/EventLoop
  * [GF]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/function*
- * [Promise/A+]: https://promisesaplus.com/
+ * [ManagedPromise/A+]: https://promisesaplus.com/
  */
 
-goog.module('webdriver.promise');
-goog.module.declareLegacyNamespace();
+'use strict';
 
-var Arrays = goog.require('goog.array');
-var asserts = goog.require('goog.asserts');
-var asyncRun = goog.require('goog.async.run');
-var throwException = goog.require('goog.async.throwException');
-var DebugError = goog.require('goog.debug.Error');
-var log = goog.require('goog.log');
-var Objects = goog.require('goog.object');
-var EventEmitter = goog.require('webdriver.EventEmitter');
-var stacktrace = goog.require('webdriver.stacktrace');
+const events = require('./events');
+const logging = require('./logging');
 
 
+/**
+ * Alias to help with readability and differentiate types.
+ * @const
+ */
+const NativePromise = Promise;
+
 
 /**
- * @define {boolean} Whether to append traces of {@code then} to rejection
- *     errors.
+ * Whether to append traces of `then` to rejection errors.
+ * @type {boolean}
  */
-goog.define('webdriver.promise.LONG_STACK_TRACES', false);
+var LONG_STACK_TRACES = false;  // TODO: this should not be CONSTANT_CASE
+
 
 /** @const */
-var promise = exports;
+const LOG = logging.getLogger('promise');
 
 
-/** @const */
-var LOG = log.getLogger('webdriver.promise');
+const UNIQUE_IDS = new WeakMap;
+let nextId = 1;
+
+
+function getUid(obj) {
+  let id = UNIQUE_IDS.get(obj);
+  if (!id) {
+    id = nextId;
+    nextId += 1;
+    UNIQUE_IDS.set(obj, id);
+  }
+  return id;
+}
+
+
+/**
+ * Runs the given function after a micro-task yield.
+ * @param {function()} fn The function to run.
+ */
+function asyncRun(fn) {
+  NativePromise.resolve().then(function() {
+    try {
+      fn();
+    } catch (ignored) {
+      // Do nothing.
+    }
+  });
+}
+
+
+/**
+ * Throws an error asynchronously so it is reported to the global error handler.
+ *
+ * @param {!Error} error The error to throw.
+ */
+function asyncThrow(error) {
+  setTimeout(function() {
+    throw error;
+  }, 0);
+}
 
 
 /**
@@ -661,18 +664,18 @@ var LOG = log.getLogger('webdriver.promise');
  * @template T
  */
 function vlog(level, loggable, opt_self) {
-  var logLevel = log.Level.FINE;
+  var logLevel = logging.Level.FINE;
   if (level > 1) {
-    logLevel = log.Level.FINEST;
+    logLevel = logging.Level.FINEST;
   } else if (level > 0) {
-    logLevel = log.Level.FINER;
+    logLevel = logging.Level.FINER;
   }
 
   if (typeof loggable === 'function') {
     loggable = loggable.bind(opt_self);
   }
 
-  log.log(LOG, logLevel, loggable);
+  LOG.log(logLevel, loggable);
 }
 
 
@@ -680,150 +683,134 @@ function vlog(level, loggable, opt_self) {
  * Generates an error to capture the current stack trace.
  * @param {string} name Error name for this stack trace.
  * @param {string} msg Message to record.
- * @param {!Function} topFn The function that should appear at the top of the
- *     stack; only applicable in V8.
+ * @param {Function=} opt_topFn The function that should appear at the top of
+ *     the stack; only applicable in V8.
  * @return {!Error} The generated error.
  */
-promise.captureStackTrace = function(name, msg, topFn) {
+function captureStackTrace(name, msg, opt_topFn) {
   var e = Error(msg);
   e.name = name;
   if (Error.captureStackTrace) {
-    Error.captureStackTrace(e, topFn);
+    Error.captureStackTrace(e, opt_topFn);
   } else {
-    var stack = stacktrace.getStack(e);
-    e.stack = e.toString();
+    var stack = Error().stack;
     if (stack) {
+      e.stack = e.toString();
       e.stack += '\n' + stack;
     }
   }
   return e;
-};
+}
 
 
 /**
  * Error used when the computation of a promise is cancelled.
- *
- * @unrestricted
  */
-promise.CancellationError = goog.defineClass(DebugError, {
+class CancellationError extends Error {
   /**
    * @param {string=} opt_msg The cancellation message.
    */
-  constructor: function(opt_msg) {
-    promise.CancellationError.base(this, 'constructor', opt_msg);
+  constructor(opt_msg) {
+    super(opt_msg);
 
     /** @override */
-    this.name = 'CancellationError';
+    this.name = this.constructor.name;
 
     /** @private {boolean} */
     this.silent_ = false;
-  },
+  }
 
-  statics: {
-    /**
-     * Wraps the given error in a CancellationError.
-     *
-     * @param {*} error The error to wrap.
-     * @param {string=} opt_msg The prefix message to use.
-     * @return {!promise.CancellationError} A cancellation error.
-     */
-    wrap: function(error, opt_msg) {
-      var message;
-      if (error instanceof promise.CancellationError) {
-        return new promise.CancellationError(
-            opt_msg ? (opt_msg + ': ' + error.message) : error.message);
-      } else if (opt_msg) {
-        message = opt_msg;
-        if (error) {
-          message += ': ' + error;
-        }
-        return new promise.CancellationError(message);
-      }
+  /**
+   * Wraps the given error in a CancellationError.
+   *
+   * @param {*} error The error to wrap.
+   * @param {string=} opt_msg The prefix message to use.
+   * @return {!CancellationError} A cancellation error.
+   */
+  static wrap(error, opt_msg) {
+    var message;
+    if (error instanceof CancellationError) {
+      return new CancellationError(
+          opt_msg ? (opt_msg + ': ' + error.message) : error.message);
+    } else if (opt_msg) {
+      message = opt_msg;
       if (error) {
-        message = error + '';
+        message += ': ' + error;
       }
-      return new promise.CancellationError(message);
+      return new CancellationError(message);
     }
+    if (error) {
+      message = error + '';
+    }
+    return new CancellationError(message);
   }
-});
+}
 
 
 /**
  * Error used to cancel tasks when a control flow is reset.
- * @unrestricted
  * @final
  */
-var FlowResetError = goog.defineClass(promise.CancellationError, {
-  constructor: function() {
-    FlowResetError.base(this, 'constructor', 'ControlFlow was reset');
-
-    /** @override */
-    this.name = 'FlowResetError';
-
+class FlowResetError extends CancellationError {
+  constructor() {
+    super('ControlFlow was reset');
     this.silent_ = true;
   }
-});
+}
 
 
 /**
  * Error used to cancel tasks that have been discarded due to an uncaught error
  * reported earlier in the control flow.
- * @unrestricted
  * @final
  */
-var DiscardedTaskError = goog.defineClass(promise.CancellationError, {
+class DiscardedTaskError extends CancellationError {
   /** @param {*} error The original error. */
-  constructor: function(error) {
+  constructor(error) {
     if (error instanceof DiscardedTaskError) {
       return /** @type {!DiscardedTaskError} */(error);
     }
 
     var msg = '';
     if (error) {
-      msg = ': ' + (typeof error.message === 'string' ? error.message : error);
+      msg = ': ' + (
+          typeof error.message === 'string' ? error.message : error);
     }
 
-    DiscardedTaskError.base(this, 'constructor',
-        'Task was discarded due to a previous failure' + msg);
-
-    /** @override */
-    this.name = 'DiscardedTaskError';
+    super('Task was discarded due to a previous failure' + msg);
     this.silent_ = true;
   }
-});
+}
 
 
 /**
  * Error used when there are multiple unhandled promise rejections detected
  * within a task or callback.
  *
- * @unrestricted
  * @final
  */
-promise.MultipleUnhandledRejectionError = goog.defineClass(DebugError, {
+class MultipleUnhandledRejectionError extends Error {
   /**
    * @param {!(Set<*>)} errors The errors to report.
    */
-  constructor: function(errors) {
-    promise.MultipleUnhandledRejectionError.base(
-        this, 'constructor', 'Multiple unhandled promise rejections reported');
+  constructor(errors) {
+    super('Multiple unhandled promise rejections reported');
 
     /** @override */
-    this.name = 'MultipleUnhandledRejectionError';
+    this.name = this.constructor.name;
 
     /** @type {!Set<*>} */
     this.errors = errors;
   }
-});
+}
 
 
 /**
  * Property used to flag constructor's as implementing the Thenable interface
  * for runtime type checking.
- * @type {string}
  * @const
  */
-var IMPLEMENTED_BY_PROP = '$webdriver_Thenable';
+const IMPLEMENTED_BY_SYMBOL = Symbol('promise.Thenable');
 
 
 /**
@@ -834,64 +821,54 @@ var IMPLEMENTED_BY_PROP = '$webdriver_Thenable';
  * @extends {IThenable<T>}
  * @template T
  */
-promise.Thenable = goog.defineClass(null, {
-  statics: {
-    /**
-     * Adds a property to a class prototype to allow runtime checks of whether
-     * instances of that class implement the Thenable interface. This function
-     * will also ensure the prototype's {@code then} function is exported from
-     * compiled code.
-     * @param {function(new: promise.Thenable, ...?)} ctor The
-     *     constructor whose prototype to modify.
-     */
-    addImplementation: function(ctor) {
-      // Based on goog.promise.Thenable.isImplementation.
-      ctor.prototype['then'] = ctor.prototype.then;
-      try {
-        // Old IE7 does not support defineProperty; IE8 only supports it for
-        // DOM elements.
-        Object.defineProperty(
-          ctor.prototype,
-          IMPLEMENTED_BY_PROP,
-          {'value': true, 'enumerable': false});
-      } catch (ex) {
-        ctor.prototype[IMPLEMENTED_BY_PROP] = true;
-      }
-    },
+class Thenable {
+  /**
+   * Adds a property to a class prototype to allow runtime checks of whether
+   * instances of that class implement the Thenable interface. This function
+   * will also ensure the prototype's {@code then} function is exported from
+   * compiled code.
+   * @param {function(new: Thenable, ...?)} ctor The
+   *     constructor whose prototype to modify.
+   */
+  static addImplementation(ctor) {
+    ctor.prototype['then'] = ctor.prototype.then;
+    try {
+      ctor.prototype[IMPLEMENTED_BY_SYMBOL] = true;
+    } catch (ignored) {
+      // Property access denied?
+    }
+  }
 
-    /**
-     * Checks if an object has been tagged for implementing the Thenable
-     * interface as defined by
-     * {@link webdriver.promise.Thenable.addImplementation}.
-     * @param {*} object The object to test.
-     * @return {boolean} Whether the object is an implementation of the Thenable
-     *     interface.
-     */
-    isImplementation: function(object) {
-      // Based on goog.promise.Thenable.isImplementation.
-      if (!object) {
-        return false;
-      }
-      try {
-        return !!object[IMPLEMENTED_BY_PROP];
-      } catch (e) {
-        return false;  // Property access seems to be forbidden.
-      }
+  /**
+   * Checks if an object has been tagged for implementing the Thenable
+   * interface as defined by {@link Thenable.addImplementation}.
+   * @param {*} object The object to test.
+   * @return {boolean} Whether the object is an implementation of the Thenable
+   *     interface.
+   */
+  static isImplementation(object) {
+    if (!object) {
+      return false;
     }
-  },
+    try {
+      return !!object[IMPLEMENTED_BY_SYMBOL];
+    } catch (e) {
+      return false;  // Property access seems to be forbidden.
+    }
+  }
 
   /**
    * Cancels the computation of this promise's value, rejecting the promise in
    * the process. This method is a no-op if the promise has already been
    * resolved.
    *
-   * @param {(string|promise.CancellationError)=} opt_reason The reason this
-   *     promise is being cancelled.
+   * @param {(string|Error)=} opt_reason The reason this promise is being
+   *     cancelled. This value will be wrapped in a {@link CancellationError}.
    */
-  cancel: function(opt_reason) {},
+  cancel(opt_reason) {}
 
   /** @return {boolean} Whether this promise's value is still being computed. */
-  isPending: function() {},
+  isPending() {}
 
   /**
    * Registers listeners for when this instance is resolved.
@@ -902,11 +879,11 @@ promise.Thenable = goog.defineClass(null, {
    * @param {?(function(*): (R|IThenable<R>))=} opt_errback
    *     The function to call if this promise is rejected. The function should
    *     expect a single argument: the rejection reason.
-   * @return {!promise.Promise<R>} A new promise which will be
+   * @return {!ManagedPromise<R>} A new promise which will be
    *     resolved with the result of the invoked callback.
    * @template R
    */
-  then: function(opt_callback, opt_errback) {},
+  then(opt_callback, opt_errback) {}
 
   /**
    * Registers a listener for when this promise is rejected. This is synonymous
@@ -920,18 +897,69 @@ promise.Thenable = goog.defineClass(null, {
    *     }
    *
    *     // Asynchronous promise API:
-   *     doAsynchronousWork().thenCatch(function(ex) {
+   *     doAsynchronousWork().catch(function(ex) {
    *       console.error(ex);
    *     });
    *
    * @param {function(*): (R|IThenable<R>)} errback The
    *     function to call if this promise is rejected. The function should
    *     expect a single argument: the rejection reason.
-   * @return {!promise.Promise<R>} A new promise which will be
+   * @return {!ManagedPromise<R>} A new promise which will be
    *     resolved with the result of the invoked callback.
    * @template R
    */
-  thenCatch: function(errback) {},
+  catch(errback) {}
+
+  /**
+   * An alias for {@link #catch()}
+   *
+   * @param {function(*): (R|IThenable<R>)} errback The
+   *     function to call if this promise is rejected. The function should
+   *     expect a single argument: the rejection reason.
+   * @return {!ManagedPromise<R>} A new promise which will be
+   *     resolved wdith the result of the invoked callback.
+   * @deprecated Use {@link #catch()} instead.
+   * @template R
+   */
+  thenCatch(errback) {}
+
+  /**
+   * Registers a listener to invoke when this promise is resolved, regardless
+   * of whether the promise's value was successfully computed. This function
+   * is synonymous with the {@code finally} clause in a synchronous API:
+   *
+   *     // Synchronous API:
+   *     try {
+   *       doSynchronousWork();
+   *     } finally {
+   *       cleanUp();
+   *     }
+   *
+   *     // Asynchronous promise API:
+   *     doAsynchronousWork().finally(cleanUp);
+   *
+   * __Note:__ similar to the {@code finally} clause, if the registered
+   * callback returns a rejected promise or throws an error, it will silently
+   * replace the rejection error (if any) from this promise:
+   *
+   *     try {
+   *       throw Error('one');
+   *     } finally {
+   *       throw Error('two');  // Hides Error: one
+   *     }
+   *
+   *     promise.rejected(Error('one'))
+   *         .finally(function() {
+   *           throw Error('two');  // Hides Error: one
+   *         });
+   *
+   * @param {function(): (R|IThenable<R>)} callback The function to call when
+   *     this promise is resolved.
+   * @return {!ManagedPromise<R>} A promise that will be fulfilled
+   *     with the callback result.
+   * @template R
+   */
+  finally(callback) {}
 
   /**
    * Registers a listener to invoke when this promise is resolved, regardless
@@ -965,19 +993,18 @@ promise.Thenable = goog.defineClass(null, {
    *
    * @param {function(): (R|IThenable<R>)} callback The function
    *     to call when this promise is resolved.
-   * @return {!promise.Promise<R>} A promise that will be fulfilled
+   * @return {!ManagedPromise<R>} A promise that will be fulfilled
    *     with the callback result.
+   * @deprecated Use {@link #finally()} instead.
    * @template R
    */
-  thenFinally: function(callback) {}
-});
-
+  thenFinally(callback) {}}
 
 
 /**
  * @enum {string}
  */
-var PromiseState = {
+const PromiseState = {
   PENDING: 'pending',
   BLOCKED: 'blocked',
   REJECTED: 'rejected',
@@ -987,11 +1014,11 @@ var PromiseState = {
 
 /**
  * Internal symbol used to store a cancellation handler for
- * {@link promise.Promise} objects. This is an internal implementation detail
+ * {@link ManagedPromise} objects. This is an internal implementation detail
  * used by the {@link TaskQueue} class to monitor for when a promise is
  * cancelled without generating an extra promise via then().
  */
-var CANCEL_HANDLER_SYMBOL = Symbol('on cancel');
+const CANCEL_HANDLER_SYMBOL = Symbol('on cancel');
 
 
 /**
@@ -1001,12 +1028,12 @@ var CANCEL_HANDLER_SYMBOL = Symbol('on cancel');
  * fulfilled or rejected state, at which point the promise is considered
  * resolved.
  *
- * @implements {promise.Thenable<T>}
+ * @implements {Thenable<T>}
+ * @unrestricted
  * @template T
  * @see http://promises-aplus.github.io/promises-spec/
- * @unrestricted  // For using CANCEL_HANDLER_SYMBOL.
  */
-promise.Promise = goog.defineClass(null, {
+class ManagedPromise {
   /**
    * @param {function(
    *           function((T|IThenable<T>|Thenable)=),
@@ -1014,23 +1041,22 @@ promise.Promise = goog.defineClass(null, {
    *     Function that is invoked immediately to begin computation of this
    *     promise's value. The function should accept a pair of callback
    *     functions, one for fulfilling the promise and another for rejecting it.
-   * @param {promise.ControlFlow=} opt_flow The control flow
+   * @param {ControlFlow=} opt_flow The control flow
    *     this instance was created under. Defaults to the currently active flow.
    */
-  constructor: function(resolver, opt_flow) {
-    goog.getUid(this);
+  constructor(resolver, opt_flow) {
+    getUid(this);
 
-    /** @private {!promise.ControlFlow} */
-    this.flow_ = opt_flow || promise.controlFlow();
+    /** @private {!ControlFlow} */
+    this.flow_ = opt_flow || controlFlow();
 
     /** @private {Error} */
     this.stack_ = null;
-    if (promise.LONG_STACK_TRACES) {
-      this.stack_ = promise.captureStackTrace(
-        'Promise', 'new', promise.Promise);
+    if (LONG_STACK_TRACES) {
+      this.stack_ = captureStackTrace('ManagedPromise', 'new', this.constructor);
     }
 
-    /** @private {promise.Promise<?>} */
+    /** @private {ManagedPromise<?>} */
     this.parent_ = null;
 
     /** @private {Array<!Task>} */
@@ -1048,7 +1074,7 @@ promise.Promise = goog.defineClass(null, {
     /** @private {TaskQueue} */
     this.queue_ = null;
 
-    /** @private {(function(promise.CancellationError)|null)} */
+    /** @private {(function(CancellationError)|null)} */
     this[CANCEL_HANDLER_SYMBOL] = null;
 
     try {
@@ -1061,13 +1087,13 @@ promise.Promise = goog.defineClass(null, {
     } catch (ex) {
       this.resolve_(PromiseState.REJECTED, ex);
     }
-  },
+  }
 
   /** @override */
-  toString: function() {
-    return 'Promise::' + goog.getUid(this) +
+  toString() {
+    return 'ManagedPromise::' + getUid(this) +
       ' {[[PromiseStatus]]: "' + this.state_ + '"}';
-  },
+  }
 
   /**
    * Resolves this promise. If the new value is itself a promise, this function
@@ -1077,7 +1103,7 @@ promise.Promise = goog.defineClass(null, {
    * @throws {TypeError} If {@code newValue === this}.
    * @private
    */
-  resolve_: function(newState, newValue) {
+  resolve_(newState, newValue) {
     if (PromiseState.PENDING !== this.state_) {
       return;
     }
@@ -1093,15 +1119,16 @@ promise.Promise = goog.defineClass(null, {
     this.state_ = PromiseState.BLOCKED;
 
     if (newState !== PromiseState.REJECTED) {
-      if (promise.Thenable.isImplementation(newValue)) {
+      if (Thenable.isImplementation(newValue)) {
         // 2.3.2
-        newValue = /** @type {!promise.Thenable} */(newValue);
+        newValue = /** @type {!Thenable} */(newValue);
         newValue.then(
             this.unblockAndResolve_.bind(this, PromiseState.FULFILLED),
             this.unblockAndResolve_.bind(this, PromiseState.REJECTED));
         return;
 
-      } else if (goog.isObject(newValue)) {
+      } else if (newValue
+          && (typeof newValue === 'object' || typeof newValue === 'function')) {
         // 2.3.3
 
         try {
@@ -1115,10 +1142,9 @@ promise.Promise = goog.defineClass(null, {
           return;
         }
 
-        // NB: goog.isFunction is loose and will accept instanceof Function.
         if (typeof then === 'function') {
           // 2.3.3.3
-          this.invokeThen_(newValue, then);
+          this.invokeThen_(/** @type {!Object} */(newValue), then);
           return;
         }
       }
@@ -1133,7 +1159,7 @@ promise.Promise = goog.defineClass(null, {
     this.state_ = newState;
     this.value_ = newValue;
     this.scheduleNotifications_();
-  },
+  }
 
   /**
    * Invokes a thenable's "then" method according to 2.3.3.3 of the promise
@@ -1142,7 +1168,7 @@ promise.Promise = goog.defineClass(null, {
    * @param {!Function} then The "then" function to invoke.
    * @private
    */
-  invokeThen_: function(x, then) {
+  invokeThen_(x, then) {
     var called = false;
     var self = this;
 
@@ -1169,28 +1195,28 @@ promise.Promise = goog.defineClass(null, {
       // 2.3.3.3.4.2
       rejectPromise(e);
     }
-  },
+  }
 
   /**
    * @param {PromiseState} newState The promise's new state.
    * @param {*} newValue The promise's new value.
    * @private
    */
-  unblockAndResolve_: function(newState, newValue) {
+  unblockAndResolve_(newState, newValue) {
     if (this.state_ === PromiseState.BLOCKED) {
       this.state_ = PromiseState.PENDING;
       this.resolve_(newState, newValue);
     }
-  },
+  }
 
   /**
    * @private
    */
-  scheduleNotifications_: function() {
+  scheduleNotifications_() {
     vlog(2, () => this + ' scheduling notifications', this);
 
     this[CANCEL_HANDLER_SYMBOL] = null;
-    if (this.value_ instanceof promise.CancellationError
+    if (this.value_ instanceof CancellationError
         && this.value_.silent_) {
       this.callbacks_ = null;
     }
@@ -1201,14 +1227,14 @@ promise.Promise = goog.defineClass(null, {
 
     if (!this.handled_ &&
         this.state_ === PromiseState.REJECTED &&
-        !(this.value_ instanceof promise.CancellationError)) {
+        !(this.value_ instanceof CancellationError)) {
       this.queue_.addUnhandledRejection(this);
     }
     this.queue_.scheduleCallbacks(this);
-  },
+  }
 
   /** @override */
-  cancel: function(opt_reason) {
+  cancel(opt_reason) {
     if (!canCancel(this)) {
       return;
     }
@@ -1216,7 +1242,7 @@ promise.Promise = goog.defineClass(null, {
     if (this.parent_ && canCancel(this.parent_)) {
       this.parent_.cancel(opt_reason);
     } else {
-      var reason = promise.CancellationError.wrap(opt_reason);
+      var reason = CancellationError.wrap(opt_reason);
       if (this[CANCEL_HANDLER_SYMBOL]) {
         this[CANCEL_HANDLER_SYMBOL](reason);
         this[CANCEL_HANDLER_SYMBOL] = null;
@@ -1233,27 +1259,35 @@ promise.Promise = goog.defineClass(null, {
       return promise.state_ === PromiseState.PENDING
           || promise.state_ === PromiseState.BLOCKED;
     }
-  },
+  }
 
   /** @override */
-  isPending: function() {
+  isPending() {
     return this.state_ === PromiseState.PENDING;
-  },
+  }
 
   /** @override */
-  then: function(opt_callback, opt_errback) {
+  then(opt_callback, opt_errback) {
     return this.addCallback_(
-        opt_callback, opt_errback, 'then', promise.Promise.prototype.then);
-  },
+        opt_callback, opt_errback, 'then', ManagedPromise.prototype.then);
+  }
 
   /** @override */
-  thenCatch: function(errback) {
+  catch(errback) {
     return this.addCallback_(
-        null, errback, 'thenCatch', promise.Promise.prototype.thenCatch);
-  },
+        null, errback, 'catch', ManagedPromise.prototype.catch);
+  }
+
+  /**
+   * @override
+   * @deprecated Use {@link #catch()} instead.
+   */
+  thenCatch(errback) {
+    return this.catch(errback);
+  }
 
   /** @override */
-  thenFinally: function(callback) {
+  finally(callback) {
     var error;
     var mustThrow = false;
     return this.then(function() {
@@ -1267,7 +1301,15 @@ promise.Promise = goog.defineClass(null, {
         throw error;
       }
     });
-  },
+  }
+
+  /**
+   * @override
+   * @deprecated Use {@link #finally()} instead.
+   */
+  thenFinally(callback) {
+    return this.finally(callback);
+  }
 
   /**
    * Registers a new callback with this promise
@@ -1278,13 +1320,13 @@ promise.Promise = goog.defineClass(null, {
    * @param {string} name The callback name.
    * @param {!Function} fn The function to use as the top of the stack when
    *     recording the callback's creation point.
-   * @return {!promise.Promise<R>} A new promise which will be resolved with the
+   * @return {!ManagedPromise<R>} A new promise which will be resolved with the
    *     esult of the invoked callback.
    * @template R
    * @private
    */
-  addCallback_: function(callback, errback, name, fn) {
-    if (!goog.isFunction(callback) && !goog.isFunction(errback)) {
+  addCallback_(callback, errback, name, fn) {
+    if (typeof callback !== 'function' && typeof errback !== 'function') {
       return this;
     }
 
@@ -1297,7 +1339,7 @@ promise.Promise = goog.defineClass(null, {
         this.flow_,
         this.invokeCallback_.bind(this, callback, errback),
         name,
-        promise.LONG_STACK_TRACES ? {name: 'Promise', top: fn} : undefined);
+        LONG_STACK_TRACES ? {name: 'Promise', top: fn} : undefined);
     cb.promise.parent_ = this;
 
     if (this.state_ !== PromiseState.PENDING &&
@@ -1313,7 +1355,7 @@ promise.Promise = goog.defineClass(null, {
     }
 
     return cb.promise;
-  },
+  }
 
   /**
    * Invokes a callback function attached to this promise.
@@ -1324,15 +1366,15 @@ promise.Promise = goog.defineClass(null, {
    * @template R
    * @private
    */
-  invokeCallback_: function(callback, errback) {
+  invokeCallback_(callback, errback) {
     var callbackFn = callback;
     if (this.state_ === PromiseState.REJECTED) {
       callbackFn = errback;
     }
 
-    if (goog.isFunction(callbackFn)) {
-      if (promise.isGenerator(callbackFn)) {
-        return promise.consume(callbackFn, null, this.value_);
+    if (typeof callbackFn === 'function') {
+      if (isGenerator(callbackFn)) {
+        return consume(callbackFn, null, this.value_);
       }
       return callbackFn(this.value_);
     } else if (this.state_ === PromiseState.REJECTED) {
@@ -1341,34 +1383,34 @@ promise.Promise = goog.defineClass(null, {
       return this.value_;
     }
   }
-});
-promise.Thenable.addImplementation(promise.Promise);
+}
+Thenable.addImplementation(ManagedPromise);
 
 
 /**
  * Represents a value that will be resolved at some point in the future. This
- * class represents the protected "producer" half of a Promise - each Deferred
+ * class represents the protected "producer" half of a ManagedPromise - each Deferred
  * has a {@code promise} property that may be returned to consumers for
  * registering callbacks, reserving the ability to resolve the deferred to the
  * producer.
  *
  * If this Deferred is rejected and there are no listeners registered before
  * the next turn of the event loop, the rejection will be passed to the
- * {@link webdriver.promise.ControlFlow} as an unhandled failure.
+ * {@link ControlFlow} as an unhandled failure.
  *
- * @implements {promise.Thenable<T>}
+ * @implements {Thenable<T>}
  * @template T
  */
-promise.Deferred = goog.defineClass(null, {
+class Deferred {
   /**
-   * @param {promise.ControlFlow=} opt_flow The control flow this instance was
+   * @param {ControlFlow=} opt_flow The control flow this instance was
    *     created under. This should only be provided during unit tests.
    */
-  constructor: function(opt_flow) {
+  constructor(opt_flow) {
     var fulfill, reject;
 
-    /** @type {!promise.Promise<T>} */
-    this.promise = new promise.Promise(function(f, r) {
+    /** @type {!ManagedPromise<T>} */
+    this.promise = new ManagedPromise(function(f, r) {
       fulfill = f;
       reject = r;
     }, opt_flow);
@@ -1399,43 +1441,124 @@ promise.Deferred = goog.defineClass(null, {
       checkNotSelf(opt_reason);
       reject(opt_reason);
     };
-  },
+  }
 
   /** @override */
-  isPending: function() {
+  isPending() {
     return this.promise.isPending();
-  },
+  }
 
   /** @override */
-  cancel: function(opt_reason) {
+  cancel(opt_reason) {
     this.promise.cancel(opt_reason);
-  },
+  }
 
   /**
    * @override
    * @deprecated Use {@code then} from the promise property directly.
    */
-  then: function(opt_cb, opt_eb) {
+  then(opt_cb, opt_eb) {
     return this.promise.then(opt_cb, opt_eb);
-  },
+  }
+
+  /**
+   * @override
+   * @deprecated Use {@lcode catch} from the promise property directly.
+   */
+  catch(opt_eb) {
+    return this.promise.catch(opt_eb);
+  }
 
   /**
    * @override
    * @deprecated Use {@code thenCatch} from the promise property directly.
    */
-  thenCatch: function(opt_eb) {
+  thenCatch(opt_eb) {
     return this.promise.thenCatch(opt_eb);
-  },
+  }
 
   /**
    * @override
    * @deprecated Use {@code thenFinally} from the promise property directly.
    */
-  thenFinally: function(opt_cb) {
+  thenFinally(opt_cb) {
     return this.promise.thenFinally(opt_cb);
   }
-});
-promise.Thenable.addImplementation(promise.Deferred);
+
+  /**
+   * @override
+   * @deprecated Use {@code finally} from the promise property directly.
+   */
+  finally(opt_cb) {
+    return this.promise.finally(opt_cb);
+  }
+}
+Thenable.addImplementation(Deferred);
+
+
+/**
+ * Registers a listener to invoke when a promise is resolved, regardless of
+ * whether the promise's value was successfully computed. This function is
+ * synonymous with the `finally` clause in a synchronous API:
+ *
+ *     // Synchronous API:
+ *     try {
+ *       doSynchronousWork();
+ *     } finally {
+ *       cleanUp();
+ *     }
+ *
+ *     // Asynchronous promise API:
+ *     promise.finally(doAsynchronousWork(), cleanUp);
+ *
+ * __Note:__ similar to the `finally` clause, if the registered callback returns
+ * a rejected promise or throws an error, that error will silently replace the
+ * rejection (if any) from the initial promise:
+ *
+ *     try {
+ *       throw Error('one');
+ *     } finally {
+ *       throw Error('two');  // Hides Error: one
+ *     }
+ *
+ *     let p = promise.rejected(Error('one'));
+ *     promise.finally(p, function() {
+ *       throw Error('two');  // Hides Error: one
+ *     });
+ *
+ * @param {PROMISE_TYPE} promise The thenable, promise-like object with which
+ *     to register the callback.
+ * @param {function(): *} callback The function to call when the promise is
+ *     resolved.
+ * @return {!PROMISE_TYPE} A new promise that is chained to the callback. This
+ *     promise will inherit the value of the original input if the callback
+ *     does not throw or return a rejected promise.
+ * @template PROMISE_TYPE
+ * @deprecated
+ */
+function thenFinally(promise, callback) {
+  if (!isPromise(promise)) {
+    throw TypeError('first argument must be a promise-like object');
+  }
+
+  if (typeof callback !== 'function') {
+    throw TypeError('second argument must be a function');
+  }
+
+  let error;
+  let mustThrow = false;
+  return promise
+      .then(() => callback(), (e) => {
+        error = e;
+        mustThrow = true;
+        return callback();
+      })
+      .then(() => {
+        if (mustThrow) {
+          throw error;
+        }
+      });
+}
 
 
 /**
@@ -1446,11 +1569,8 @@ promise.Thenable.addImplementation(promise.Deferred);
  */
 function isError(value) {
   return value instanceof Error ||
-      goog.isObject(value) &&
-      (goog.isString(value.message) ||
-       // A special test for goog.testing.JsUnitException.
-       value.isJsUnitException);
-
+      (!!value && typeof value === 'object'
+          && typeof value.message === 'string');
 }
 
 
@@ -1458,97 +1578,101 @@ function isError(value) {
  * Determines whether a {@code value} should be treated as a promise.
  * Any object whose "then" property is a function will be considered a promise.
  *
- * @param {*} value The value to test.
+ * @param {?} value The value to test.
  * @return {boolean} Whether the value is a promise.
  */
-promise.isPromise = function(value) {
-  return !!value && goog.isObject(value) &&
-      // Use array notation so the Closure compiler does not obfuscate away our
-      // contract. Use typeof rather than goog.isFunction because
-      // goog.isFunction accepts instanceof Function, which the promise spec
-      // does not.
-      typeof value['then'] === 'function';
-};
+function isPromise(value) {
+  try {
+    // Use array notation so the Closure compiler does not obfuscate away our
+    // contract.
+    return value
+        && (typeof value === 'object' || typeof value === 'function')
+        && typeof value['then'] === 'function';
+  } catch (ex) {
+    return false;
+  }
+}
 
 
 /**
  * Creates a promise that will be resolved at a set time in the future.
  * @param {number} ms The amount of time, in milliseconds, to wait before
  *     resolving the promise.
- * @return {!promise.Promise} The promise.
+ * @return {!ManagedPromise} The promise.
  */
-promise.delayed = function(ms) {
+function delayed(ms) {
   var key;
-  return new promise.Promise(function(fulfill) {
+  return new ManagedPromise(function(fulfill) {
     key = setTimeout(function() {
       key = null;
       fulfill();
     }, ms);
-  }).thenCatch(function(e) {
+  }).catch(function(e) {
     clearTimeout(key);
     key = null;
     throw e;
   });
-};
+}
 
 
 /**
  * Creates a new deferred object.
- * @return {!promise.Deferred<T>} The new deferred object.
+ * @return {!Deferred<T>} The new deferred object.
  * @template T
  */
-promise.defer = function() {
-  return new promise.Deferred();
-};
+function defer() {
+  return new Deferred();
+}
 
 
 /**
  * Creates a promise that has been resolved with the given value.
  * @param {T=} opt_value The resolved value.
- * @return {!promise.Promise<T>} The resolved promise.
+ * @return {!ManagedPromise<T>} The resolved promise.
  * @template T
  */
-promise.fulfilled = function(opt_value) {
-  if (opt_value instanceof promise.Promise) {
+function fulfilled(opt_value) {
+  if (opt_value instanceof ManagedPromise) {
     return opt_value;
   }
-  return new promise.Promise(function(fulfill) {
+  return new ManagedPromise(function(fulfill) {
     fulfill(opt_value);
   });
-};
+}
 
 
 /**
  * Creates a promise that has been rejected with the given reason.
  * @param {*=} opt_reason The rejection reason; may be any value, but is
  *     usually an Error or a string.
- * @return {!promise.Promise<T>} The rejected promise.
+ * @return {!ManagedPromise<T>} The rejected promise.
  * @template T
  */
-promise.rejected = function(opt_reason) {
-  if (opt_reason instanceof promise.Promise) {
+function rejected(opt_reason) {
+  if (opt_reason instanceof ManagedPromise) {
     return opt_reason;
   }
-  return new promise.Promise(function(_, reject) {
+  return new ManagedPromise(function(_, reject) {
     reject(opt_reason);
   });
-};
+}
 
 
 /**
  * Wraps a function that expects a node-style callback as its final
  * argument. This callback expects two arguments: an error value (which will be
  * null if the call succeeded), and the success value as the second argument.
- * The callback will the resolve or reject the returned promise, based on its arguments.
+ * The callback will the resolve or reject the returned promise, based on its
+ * arguments.
  * @param {!Function} fn The function to wrap.
  * @param {...?} var_args The arguments to apply to the function, excluding the
  *     final callback.
- * @return {!promise.Promise} A promise that will be resolved with the
+ * @return {!ManagedPromise} A promise that will be resolved with the
  *     result of the provided function's callback.
  */
-promise.checkedNodeCall = function(fn, var_args) {
-  var args = Arrays.slice(arguments, 1);
-  return new promise.Promise(function(fulfill, reject) {
+function checkedNodeCall(fn, var_args) {
+  let args = Array.prototype.slice.call(arguments, 1);
+  return new ManagedPromise(function(fulfill, reject) {
     try {
       args.push(function(error, value) {
         error ? reject(error) : fulfill(value);
@@ -1558,7 +1682,7 @@ promise.checkedNodeCall = function(fn, var_args) {
       reject(ex);
     }
   });
-};
+}
 
 
 /**
@@ -1570,43 +1694,37 @@ promise.checkedNodeCall = function(fn, var_args) {
  *     resolved successfully.
  * @param {Function=} opt_errback The function to call when the value is
  *     rejected.
- * @return {!promise.Promise} A new promise.
+ * @return {!ManagedPromise} A new promise.
  */
-promise.when = function(value, opt_callback, opt_errback) {
-  if (promise.Thenable.isImplementation(value)) {
+function when(value, opt_callback, opt_errback) {
+  if (Thenable.isImplementation(value)) {
     return value.then(opt_callback, opt_errback);
   }
 
-  return new promise.Promise(function(fulfill, reject) {
-    promise.asap(value, fulfill, reject);
+  return new ManagedPromise(function(fulfill) {
+    fulfill(value);
   }).then(opt_callback, opt_errback);
-};
+}
 
 
 /**
- * Invokes the appropriate callback function as soon as a promised
- * {@code value} is resolved. This function is similar to
- * {@link webdriver.promise.when}, except it does not return a new promise.
+ * Invokes the appropriate callback function as soon as a promised `value` is
+ * resolved. This function is similar to `when()`, except it does not return
+ * a new promise.
  * @param {*} value The value to observe.
  * @param {Function} callback The function to call when the value is
  *     resolved successfully.
  * @param {Function=} opt_errback The function to call when the value is
  *     rejected.
  */
-promise.asap = function(value, callback, opt_errback) {
-  if (promise.isPromise(value)) {
+function asap(value, callback, opt_errback) {
+  if (isPromise(value)) {
     value.then(callback, opt_errback);
 
-  // Maybe a Dojo-like deferred object?
-  } else if (!!value && goog.isObject(value) &&
-      goog.isFunction(value.addCallbacks)) {
-    value.addCallbacks(callback, opt_errback);
-
-  // A raw value, return a resolved promise.
   } else if (callback) {
     callback(value);
   }
-};
+}
 
 
 /**
@@ -1615,16 +1733,16 @@ promise.asap = function(value, callback, opt_errback) {
  * input array's promises are rejected, the returned promise will be rejected
  * with the same reason.
  *
- * @param {!Array<(T|!promise.Promise<T>)>} arr An array of
+ * @param {!Array<(T|!ManagedPromise<T>)>} arr An array of
  *     promises to wait on.
- * @return {!promise.Promise<!Array<T>>} A promise that is
+ * @return {!ManagedPromise<!Array<T>>} A promise that is
  *     fulfilled with an array containing the fulfilled values of the
  *     input array, or rejected with the same reason as the first
  *     rejected value.
  * @template T
  */
-promise.all = function(arr) {
-  return new promise.Promise(function(fulfill, reject) {
+function all(arr) {
+  return new ManagedPromise(function(fulfill, reject) {
     var n = arr.length;
     var values = [];
 
@@ -1642,11 +1760,17 @@ promise.all = function(arr) {
       }
     };
 
+    function processPromise(index) {
+      asap(arr[index], function(value) {
+        onFulfilled(index, value);
+      }, reject);
+    }
+
     for (var i = 0; i < n; ++i) {
-      promise.asap(arr[i], goog.partial(onFulfilled, i), reject);
+      processPromise(i);
     }
   });
-};
+}
 
 
 /**
@@ -1662,7 +1786,7 @@ promise.all = function(arr) {
  * Only the first failure will be reported; all subsequent errors will be
  * silently ignored.
  *
- * @param {!(Array<TYPE>|promise.Promise<!Array<TYPE>>)} arr The
+ * @param {!(Array<TYPE>|ManagedPromise<!Array<TYPE>>)} arr The
  *     array to iterator over, or a promise that will resolve to said array.
  * @param {function(this: SELF, TYPE, number, !Array<TYPE>): ?} fn The
  *     function to call for each element in the array. This function should
@@ -1671,11 +1795,13 @@ promise.all = function(arr) {
  *     {@code fn}.
  * @template TYPE, SELF
  */
-promise.map = function(arr, fn, opt_self) {
-  return promise.fulfilled(arr).then(function(v) {
-    goog.asserts.assertNumber(v.length, 'not an array like value');
+function map(arr, fn, opt_self) {
+  return fulfilled(arr).then(function(v) {
+    if (!Array.isArray(v)) {
+      throw TypeError('not an array');
+    }
     var arr = /** @type {!Array} */(v);
-    return new promise.Promise(function(fulfill, reject) {
+    return new ManagedPromise(function(fulfill, reject) {
       var n = arr.length;
       var values = new Array(n);
       (function processNext(i) {
@@ -1689,7 +1815,7 @@ promise.map = function(arr, fn, opt_self) {
           return;
         }
         try {
-          promise.asap(
+          asap(
               fn.call(opt_self, arr[i], i, /** @type {!Array} */(arr)),
               function(value) {
                 values[i] = value;
@@ -1702,7 +1828,7 @@ promise.map = function(arr, fn, opt_self) {
       })(0);
     });
   });
-};
+}
 
 
 /**
@@ -1718,20 +1844,22 @@ promise.map = function(arr, fn, opt_self) {
  * first failure will be reported; all subsequent errors will be silently
  * ignored.
  *
- * @param {!(Array<TYPE>|promise.Promise<!Array<TYPE>>)} arr The
+ * @param {!(Array<TYPE>|ManagedPromise<!Array<TYPE>>)} arr The
  *     array to iterator over, or a promise that will resolve to said array.
  * @param {function(this: SELF, TYPE, number, !Array<TYPE>): (
- *             boolean|promise.Promise<boolean>)} fn The function
+ *             boolean|ManagedPromise<boolean>)} fn The function
  *     to call for each element in the array.
  * @param {SELF=} opt_self The object to be used as the value of 'this' within
  *     {@code fn}.
  * @template TYPE, SELF
  */
-promise.filter = function(arr, fn, opt_self) {
-  return promise.fulfilled(arr).then(function(v) {
-    goog.asserts.assertNumber(v.length, 'not an array like value');
+function filter(arr, fn, opt_self) {
+  return fulfilled(arr).then(function(v) {
+    if (!Array.isArray(v)) {
+      throw TypeError('not an array');
+    }
     var arr = /** @type {!Array} */(v);
-    return new promise.Promise(function(fulfill, reject) {
+    return new ManagedPromise(function(fulfill, reject) {
       var n = arr.length;
       var values = [];
       var valuesLength = 0;
@@ -1748,7 +1876,7 @@ promise.filter = function(arr, fn, opt_self) {
         try {
           var value = arr[i];
           var include = fn.call(opt_self, value, i, /** @type {!Array} */(arr));
-          promise.asap(include, function(include) {
+          asap(include, function(include) {
             if (include) {
               values[valuesLength++] = value;
             }
@@ -1760,7 +1888,7 @@ promise.filter = function(arr, fn, opt_self) {
       })(0);
     });
   });
-};
+}
 
 
 /**
@@ -1779,90 +1907,91 @@ promise.filter = function(arr, fn, opt_self) {
  *     promise.fullyResolved(value);  // Stack overflow.
  *
  * @param {*} value The value to fully resolve.
- * @return {!promise.Promise} A promise for a fully resolved version
+ * @return {!ManagedPromise} A promise for a fully resolved version
  *     of the input value.
  */
-promise.fullyResolved = function(value) {
-  if (promise.isPromise(value)) {
-    return promise.when(value, fullyResolveValue);
+function fullyResolved(value) {
+  if (isPromise(value)) {
+    return when(value, fullyResolveValue);
   }
   return fullyResolveValue(value);
-};
+}
 
 
 /**
  * @param {*} value The value to fully resolve. If a promise, assumed to
  *     already be resolved.
- * @return {!promise.Promise} A promise for a fully resolved version
+ * @return {!ManagedPromise} A promise for a fully resolved version
  *     of the input value.
  */
- function fullyResolveValue(value) {
-  switch (goog.typeOf(value)) {
-    case 'array':
-      return fullyResolveKeys(/** @type {!Array} */ (value));
-
-    case 'object':
-      if (promise.isPromise(value)) {
-        // We get here when the original input value is a promise that
-        // resolves to itself. When the user provides us with such a promise,
-        // trust that it counts as a "fully resolved" value and return it.
-        // Of course, since it's already a promise, we can just return it
-        // to the user instead of wrapping it in another promise.
-        return /** @type {!promise.Promise} */ (value);
-      }
+function fullyResolveValue(value) {
+  if (Array.isArray(value)) {
+    return fullyResolveKeys(/** @type {!Array} */ (value));
+  }
 
-      if (goog.isNumber(value.nodeType) &&
-          goog.isObject(value.ownerDocument) &&
-          goog.isNumber(value.ownerDocument.nodeType)) {
-        // DOM node; return early to avoid infinite recursion. Should we
-        // only support objects with a certain level of nesting?
-        return promise.fulfilled(value);
-      }
+  if (isPromise(value)) {
+    if (isPromise(value)) {
+      // We get here when the original input value is a promise that
+      // resolves to itself. When the user provides us with such a promise,
+      // trust that it counts as a "fully resolved" value and return it.
+      // Of course, since it's already a promise, we can just return it
+      // to the user instead of wrapping it in another promise.
+      return /** @type {!ManagedPromise} */ (value);
+    }
+  }
 
-      return fullyResolveKeys(/** @type {!Object} */ (value));
+  if (value && typeof value === 'object') {
+    return fullyResolveKeys(/** @type {!Object} */ (value));
+  }
 
-    default:  // boolean, function, null, number, string, undefined
-      return promise.fulfilled(value);
+  if (typeof value === 'function') {
+    return fullyResolveKeys(/** @type {!Object} */ (value));
   }
+
+  return fulfilled(value);
 }
 
 
 /**
  * @param {!(Array|Object)} obj the object to resolve.
- * @return {!promise.Promise} A promise that will be resolved with the
+ * @return {!ManagedPromise} A promise that will be resolved with the
  *     input object once all of its values have been fully resolved.
  */
- function fullyResolveKeys(obj) {
-  var isArray = goog.isArray(obj);
-  var numKeys = isArray ? obj.length : Objects.getCount(obj);
+function fullyResolveKeys(obj) {
+  var isArray = Array.isArray(obj);
+  var numKeys = isArray ? obj.length : (function() {
+    let n = 0;
+    for (let key in obj) {
+      n += 1;
+    }
+    return n;
+  })();
   if (!numKeys) {
-    return promise.fulfilled(obj);
+    return fulfilled(obj);
+  }
+
+  function forEachProperty(obj, fn) {
+    for (let key in obj) {
+      fn.call(null, obj[key], key, obj);
+    }
+  }
+
+  function forEachElement(arr, fn) {
+    arr.forEach(fn);
   }
 
   var numResolved = 0;
-  return new promise.Promise(function(fulfill, reject) {
-    // In pre-IE9, goog.array.forEach will not iterate properly over arrays
-    // containing undefined values because "index in array" returns false
-    // when array[index] === undefined (even for x = [undefined, 1]). To get
-    // around this, we need to use our own forEach implementation.
-    // DO NOT REMOVE THIS UNTIL WE NO LONGER SUPPORT IE8. This cannot be
-    // reproduced in IE9 by changing the browser/document modes, it requires an
-    // actual pre-IE9 browser.  Yay, IE!
-    var forEachKey = !isArray ? Objects.forEach : function(arr, fn) {
-      var n = arr.length;
-      for (var i = 0; i < n; ++i) {
-        fn.call(null, arr[i], i, arr);
-      }
-    };
+  return new ManagedPromise(function(fulfill, reject) {
+    var forEachKey = isArray ? forEachElement: forEachProperty;
 
     forEachKey(obj, function(partialValue, key) {
-      var type = goog.typeOf(partialValue);
-      if (type != 'array' && type != 'object') {
+      if (!Array.isArray(partialValue)
+          && (!partialValue || typeof partialValue !== 'object')) {
         maybeResolveValue();
         return;
       }
 
-      promise.fullyResolved(partialValue).then(
+      fullyResolved(partialValue).then(
           function(resolvedValue) {
             obj[key] = resolvedValue;
             maybeResolveValue();
@@ -1881,7 +2010,7 @@ promise.fullyResolved = function(value) {
 
 //////////////////////////////////////////////////////////////////////////////
 //
-//  promise.ControlFlow
+//  ControlFlow
 //
 //////////////////////////////////////////////////////////////////////////////
 
@@ -1893,37 +2022,33 @@ promise.fullyResolved = function(value) {
  * the ordered scheduled, starting each task only once those before it have
  * completed.
  *
- * Each task scheduled within this flow may return a
- * {@link webdriver.promise.Promise} to indicate it is an asynchronous
- * operation. The ControlFlow will wait for such promises to be resolved before
- * marking the task as completed.
+ * Each task scheduled within this flow may return a {@link ManagedPromise} to
+ * indicate it is an asynchronous operation. The ControlFlow will wait for such
+ * promises to be resolved before marking the task as completed.
  *
- * Tasks and each callback registered on a {@link webdriver.promise.Promise}
- * will be run in their own ControlFlow frame.  Any tasks scheduled within a
- * frame will take priority over previously scheduled tasks. Furthermore, if any
- * of the tasks in the frame fail, the remainder of the tasks in that frame will
- * be discarded and the failure will be propagated to the user through the
- * callback/task's promised result.
+ * Tasks and each callback registered on a {@link ManagedPromise} will be run
+ * in their own ControlFlow frame.  Any tasks scheduled within a frame will take
+ * priority over previously scheduled tasks. Furthermore, if any of the tasks in
+ * the frame fail, the remainder of the tasks in that frame will be discarded
+ * and the failure will be propagated to the user through the callback/task's
+ * promised result.
  *
  * Each time a ControlFlow empties its task queue, it will fire an
- * {@link webdriver.promise.ControlFlow.EventType.IDLE IDLE} event. Conversely,
+ * {@link ControlFlow.EventType.IDLE IDLE} event. Conversely,
  * whenever the flow terminates due to an unhandled error, it will remove all
  * remaining tasks in its queue and fire an
- * {@link webdriver.promise.ControlFlow.EventType.UNCAUGHT_EXCEPTION
- * UNCAUGHT_EXCEPTION} event. If there are no listeners registered with the
- * flow, the error will be rethrown to the global error handler.
+ * {@link ControlFlow.EventType.UNCAUGHT_EXCEPTION UNCAUGHT_EXCEPTION} event.
+ * If there are no listeners registered with the flow, the error will be
+ * rethrown to the global error handler.
  *
- * Refer to the {@link webdriver.promise} module documentation for a detailed
+ * Refer to the {@link ./promise} module documentation fora  detailed
  * explanation of how the ControlFlow coordinates task execution.
  *
  * @final
  */
-promise.ControlFlow = goog.defineClass(EventEmitter, {
-  // TODO: remove this empty comment when the compiler properly handles
-  // goog.defineClass with a missing constructor comment.
-  /** @constructor */
-  constructor: function() {
-    promise.ControlFlow.base(this, 'constructor');
+class ControlFlow extends events.EventEmitter {
+  constructor() {
+    super();
 
     /** @private {boolean} */
     this.propagateUnhandledRejections_ = true;
@@ -1937,7 +2062,7 @@ promise.ControlFlow = goog.defineClass(EventEmitter, {
     /**
      * Micro task that controls shutting down the control flow. Upon shut down,
      * the flow will emit an
-     * {@link webdriver.promise.ControlFlow.EventType.IDLE} event. Idle events
+     * {@link ControlFlow.EventType.IDLE} event. Idle events
      * always follow a brief timeout in order to catch latent errors from the
      * last completed task. If this task had a callback registered, but no
      * errback, and the task fails, the unhandled failure would not be reported
@@ -1948,7 +2073,7 @@ promise.ControlFlow = goog.defineClass(EventEmitter, {
      *       function() { return promise.rejected('failed'); });
      *   // Set a callback on the result. This delays reporting the unhandled
      *   // failure for 1 turn of the event loop.
-     *   result.then(goog.nullFunction);
+     *   result.then(function() {});
      *
      * @private {MicroTask}
      */
@@ -1961,28 +2086,27 @@ promise.ControlFlow = goog.defineClass(EventEmitter, {
      * _actually_ something to run. When a control flow is waiting on a task,
      * there will be nothing in the JS event loop and the process would
      * terminate without this.
-     *
-     * @private {?number}
+     * @private
      */
     this.hold_ = null;
-  },
+  }
 
   /**
    * Returns a string representation of this control flow, which is its current
-   * {@link #getSchedule() schedule}, sans task stack traces.
+   * {@linkplain #getSchedule() schedule}, sans task stack traces.
    * @return {string} The string representation of this contorl flow.
    * @override
    */
-  toString: function() {
+  toString() {
     return this.getSchedule();
-  },
+  }
 
   /**
    * Sets whether any unhandled rejections should propagate up through the
    * control flow stack and cause rejections within parent tasks. If error
    * propagation is disabled, tasks will not be aborted when an unhandled
    * promise rejection is detected, but the rejection _will_ trigger an
-   * {@link webdriver.promise.ControlFlow.EventType.UNCAUGHT_EXCEPTION}
+   * {@link ControlFlow.EventType.UNCAUGHT_EXCEPTION}
    * event.
    *
    * The default behavior is to propagate all unhandled rejections. _The use
@@ -1990,26 +2114,26 @@ promise.ControlFlow = goog.defineClass(EventEmitter, {
    *
    * @param {boolean} propagate whether to propagate errors.
    */
-  setPropagateUnhandledRejections: function(propagate) {
+  setPropagateUnhandledRejections(propagate) {
     this.propagateUnhandledRejections_ = propagate;
-  },
+  }
 
   /**
    * @return {boolean} Whether this flow is currently idle.
    */
-  isIdle: function() {
+  isIdle() {
     return !this.shutdownTask_ && (!this.taskQueues_ || !this.taskQueues_.size);
-  },
+  }
 
   /**
    * Resets this instance, clearing its queue and removing all event listeners.
    */
-  reset: function() {
+  reset() {
     this.cancelQueues_(new FlowResetError);
-    this.emit(promise.ControlFlow.EventType.RESET);
+    this.emit(ControlFlow.EventType.RESET);
     this.removeAllListeners();
     this.cancelShutdown_();
-  },
+  }
 
   /**
    * Generates an annotated string describing the internal state of this control
@@ -2020,8 +2144,8 @@ promise.ControlFlow = goog.defineClass(EventEmitter, {
    *     from when each task was scheduled. Defaults to false.
    * @return {string} String representation of this flow's internal state.
    */
-  getSchedule: function(opt_includeStackTraces) {
-    var ret = 'ControlFlow::' + goog.getUid(this);
+  getSchedule(opt_includeStackTraces) {
+    var ret = 'ControlFlow::' + getUid(this);
     var activeQueue = this.activeQueue_;
     if (!this.taskQueues_ || !this.taskQueues_.size) {
       return ret;
@@ -2066,7 +2190,7 @@ promise.ControlFlow = goog.defineClass(EventEmitter, {
       }
       return ret;
     }
-  },
+  }
 
   /**
    * Returns the currently actively task queue for this flow. If there is no
@@ -2074,7 +2198,7 @@ promise.ControlFlow = goog.defineClass(EventEmitter, {
    * @return {!TaskQueue} the currently active task queue for this flow.
    * @private
    */
-  getActiveQueue_: function() {
+  getActiveQueue_() {
     if (this.activeQueue_) {
       return this.activeQueue_;
     }
@@ -2088,45 +2212,46 @@ promise.ControlFlow = goog.defineClass(EventEmitter, {
         .once('end', this.onQueueEnd_, this)
         .once('error', this.onQueueError_, this);
 
-    asyncRun(() => this.activeQueue_ = null, this);
+    asyncRun(() => this.activeQueue_ = null);
     this.activeQueue_.start();
     return this.activeQueue_;
-  },
+  }
 
   /**
    * Schedules a task for execution. If there is nothing currently in the
    * queue, the task will be executed in the next turn of the event loop. If
    * the task function is a generator, the task will be executed using
-   * {@link webdriver.promise.consume}.
+   * {@link ./promise.consume consume()}.
    *
-   * @param {function(): (T|promise.Promise<T>)} fn The function to
+   * @param {function(): (T|ManagedPromise<T>)} fn The function to
    *     call to start the task. If the function returns a
-   *     {@link webdriver.promise.Promise}, this instance will wait for it to be
+   *     {@link ManagedPromise}, this instance will wait for it to be
    *     resolved before starting the next task.
    * @param {string=} opt_description A description of the task.
-   * @return {!promise.Promise<T>} A promise that will be resolved
+   * @return {!ManagedPromise<T>} A promise that will be resolved
    *     with the result of the action.
    * @template T
    */
-  execute: function(fn, opt_description) {
-    if (promise.isGenerator(fn)) {
-      fn = goog.partial(promise.consume, fn);
+  execute(fn, opt_description) {
+    if (isGenerator(fn)) {
+      let original = fn;
+      fn = () => consume(original);
     }
 
     if (!this.hold_) {
       var holdIntervalMs = 2147483647;  // 2^31-1; max timer length for Node.js
-      this.hold_ = setInterval(goog.nullFunction, holdIntervalMs);
+      this.hold_ = setInterval(function() {}, holdIntervalMs);
     }
 
     var task = new Task(
         this, fn, opt_description || '<anonymous>',
-        {name: 'Task', top: promise.ControlFlow.prototype.execute});
+        {name: 'Task', top: ControlFlow.prototype.execute});
 
     var q = this.getActiveQueue_();
     q.enqueue(task);
-    this.emit(promise.ControlFlow.EventType.SCHEDULE_TASK, task.description);
+    this.emit(ControlFlow.EventType.SCHEDULE_TASK, task.description);
     return task.promise;
-  },
+  }
 
   /**
    * Inserts a {@code setTimeout} into the command queue. This is equivalent to
@@ -2134,14 +2259,14 @@ promise.ControlFlow = goog.defineClass(EventEmitter, {
    *
    * @param {number} ms The timeout delay, in milliseconds.
    * @param {string=} opt_description A description to accompany the timeout.
-   * @return {!promise.Promise} A promise that will be resolved with
+   * @return {!ManagedPromise} A promise that will be resolved with
    *     the result of the action.
    */
-  timeout: function(ms, opt_description) {
+  timeout(ms, opt_description) {
     return this.execute(function() {
-      return promise.delayed(ms);
+      return delayed(ms);
     }, opt_description);
-  },
+  }
 
   /**
    * Schedules a task that shall wait for a condition to hold. Each condition
@@ -2151,7 +2276,7 @@ promise.ControlFlow = goog.defineClass(EventEmitter, {
    * Condition functions may schedule sub-tasks with this instance, however,
    * their execution time will be factored into whether a wait has timed out.
    *
-   * In the event a condition returns a Promise, the polling loop will wait for
+   * In the event a condition returns a ManagedPromise, the polling loop will wait for
    * it to be resolved before evaluating whether the condition has been
    * satisfied. The resolution time for a promise is factored into whether a
    * wait has timed out.
@@ -2166,38 +2291,38 @@ promise.ControlFlow = goog.defineClass(EventEmitter, {
    * If this function is invoked with `timeout === 0`, or the timeout is
    * omitted, the flow will wait indefinitely for the condition to be satisfied.
    *
-   * @param {(!promise.Promise<T>|function())} condition The condition to poll,
+   * @param {(!ManagedPromise<T>|function())} condition The condition to poll,
    *     or a promise to wait on.
    * @param {number=} opt_timeout How long to wait, in milliseconds, for the
    *     condition to hold before timing out. If omitted, the flow will wait
    *     indefinitely.
    * @param {string=} opt_message An optional error message to include if the
    *     wait times out; defaults to the empty string.
-   * @return {!promise.Promise<T>} A promise that will be fulfilled
+   * @return {!ManagedPromise<T>} A promise that will be fulfilled
    *     when the condition has been satisified. The promise shall be rejected
    *     if the wait times out waiting for the condition.
    * @throws {TypeError} If condition is not a function or promise or if timeout
    *     is not a number >= 0.
    * @template T
    */
-  wait: function(condition, opt_timeout, opt_message) {
+  wait(condition, opt_timeout, opt_message) {
     var timeout = opt_timeout || 0;
-    if (!goog.isNumber(timeout) || timeout < 0) {
+    if (typeof timeout !== 'number' || timeout < 0) {
       throw TypeError('timeout must be a number >= 0: ' + timeout);
     }
 
-    if (promise.isPromise(condition)) {
+    if (isPromise(condition)) {
       return this.execute(function() {
         if (!timeout) {
           return condition;
         }
-        return new promise.Promise(function(fulfill, reject) {
-          var start = goog.now();
+        return new ManagedPromise(function(fulfill, reject) {
+          var start = Date.now();
           var timer = setTimeout(function() {
             timer = null;
             reject(Error((opt_message ? opt_message + '\n' : '') +
                          'Timed out waiting for promise to resolve after ' +
-                         (goog.now() - start) + 'ms'));
+                         (Date.now() - start) + 'ms'));
           }, timeout);
 
           /** @type {Thenable} */(condition).then(
@@ -2213,25 +2338,26 @@ promise.ControlFlow = goog.defineClass(EventEmitter, {
       }, opt_message || '<anonymous wait: promise resolution>');
     }
 
-    if (!goog.isFunction(condition)) {
+    if (typeof condition !== 'function') {
       throw TypeError('Invalid condition; must be a function or promise: ' +
-                      goog.typeOf(condition));
+          typeof condition);
     }
 
-    if (promise.isGenerator(condition)) {
-      condition = goog.partial(promise.consume, condition);
+    if (isGenerator(condition)) {
+      let original = condition;
+      condition = () => consume(original);
     }
 
     var self = this;
     return this.execute(function() {
-      var startTime = goog.now();
-      return new promise.Promise(function(fulfill, reject) {
+      var startTime = Date.now();
+      return new ManagedPromise(function(fulfill, reject) {
         pollCondition();
 
         function pollCondition() {
           var conditionFn = /** @type {function()} */(condition);
           self.execute(conditionFn).then(function(value) {
-            var elapsed = goog.now() - startTime;
+            var elapsed = Date.now() - startTime;
             if (!!value) {
               fulfill(value);
             } else if (timeout && elapsed >= timeout) {
@@ -2247,7 +2373,7 @@ promise.ControlFlow = goog.defineClass(EventEmitter, {
         }
       });
     }, opt_message || '<anonymous wait>');
-  },
+  }
 
   /**
    * Executes a function in the next available turn of the JavaScript event
@@ -2285,36 +2411,36 @@ promise.ControlFlow = goog.defineClass(EventEmitter, {
    * @param {Object=} opt_self The object in whose context to run the function.
    * @param {...*} var_args Any arguments to pass to the function.
    */
-  async: function(fn, opt_self, var_args) {
-    asyncRun(function() {
+  async(fn, opt_self, var_args) {
+    asyncRun(() => {
       // Clear any lingering queues, forces getActiveQueue_ to create a new one.
       this.activeQueue_ = null;
       var q = this.getActiveQueue_();
       try {
         q.execute_(fn.bind(opt_self, var_args));
       } catch (ex) {
-        var cancellationError = promise.CancellationError.wrap(ex,
+        var cancellationError = CancellationError.wrap(ex,
             'Function passed to ControlFlow.async() threw');
         cancellationError.silent_ = true;
         q.abort_(cancellationError);
       } finally {
         this.activeQueue_ = null;
       }
-    }, this);
-  },
+    });
+  }
 
   /**
    * Event handler for when a task queue is exhausted. This starts the shutdown
    * sequence for this instance if there are no remaining task queues: after
    * one turn of the event loop, this object will emit the
-   * {@link webdriver.promise.ControlFlow.EventType.IDLE IDLE} event to signal
+   * {@link ControlFlow.EventType.IDLE IDLE} event to signal
    * listeners that it has completed. During this wait, if another task is
    * scheduled, the shutdown will be aborted.
    *
    * @param {!TaskQueue} q the completed task queue.
    * @private
    */
-  onQueueEnd_: function(q) {
+  onQueueEnd_(q) {
     if (!this.taskQueues_) {
       return;
     }
@@ -2324,15 +2450,18 @@ promise.ControlFlow = goog.defineClass(EventEmitter, {
     vlog(1, () => this.taskQueues_.size + ' queues remain\n' + this, this);
 
     if (!this.taskQueues_.size) {
-      asserts.assert(!this.shutdownTask_, 'Already have a shutdown task??');
-      this.shutdownTask_ = new MicroTask(this.shutdown_, this);
+      if (this.shutdownTask_) {
+        throw Error('Already have a shutdown task??');
+      }
+      vlog(1, () => 'Scheduling shutdown\n' + this);
+      this.shutdownTask_ = new MicroTask(() => this.shutdown_());
     }
-  },
+  }
 
   /**
    * Event handler for when a task queue terminates with an error. This triggers
    * the cancellation of all other task queues and a
-   * {@link webdriver.promise.ControlFlow.EventType.UNCAUGHT_EXCEPTION} event.
+   * {@link ControlFlow.EventType.UNCAUGHT_EXCEPTION} event.
    * If there are no error event listeners registered with this instance, the
    * error will be rethrown to the global error handler.
    *
@@ -2340,30 +2469,30 @@ promise.ControlFlow = goog.defineClass(EventEmitter, {
    * @param {!TaskQueue} q the task queue.
    * @private
    */
-  onQueueError_: function(error, q) {
+  onQueueError_(error, q) {
     if (this.taskQueues_) {
       this.taskQueues_.delete(q);
     }
-    this.cancelQueues_(promise.CancellationError.wrap(
+    this.cancelQueues_(CancellationError.wrap(
         error, 'There was an uncaught error in the control flow'));
     this.cancelShutdown_();
     this.cancelHold_();
 
     var listeners = this.listeners(
-      promise.ControlFlow.EventType.UNCAUGHT_EXCEPTION);
-    if (!listeners.length) {
-      throwException(error);
+        ControlFlow.EventType.UNCAUGHT_EXCEPTION);
+    if (!listeners.size) {
+      asyncThrow(/** @type {!Error} */(error));
     } else {
       this.reportUncaughtException_(error);
     }
-  },
+  }
 
   /**
    * Cancels all remaining task queues.
-   * @param {!promise.CancellationError} reason The cancellation reason.
+   * @param {!CancellationError} reason The cancellation reason.
    * @private
    */
-  cancelQueues_: function(reason) {
+  cancelQueues_(reason) {
     reason.silent_ = true;
     if (this.taskQueues_) {
       for (var q of this.taskQueues_) {
@@ -2373,53 +2502,53 @@ promise.ControlFlow = goog.defineClass(EventEmitter, {
       this.taskQueues_.clear();
       this.taskQueues_ = null;
     }
-  },
+  }
 
   /**
    * Reports an uncaught exception using a
-   * {@link webdriver.promise.ControlFlow.EventType.UNCAUGHT_EXCEPTION} event.
+   * {@link ControlFlow.EventType.UNCAUGHT_EXCEPTION} event.
    *
    * @param {*} e the error to report.
    * @private
    */
-  reportUncaughtException_: function(e) {
-    this.emit(promise.ControlFlow.EventType.UNCAUGHT_EXCEPTION, e);
-  },
+  reportUncaughtException_(e) {
+    this.emit(ControlFlow.EventType.UNCAUGHT_EXCEPTION, e);
+  }
 
   /** @private */
-  cancelHold_: function() {
+  cancelHold_() {
     if (this.hold_) {
       clearInterval(this.hold_);
       this.hold_ = null;
     }
-  },
+  }
 
   /** @private */
-  shutdown_: function() {
+  shutdown_() {
     vlog(1, () => 'Going idle: ' + this);
     this.cancelHold_();
     this.shutdownTask_ = null;
-    this.emit(promise.ControlFlow.EventType.IDLE);
-  },
+    this.emit(ControlFlow.EventType.IDLE);
+  }
 
   /**
    * Cancels the shutdown sequence if it is currently scheduled.
    * @private
    */
-  cancelShutdown_: function() {
+  cancelShutdown_() {
     if (this.shutdownTask_) {
       this.shutdownTask_.cancel();
       this.shutdownTask_ = null;
     }
   }
-});
+}
 
 
 /**
- * Events that may be emitted by an {@link webdriver.promise.ControlFlow}.
+ * Events that may be emitted by an {@link ControlFlow}.
  * @enum {string}
  */
-promise.ControlFlow.EventType = {
+ControlFlow.EventType = {
 
   /** Emitted when all tasks have been successfully executed. */
   IDLE: 'idle',
@@ -2444,56 +2573,67 @@ promise.ControlFlow.EventType = {
  * Wraps a function to execute as a cancellable micro task.
  * @final
  */
-var MicroTask = goog.defineClass(null, {
+class MicroTask {
   /**
-   * @param {function(this: THIS)} fn The function to run as a micro task.
-   * @param {THIS=} opt_scope The scope to run the function in.
-   * @template THIS
+   * @param {function()} fn The function to run as a micro task.
    */
-  constructor: function(fn, opt_scope) {
+  constructor(fn) {
     /** @private {boolean} */
     this.cancelled_ = false;
-    asyncRun(function() {
+    asyncRun(() => {
       if (!this.cancelled_) {
-        fn.call(opt_scope);
+        fn();
       }
-    }, this);
-  },
+    });
+  }
+
+  /**
+   * Runs the given function after a micro-task yield.
+   * @param {function()} fn The function to run.
+   */
+  static run(fn) {
+    NativePromise.resolve().then(function() {
+      try {
+        fn();
+      } catch (ignored) {
+        // Do nothing.
+      }
+    });
+  }
 
   /**
    * Cancels the execution of this task. Note: this will not prevent the task
    * timer from firing, just the invocation of the wrapped function.
    */
-  cancel: function() {
+  cancel() {
     this.cancelled_ = true;
   }
-});
+}
 
 
 /**
- * A task to be executed by a {@link webdriver.promise.ControlFlow}.
+ * A task to be executed by a {@link ControlFlow}.
  *
+ * @template T
  * @final
  */
-var Task = goog.defineClass(promise.Deferred, {
+class Task extends Deferred {
   /**
-   * @param {!promise.ControlFlow} flow The flow this instances belongs
+   * @param {!ControlFlow} flow The flow this instances belongs
    *     to.
-   * @param {function(): (T|!promise.Promise<T>)} fn The function to
+   * @param {function(): (T|!ManagedPromise<T>)} fn The function to
    *     call when the task executes. If it returns a
-   *     {@link webdriver.promise.Promise}, the flow will wait for it to be
+   *     {@link ManagedPromise}, the flow will wait for it to be
    *     resolved before starting the next task.
    * @param {string} description A description of the task for debugging.
    * @param {{name: string, top: !Function}=} opt_stackOptions Options to use
    *     when capturing the stacktrace for when this task was created.
-   * @constructor
-   * @extends {promise.Deferred<T>}
-   * @template T
    */
-  constructor: function(flow, fn, description, opt_stackOptions) {
-    Task.base(this, 'constructor', flow);
+  constructor(flow, fn, description, opt_stackOptions) {
+    super(flow);
+    getUid(this);
 
-    /** @type {function(): (T|!promise.Promise<T>)} */
+    /** @type {function(): (T|!ManagedPromise<T>)} */
     this.execute = fn;
 
     /** @type {string} */
@@ -2519,20 +2659,20 @@ var Task = goog.defineClass(promise.Deferred, {
     this.blocked = false;
 
     if (opt_stackOptions) {
-      this.promise.stack_ = promise.captureStackTrace(
+      this.promise.stack_ = captureStackTrace(
           opt_stackOptions.name, this.description, opt_stackOptions.top);
     }
-  },
+  }
 
   /** @override */
-  toString: function() {
-    return 'Task::' + goog.getUid(this) + '<' + this.description + '>';
+  toString() {
+    return 'Task::' + getUid(this) + '<' + this.description + '>';
   }
-});
+}
 
 
 /** @enum {string} */
-var TaskQueueState = {
+const TaskQueueState = {
   NEW: 'new',
   STARTED: 'started',
   FINISHED: 'finished'
@@ -2542,16 +2682,15 @@ var TaskQueueState = {
 /**
  * @final
  */
-var TaskQueue = goog.defineClass(EventEmitter, {
-  /** @param {!promise.ControlFlow} flow . */
-  constructor: function(flow) {
-    TaskQueue.base(this, 'constructor');
-    goog.getUid(this);
+class TaskQueue extends events.EventEmitter {
+  /** @param {!ControlFlow} flow . */
+  constructor(flow) {
+    super();
 
     /** @private {string} */
-    this.name_ = 'TaskQueue::' + goog.getUid(this);
+    this.name_ = 'TaskQueue::' + getUid(this);
 
-    /** @private {!promise.ControlFlow} */
+    /** @private {!ControlFlow} */
     this.flow_ = flow;
 
     /** @private {!Array<!Task>} */
@@ -2566,41 +2705,41 @@ var TaskQueue = goog.defineClass(EventEmitter, {
     /** @private {TaskQueueState} */
     this.state_ = TaskQueueState.NEW;
 
-    /** @private {!Set<!webdriver.promise.Promise>} */
+    /** @private {!Set<!ManagedPromise>} */
     this.unhandledRejections_ = new Set();
-  },
+  }
 
   /** @override */
-  toString: function() {
-    return 'TaskQueue::' + goog.getUid(this);
-  },
+  toString() {
+    return 'TaskQueue::' + getUid(this);
+  }
 
   /**
-   * @param {!webdriver.promise.Promise} promise .
+   * @param {!ManagedPromise} promise .
    */
-  addUnhandledRejection: function(promise) {
+  addUnhandledRejection(promise) {
     // TODO: node 4.0.0+
     vlog(2, () => this + ' registering unhandled rejection: ' + promise, this);
     this.unhandledRejections_.add(promise);
-  },
+  }
 
   /**
-   * @param {!webdriver.promise.Promise} promise .
+   * @param {!ManagedPromise} promise .
    */
-  clearUnhandledRejection: function(promise) {
+  clearUnhandledRejection(promise) {
     var deleted = this.unhandledRejections_.delete(promise);
     if (deleted) {
       // TODO: node 4.0.0+
       vlog(2, () => this + ' clearing unhandled rejection: ' + promise, this);
     }
-  },
+  }
 
   /**
    * Enqueues a new task for execution.
    * @param {!Task} task The task to enqueue.
    * @throws {Error} If this instance has already started execution.
    */
-  enqueue: function(task) {
+  enqueue(task) {
     if (this.state_ !== TaskQueueState.NEW) {
       throw Error('TaskQueue has started: ' + this);
     }
@@ -2616,16 +2755,16 @@ var TaskQueue = goog.defineClass(EventEmitter, {
 
     vlog(1, () => this + '.enqueue(' + task + ')', this);
     vlog(2, () => this.flow_.toString(), this);
-  },
+  }
 
   /**
    * Schedules the callbacks registered on the given promise in this queue.
    *
-   * @param {!promise.Promise} promise the promise whose callbacks should be
+   * @param {!ManagedPromise} promise the promise whose callbacks should be
    *     registered as interrupts in this task queue.
    * @throws {Error} if this queue has already finished.
    */
-  scheduleCallbacks: function(promise) {
+  scheduleCallbacks(promise) {
     if (this.state_ === TaskQueueState.FINISHED) {
       throw new Error('cannot interrupt a finished q(' + this + ')');
     }
@@ -2633,7 +2772,7 @@ var TaskQueue = goog.defineClass(EventEmitter, {
     if (this.pending_ && this.pending_.task.promise === promise) {
       this.pending_.task.promise.queue_ = null;
       this.pending_ = null;
-      asyncRun(this.executeNext_, this);
+      asyncRun(() => this.executeNext_());
     }
 
     if (!promise.callbacks_) {
@@ -2663,7 +2802,7 @@ var TaskQueue = goog.defineClass(EventEmitter, {
     }, this);
     promise.callbacks_ = null;
     vlog(2, () => this + ' interrupted\n' + this.flow_, this);
-  },
+  }
 
   /**
    * Starts executing tasks in this queue. Once called, no further tasks may
@@ -2671,15 +2810,15 @@ var TaskQueue = goog.defineClass(EventEmitter, {
    *
    * @throws {Error} if this queue has already been started.
    */
-  start: function() {
+  start() {
     if (this.state_ !== TaskQueueState.NEW) {
       throw new Error('TaskQueue has already started');
     }
     // Always asynchronously execute next, even if there doesn't look like
     // there is anything in the queue. This will catch pending unhandled
     // rejections that were registered before start was called.
-    asyncRun(this.executeNext_, this);
-  },
+    asyncRun(() => this.executeNext_());
+  }
 
   /**
    * Aborts this task queue. If there are any scheduled tasks, they are silently
@@ -2690,7 +2829,7 @@ var TaskQueue = goog.defineClass(EventEmitter, {
    * @param {*} error The abortion reason.
    * @private
    */
-  abort_: function(error) {
+  abort_(error) {
     var cancellation;
 
     if (error instanceof FlowResetError) {
@@ -2711,23 +2850,22 @@ var TaskQueue = goog.defineClass(EventEmitter, {
 
     if (this.pending_) {
       vlog(2, () => this + '.abort(); cancelling pending task', this);
-      this.pending_.task.cancel(
-          /** @type {!webdriver.promise.CancellationError} */(error));
+      this.pending_.task.cancel(/** @type {!CancellationError} */(error));
 
     } else {
       vlog(2, () => this + '.abort(); emitting error event', this);
       this.emit('error', error, this);
     }
-  },
+  }
 
   /** @private */
-  executeNext_: function() {
+  executeNext_() {
     if (this.state_ === TaskQueueState.FINISHED) {
       return;
     }
     this.state_ = TaskQueueState.STARTED;
 
-    if (this.pending_ != null || this.processUnhandledRejections_()) {
+    if (this.pending_ !== null || this.processUnhandledRejections_()) {
       return;
     }
 
@@ -2760,8 +2898,7 @@ var TaskQueue = goog.defineClass(EventEmitter, {
     } catch (ex) {
       subQ.abort_(ex);
     }
-  },
-
+  }
 
   /**
    * @param {!Function} fn .
@@ -2769,7 +2906,7 @@ var TaskQueue = goog.defineClass(EventEmitter, {
    * @template T
    * @private
    */
-  execute_: function(fn) {
+  execute_(fn) {
     try {
       activeFlows.push(this.flow_);
       this.flow_.activeQueue_ = this;
@@ -2778,17 +2915,17 @@ var TaskQueue = goog.defineClass(EventEmitter, {
       this.flow_.activeQueue_ = null;
       activeFlows.pop();
     }
-  },
+  }
 
   /**
    * Process any unhandled rejections registered with this task queue. If there
    * is a rejection, this queue will be aborted with the rejection error. If
    * there are multiple rejections registered, this queue will be aborted with
-   * a {@link promise.MultipleUnhandledRejectionError}.
+   * a {@link MultipleUnhandledRejectionError}.
    * @return {boolean} whether there was an unhandled rejection.
    * @private
    */
-  processUnhandledRejections_: function() {
+  processUnhandledRejections_() {
     if (!this.unhandledRejections_.size) {
       return false;
     }
@@ -2801,7 +2938,7 @@ var TaskQueue = goog.defineClass(EventEmitter, {
 
     var errorToReport = errors.size === 1
         ? errors.values().next().value
-        : new promise.MultipleUnhandledRejectionError(errors);
+        : new MultipleUnhandledRejectionError(errors);
 
     vlog(1, () => this + ' aborting due to unhandled rejections', this);
     if (this.flow_.propagateUnhandledRejections_) {
@@ -2812,13 +2949,13 @@ var TaskQueue = goog.defineClass(EventEmitter, {
       this.flow_.reportUncaughtException_(errorToReport);
       return false;
     }
-  },
+  }
 
   /**
    * @param {!Task} task The task to drop.
    * @private
    */
-  dropTask_: function(task) {
+  dropTask_(task) {
     var index;
     if (this.interrupts_) {
       index = this.interrupts_.indexOf(task);
@@ -2834,49 +2971,49 @@ var TaskQueue = goog.defineClass(EventEmitter, {
       task.queue = null;
       this.tasks_.splice(index, 1);
     }
-  },
+  }
 
   /**
    * @param {!Task} task The task that was cancelled.
-   * @param {!promise.CancellationError} reason The cancellation reason.
+   * @param {!CancellationError} reason The cancellation reason.
    * @private
    */
-  onTaskCancelled_: function(task, reason) {
+  onTaskCancelled_(task, reason) {
     if (this.pending_ && this.pending_.task === task) {
       this.pending_.q.abort_(reason);
     } else {
       this.dropTask_(task);
     }
-  },
+  }
 
   /**
    * @param {*} value the value originally returned by the task function.
    * @private
    */
-  onTaskComplete_: function(value) {
+  onTaskComplete_(value) {
     if (this.pending_) {
       this.pending_.task.fulfill(value);
     }
-  },
+  }
 
   /**
    * @param {*} taskFnResult the value originally returned by the task function.
    * @param {*} error the error that caused the task function to terminate.
    * @private
    */
-  onTaskFailure_: function(taskFnResult, error) {
-    if (promise.Thenable.isImplementation(taskFnResult)) {
-      taskFnResult.cancel(promise.CancellationError.wrap(error));
+  onTaskFailure_(taskFnResult, error) {
+    if (Thenable.isImplementation(taskFnResult)) {
+      taskFnResult.cancel(CancellationError.wrap(error));
     }
     this.pending_.task.reject(error);
-  },
+  }
 
   /**
    * @return {(Task|undefined)} the next task scheduled within this queue,
    *     if any.
    * @private
    */
-  getNextTask_: function() {
+  getNextTask_() {
     var task = undefined;
     while (true) {
       if (this.interrupts_) {
@@ -2896,15 +3033,15 @@ var TaskQueue = goog.defineClass(EventEmitter, {
     }
     return task;
   }
-});
+};
 
 
 
 /**
  * The default flow to use if no others are active.
- * @type {!promise.ControlFlow}
+ * @type {!ControlFlow}
  */
-var defaultFlow = new promise.ControlFlow();
+var defaultFlow = new ControlFlow();
 
 
 /**
@@ -2912,48 +3049,48 @@ var defaultFlow = new promise.ControlFlow();
  * commands. When there are multiple flows on the stack, the flow at index N
  * represents a callback triggered within a task owned by the flow at index
  * N-1.
- * @type {!Array<!promise.ControlFlow>}
+ * @type {!Array<!ControlFlow>}
  */
 var activeFlows = [];
 
 
 /**
  * Changes the default flow to use when no others are active.
- * @param {!promise.ControlFlow} flow The new default flow.
+ * @param {!ControlFlow} flow The new default flow.
  * @throws {Error} If the default flow is not currently active.
  */
-promise.setDefaultFlow = function(flow) {
+function setDefaultFlow(flow) {
   if (activeFlows.length) {
     throw Error('You may only change the default flow while it is active');
   }
   defaultFlow = flow;
-};
+}
 
 
 /**
- * @return {!promise.ControlFlow} The currently active control flow.
+ * @return {!ControlFlow} The currently active control flow.
  */
-promise.controlFlow = function() {
-  return /** @type {!promise.ControlFlow} */ (
-      Arrays.peek(activeFlows) || defaultFlow);
-};
+function controlFlow() {
+  return /** @type {!ControlFlow} */ (
+      activeFlows.length ? activeFlows[activeFlows.length - 1] : defaultFlow);
+}
 
 
 /**
  * Creates a new control flow. The provided callback will be invoked as the
  * first task within the new flow, with the flow as its sole argument. Returns
  * a promise that resolves to the callback result.
- * @param {function(!promise.ControlFlow)} callback The entry point
+ * @param {function(!ControlFlow)} callback The entry point
  *     to the newly created flow.
- * @return {!promise.Promise} A promise that resolves to the callback
+ * @return {!ManagedPromise} A promise that resolves to the callback
  *     result.
  */
-promise.createFlow = function(callback) {
-  var flow = new promise.ControlFlow;
+function createFlow(callback) {
+  var flow = new ControlFlow;
   return flow.execute(function() {
     return callback(flow);
   });
-};
+}
 
 
 /**
@@ -2961,9 +3098,9 @@ promise.createFlow = function(callback) {
  * @param {!Function} fn The function to test.
  * @return {boolean} Whether the function is a generator.
  */
-promise.isGenerator = function(fn) {
+function isGenerator(fn) {
   return fn.constructor.name === 'GeneratorFunction';
-};
+}
 
 
 /**
@@ -2992,7 +3129,7 @@ promise.isGenerator = function(fn) {
  *       yield promise.delayed(250).then(function() {
  *         throw Error('boom');
  *       });
- *     }).thenCatch(function(e) {
+ *     }).catch(function(e) {
  *       console.log(e.toString());  // Error: boom
  *     });
  *
@@ -3000,18 +3137,19 @@ promise.isGenerator = function(fn) {
  * @param {Object=} opt_self The object to use as "this" when invoking the
  *     initial generator.
  * @param {...*} var_args Any arguments to pass to the initial generator.
- * @return {!promise.Promise<?>} A promise that will resolve to the
+ * @return {!ManagedPromise<?>} A promise that will resolve to the
  *     generator's final result.
  * @throws {TypeError} If the given function is not a generator.
  */
-promise.consume = function(generatorFn, opt_self, var_args) {
-  if (!promise.isGenerator(generatorFn)) {
+function consume(generatorFn, opt_self, var_args) {
+  if (!isGenerator(generatorFn)) {
     throw new TypeError('Input is not a GeneratorFunction: ' +
         generatorFn.constructor.name);
   }
 
-  var deferred = promise.defer();
-  var generator = generatorFn.apply(opt_self, Arrays.slice(arguments, 2));
+  var deferred = defer();
+  var generator = generatorFn.apply(
+      opt_self, Array.prototype.slice.call(arguments, 2));
   callNext();
   return deferred.promise;
 
@@ -3044,6 +3182,41 @@ promise.consume = function(generatorFn, opt_self, var_args) {
       return;
     }
 
-    promise.asap(result.value, callNext, callThrow);
+    asap(result.value, callNext, callThrow);
   }
+}
+
+
+// PUBLIC API
+
+
+module.exports = {
+  CancellationError: CancellationError,
+  ControlFlow: ControlFlow,
+  Deferred: Deferred,
+  MultipleUnhandledRejectionError: MultipleUnhandledRejectionError,
+  Thenable: Thenable,
+  Promise: ManagedPromise,
+  all: all,
+  asap: asap,
+  captureStackTrace: captureStackTrace,
+  checkedNodeCall: checkedNodeCall,
+  consume: consume,
+  controlFlow: controlFlow,
+  createFlow: createFlow,
+  defer: defer,
+  delayed: delayed,
+  filter: filter,
+  fulfilled: fulfilled,
+  fullyResolved: fullyResolved,
+  isGenerator: isGenerator,
+  isPromise: isPromise,
+  map: map,
+  rejected: rejected,
+  setDefaultFlow: setDefaultFlow,
+  thenFinally: thenFinally,
+  when: when,
+
+  get LONG_STACK_TRACES() { return LONG_STACK_TRACES; },
+  set LONG_STACK_TRACES(v) { LONG_STACK_TRACES = v; },
 };