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:   int _runningInTurn = 0;
  
    /**
     * A function called with any errors from the zone.
     */
    var onError = (e, s, ls) => print('$e\n$s\n$ls');
  
    /**
     * A function that is called at the end of each VM turn in which the
     * in-zone code or any runAsync callbacks were run.
     */
    var onTurnDone = () => null;  // Type was ZoneOnTurn: dartbug 13519
  
    /**
     * A function that is called when uncaught errors are thrown inside the zone.
     */
    // var onError = (dynamic e, dynamic s, LongStackTrace ls) => print('EXCEPTION: $e\n$s\n$ls');
    // Type was ZoneOnError: dartbug 13519
  
    LongStackTrace _longStacktrace = null;
  
  
negative.code:   }
  
    /**
     * Runs [body] in the inner zone and returns whatever it returns.
     */
    dynamic run(body()) => _innerZone.run(body);
  
    /**
     * Runs [body] in the outer zone and returns whatever it returns.
     * In a typical app where the inner zone is the Angular zone, this allows
     * one to escape Angular's auto-digest mechanism.
     *
     *     myFunction(NgZone zone, Element element) {
     *       element.onClick.listen(() {
  