anchor.diff:  }
   
   /**
  - * A better zone API which implements onTurnDone.
  + * A [Zone] wrapper that lets you schedule tasks after its private microtask
  + * queue is exhausted but before the next "turn", i.e. event loop iteration.
  + * This lets you freely schedule microtasks that prepare data, and set an
  + * [onTurnDone] handler that will consume that data after it's ready but before
  + * the browser has a chance to re-render.
  + * The wrapper maintains an "inner" and "outer" [Zone] and a private queue of
  + * all the microtasks scheduled on the inner [Zone].
  + *
  + * In a typical app, [ngDynamicApp] or [ngStaticApp] will create a singleton
  + * [NgZone] whose outer [Zone] is the root [Zone] and whose default [onTurnDone]
  + * runs the Angular digest.  A component may want to inject this singleton if it
  + * needs to run code _outside_ the Angular digest.
    */
   class NgZone {
  -  final async.Zone _outerZone = async.Zone.current;
  -  async.Zone _zone;
  -
  +  /// an "outer" [Zone], which is the one that created this.
  +  async.Zone _outerZone;
  +
  +  /// an "inner" [Zone], which is a child of the outer [Zone].
  +  async.Zone _innerZone;
  +
  +  /**
  +   * Associates with this
  +   *
  +   * Defaults [onError] to forward errors to the outer [Zone].
  +   * Defaults [onTurnDone] to a no-op.
  +   */
     NgZone() {
  -    _zone = _outerZone.fork(specification: new async.ZoneSpecification(
  +    _outerZone = async.Zone.current;
  +    _innerZone = _outerZone.fork(specification: new async.ZoneSpecification(
           run: _onRun,
           runUnary: _onRunUnary,
           scheduleMicrotask: _onScheduleMicrotask,
           handleUncaughtError: _uncaughtError
       ));
  -    // Prevent silently ignoring uncaught exceptions by forwarding such
  -    // exceptions to the outer zone by default.
  -    onError = (e, s, ls) => _outerZone.handleUncaughtError(e, s);
  -  }
  -
  +    onError = _defaultOnError;
  +    onTurnDone = _defaultOnTurnDone;
  +  }
   
     List _asyncQueue = [];
     bool _errorThrownFromOnRun = false;
  
positive.code:   }
  
    /**
     * Runs the provided function in the zone.  Any runAsync calls (e.g. futures)
     * will also be run in this zone.
     *
     * Returns the return value of body.
     */
    dynamic run(body()) => _zone.run(body);
  
    /**
     * Allows one to escape the auto-digest mechanism of Angular.
     *
     *     myFunction(NgZone zone, Element element) {
     *       element.onClick.listen(() {
  
negative.code:   int _runningInTurn = 0;
  
    /**
     * Called with any errors from the inner zone.
     */
    ZoneOnError onError;
  
    /// Prevent silently ignoring uncaught exceptions by forwarding such exceptions to the outer zone.
    void _defaultOnError(dynamic e, dynamic s, LongStackTrace ls) =>
        _outerZone.handleUncaughtError(e, s);
  
    /**
     * Called at the end of each VM turn in which inner zone code runs.
     * "At the end" means after the private microtask queue of the inner zone is
     * exhausted but before the next VM turn.  Notes
     * - This won't wait for microtasks scheduled in zones other than the inner
     *   zone, e.g. those scheduled with [runOutsideAngular].
     * - [onTurnDone] runs repeatedly until it fails to schedule any more
     *   microtasks, so you usually don't want it to schedule any.  For example,
     *   if its first line of code is `new Future.value()`, the turn will _never_
     *   end.
     */
    ZoneOnTurn onTurnDone;
    void _defaultOnTurnDone() => null;
  
    LongStackTrace _longStacktrace = null;
  
  