Simplify scheduleMicrotask.

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, this.zone);
+  _AsyncCallbackEntry(this.callback);
 }
 
 /** 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 _microtaskLoop() {
   while (_nextCallback != null) {
     _lastPriorityCallback = null;
     _AsyncCallbackEntry entry = _nextCallback;
     _nextCallback = entry.next;
     if (_nextCallback == null) _lastCallback = null;
-    Zone._current = entry.zone;
-    entry.callback();
+    (entry.callback)();

[Lasse Reichstein Nielsen, 2015/12/02 06:49:22]

Are you sure we shouldn't be setting the zone here and not binding the callback
instead. 
Seems overkill to create an extra closure for each microtask, and I think this
was my original plan.
On the other hand, the zone is currently just overhead, and if I decide to use
it, I can reintroduce it then.

[floitsch, 2015/12/02 06:56:35]

It is possible, but not trivial.
Currently, we call zone.bindCallback, if _rootScheduleMicrotask is run with a
Zone.current that is not the root-zone.
So, if we are in the root-zone, then nothing happens and we are fine anyway.
If we are in a zone, we need to pay attention that the zone doesn't override any
function that is invoked by `bindCallback`. That is feasible (since
ZoneSpecifications allow us to do that), but slightly more complicated than what
we have currently. I'm not sure it's worth it.
I still hope that the root-zone is the more common case.

Also, I find this change convenient, since it allowed me to propose exposing the
_schedule functions below to the embedder (which would otherwise be much more
complicated).

Finally: I'm not 100% sure that we don't need to set the zone to the root-zone,
but in theory every zone is reset after a Zone.run. So that should be ok. But I
can set it explicitly to the Root-zone again.

   }
 }
 
-void _microtaskLoopEntry() {
+void _startMicrotaskLoop() {
   _isInCallbackLoop = true;
   try {
     // Moved to separate function because try-finally prevents
     // good optimization.

[Lasse Reichstein Nielsen, 2015/12/02 06:49:22]

Side-comment: This (still) really sucks!
If moving code to a separate function makes the code run faster, the compiler
should be doing it for you.

[floitsch, 2015/12/02 06:56:35]

I'm not even sure if it still is slower..

     _microtaskLoop();
   } finally {
-    Zone._current = _ROOT_ZONE;
     _lastPriorityCallback = null;
     _isInCallbackLoop = false;
     if (_nextCallback != null) {
-      _AsyncRun._scheduleImmediate(_microtaskLoopEntry);
+      _AsyncRun._scheduleImmediate(_startMicrotaskLoop);
     }
   }
 }
 
 /**
  * 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(_AsyncCallbackEntry newEntry) {
+void _scheduleAsyncCallback(_AsyncCallback callback) {
+  _AsyncCallbackEntry newEntry = new _AsyncCallbackEntry(callback);
   if (_nextCallback == null) {
     _nextCallback = _lastCallback = newEntry;
     if (!_isInCallbackLoop) {
-      _AsyncRun._scheduleImmediate(_microtaskLoopEntry);
+      _AsyncRun._scheduleImmediate(_startMicrotaskLoop);
     }
   } else {
     _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, _ROOT_ZONE);
   if (_nextCallback == null) {
-    _scheduleAsyncCallback(entry);
+    _scheduleAsyncCallback(callback);
     _lastPriorityCallback = _lastCallback;
-  } else if (_lastPriorityCallback == null) {
+    return;
+  }
+  _AsyncCallbackEntry entry = new _AsyncCallbackEntry(callback);
+  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 40 matching lines @@
     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());
 }