Store zone in microtask entry.

sdk/lib/async/schedule_microtask.dart

 // Copyright (c) 2013, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 part of dart.async;
 
 typedef void _AsyncCallback();
 
 class _AsyncCallbackEntry {
   final _AsyncCallback callback;
+  final Zone zone;
   _AsyncCallbackEntry next;
-  _AsyncCallbackEntry(this.callback);
+  _AsyncCallbackEntry(this.callback, this.zone);
 }
 
 /** Head of single linked list of pending callbacks. */
 _AsyncCallbackEntry _nextCallback;
 /** Tail of single linked list of pending callbacks. */
 _AsyncCallbackEntry _lastCallback;
 /**
  * Tail of priority callbacks added by the currently executing callback.
  *
  * Priority callbacks are put at the beginning of the
  * callback queue, so that if one callback schedules more than one
  * priority callback, they are still enqueued in scheduling order.
  */
 _AsyncCallbackEntry _lastPriorityCallback;
 /**
  * Whether we are currently inside the callback loop.
  *
  * If we are inside the loop, we never need to schedule the loop,
  * even if adding a first element.
  */
 bool _isInCallbackLoop = false;
 
-void _asyncRunCallbackLoop() {
+void _microtaskLoop() {
   while (_nextCallback != null) {
     _lastPriorityCallback = null;
     _AsyncCallbackEntry entry = _nextCallback;
     _nextCallback = entry.next;
     if (_nextCallback == null) _lastCallback = null;
+    Zone._current = entry.zone;
     entry.callback();
   }
 }
 
-void _asyncRunCallback() {
+void _microtaskLoopEntry() {
   _isInCallbackLoop = true;
   try {
-    _asyncRunCallbackLoop();
+    // Moved to separate function because try-finally prevents
+    // good optimization.
+    _microtaskLoop();
   } finally {
+    Zone._current = _ROOT_ZONE;
     _lastPriorityCallback = null;
     _isInCallbackLoop = false;
-    if (_nextCallback != null) _AsyncRun._scheduleImmediate(_asyncRunCallback);
+    if (_nextCallback != null) {
+      _AsyncRun._scheduleImmediate(_microtaskLoopEntry);
+    }
   }
 }
 
 /**
  * Schedules a callback to be called as a microtask.
  *
  * The microtask is called after all other currently scheduled
  * microtasks, but as part of the current system event.
  */
-void _scheduleAsyncCallback(callback) {
+void _scheduleAsyncCallback(_AsyncCallbackEntry newEntry) {
   // Optimizing a group of Timer.run callbacks to be executed in the
   // same Timer callback.

[Ivan Posva, 2015/02/02 16:06:47]

I am not clear what this comment is trying to tell me about Timer.run. Where and
what is this optimization?

[Lasse Reichstein Nielsen, 2015/02/23 08:01:39]

I think the timer is long, long gone. This comment has been outdated since we
introduced the _scheduleImmeditate function.

   if (_nextCallback == null) {
-    _nextCallback = _lastCallback = new _AsyncCallbackEntry(callback);
+    _nextCallback = _lastCallback = newEntry;
     if (!_isInCallbackLoop) {
-      _AsyncRun._scheduleImmediate(_asyncRunCallback);
+      _AsyncRun._scheduleImmediate(_microtaskLoopEntry);
     }
   } else {
-    _AsyncCallbackEntry newEntry = new _AsyncCallbackEntry(callback);
     _lastCallback.next = newEntry;
     _lastCallback = newEntry;
   }
 }
 
 /**
  * Schedules a callback to be called before all other currently scheduled ones.
  *
  * This callback takes priority over existing scheduled callbacks.
  * It is only used internally to give higher priority to error reporting.
+ *
+ * Is always run in the root zone.
  */
 void _schedulePriorityAsyncCallback(callback) {
-  _AsyncCallbackEntry entry = new _AsyncCallbackEntry(callback);
+  _AsyncCallbackEntry entry =
+      new _AsyncCallbackEntry(callback, _ROOT_ZONE);
   if (_nextCallback == null) {
-    _scheduleAsyncCallback(callback);
+    _scheduleAsyncCallback(entry);
     _lastPriorityCallback = _lastCallback;
   } else if (_lastPriorityCallback == null) {
     entry.next = _nextCallback;
     _nextCallback = _lastPriorityCallback = entry;
   } else {
     entry.next = _lastPriorityCallback.next;
     _lastPriorityCallback.next = entry;
     _lastPriorityCallback = entry;
     if (entry.next == null) {
       _lastCallback = entry;
@@ skipping 20 matching lines @@
  *       foo();
  *     }
  *
  * ## Other resources
  *
  * * [The Event Loop and Dart](https://www.dartlang.org/articles/event-loop/):
  * Learn how Dart handles the event queue and microtask queue, so you can write
  * better asynchronous code with fewer surprises.
  */
 void scheduleMicrotask(void callback()) {
-  if (identical(_ROOT_ZONE, Zone.current)) {
+  Zone currentZone = Zone.current;
+  if (identical(_ROOT_ZONE, currentZone)) {
     // No need to bind the callback. We know that the root's scheduleMicrotask
     // will be invoked in the root zone.
     _rootScheduleMicrotask(null, null, _ROOT_ZONE, callback);
     return;
   }
+  _ZoneFunction implementation = currentZone._scheduleMicrotask;
+  if (identical(_ROOT_ZONE, implementation.zone) &&
+      _ROOT_ZONE.inSameErrorZone(currentZone)) {
+    _rootScheduleMicrotask(null, null, currentZone,
+                           currentZone.registerCallback(callback));
+    return;
+  }
   Zone.current.scheduleMicrotask(
       Zone.current.bindCallback(callback, runGuarded: true));
 }
 
 class _AsyncRun {
   /** Schedule the given callback before any other event in the event-loop. */
   external static void _scheduleImmediate(void callback());
 }