Simplify scheduleMicrotask.

sdk/lib/async/schedule_microtask.dart

Index: sdk/lib/async/schedule_microtask.dart
diff --git a/sdk/lib/async/schedule_microtask.dart b/sdk/lib/async/schedule_microtask.dart
index acc4036ee7fa2e60646f64ebdbfba7aa639f4ddc..fac3f7f031128310614845322253ea1d796f4509 100644
--- a/sdk/lib/async/schedule_microtask.dart
+++ b/sdk/lib/async/schedule_microtask.dart
@@ -8,9 +8,8 @@ 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. */
@@ -39,23 +38,21 @@ void _microtaskLoop() {
     _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);
     }
   }
 }
@@ -66,11 +63,12 @@ void _microtaskLoopEntry() {
  * 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;
@@ -87,12 +85,13 @@ void _scheduleAsyncCallback(_AsyncCallbackEntry newEntry) {
  * 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 {