Rename runAsync to scheduleMicrotask.

pkg/mdv/lib/src/input_bindings.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 mdv;
 
 abstract class _InputBinding extends NodeBinding {
   StreamSubscription _eventSub;
 
   _InputBinding(node, name, model, path): super(node, name, model, path) {
@@ skipping 133 matching lines @@
     }
 
     // The binding may wish to bind to an <option> which has not yet been
     // produced by a child <template>. Furthermore, we may need to wait for
     // <optgroup> iterating and then for <option>.
     //
     // Unlike the JavaScript MDV, we don't have a special "Object.observe" event
     // loop to schedule on. (See the the "ensureScheduled" function:
     // https://github.com/Polymer/mdv/commit/9a51ad7ed74a292bf71662cea28acbd151ff65c8)
     //
-    // Instead we use runAsync. Each <template repeat> needs a delay of 2:
+    // Instead we use scheduleMicrotask. Each <template repeat> needs a delay of
+    // 2:

[Lasse Reichstein Nielsen, 2013/10/07 07:17:03]

This is extremely fragile, and depends on the exact order of the microtask
queue. If something else becomes async, it may fail inexplicably.
I'd prefer if it was abstracted into something that explicitly handled its own
queuing, with a "run a after b" scheduling.

[floitsch, 2013/10/10 16:00:36]

Filed dartbug.com/13968

     //   * once to happen after the child _TemplateIterator is created
     //   * once to be after _TemplateIterator.inputs CompoundBinding resolve
     // And then we need to do this delay sequence twice:
     //   * once for OPTGROUP
     //   * once for OPTION.
     // The resulting 2 * 2 is our maxRetries.
     var maxRetries = 4;
     delaySetSelectedIndex() {
       if (newValue > node.length && --maxRetries >= 0) {
-        runAsync(delaySetSelectedIndex);
+        scheduleMicrotask(delaySetSelectedIndex);
       } else {
         node.selectedIndex = newValue;
       }
     }
 
-    runAsync(delaySetSelectedIndex);
+    scheduleMicrotask(delaySetSelectedIndex);
   }
 
   void nodeValueChanged(e) {
     value = node.selectedIndex;
   }
 
   // TODO(jmesserly,sigmund): I wonder how many bindings typically convert from
   // one type to another (e.g. value-as-number) and whether it is useful to
   // have something like a int/num binding converter (either as a base class or
   // a wrapper).
   static int _toInt(value) {
     if (value is String) return int.parse(value, onError: (_) => null);
     return value is int ? value : null;
   }
 }