Add a default value for bindCallback's runGuarded.

sdk/lib/async/zone.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 dynamic ZoneCallback();
 typedef dynamic ZoneUnaryCallback(arg);
 
 typedef dynamic HandleUncaughtErrorHandler(
@@ skipping 233 matching lines @@
   dynamic runGuarded(f());
 
   /**
    * Executes the given callback [f] in this zone.
    *
    * Same as [runUnary] but catches uncaught errors and gives them to
    * [handleUncaughtError].
    */
   dynamic runUnaryGuarded(f(arg), var arg);
 
-  ZoneCallback registerCallback(f());
-  ZoneUnaryCallback registerUnaryCallback(f(arg));
+  /**
+   * Registers the given callback in this zone.
+   *
+   * It is good practice to register asynchronous or delayed callbacks before
+   * invoking [run]. This gives the zone a chance to wrap the callback and
+   * to store information with the callback. For example, a zone may decide
+   * to store the stack trace (at the time of the registration) with the
+   * callback.
+   *
+   * Returns a potentially new callback that should be used in place of the
+   * given [callback].
+   */
+  ZoneCallback registerCallback(callback());
+
+  /**
+   * Registers the given callback in this zone.
+   *
+   * Similar to [registerCallback] but with a unary callback.
+   */
+  ZoneUnaryCallback registerUnaryCallback(callback(arg));
 
   /**
    *  Equivalent to:
    *
    *      ZoneCallback registered = registerCallback(f);
+   *      if (runGuarded) return () => this.runGuarded(registered);
    *      return () => this.run(registered);
+   *
    */
-  ZoneCallback bindCallback(f(), { bool runGuarded });
+  ZoneCallback bindCallback(f(), { bool runGuarded: true });
   /**
    *  Equivalent to:
    *
    *      ZoneCallback registered = registerCallback1(f);
-   *      return (arg) => this.run1(registered, arg);
+   *      if (runGuarded) return (arg) => this.runUnaryGuarded(registered, arg);
+   *      return (arg) => thin.runUnary(registered, arg);
    */
-  ZoneUnaryCallback bindUnaryCallback(f(arg), { bool runGuarded });
+  ZoneUnaryCallback bindUnaryCallback(f(arg), { bool runGuarded: true });
 
   /**
    * Runs [f] asynchronously.
    */
   void scheduleMicrotask(void f());
 
   /**
    * Creates a Timer where the callback is executed in this zone.
    */
   Timer createTimer(Duration duration, void callback());
@@ skipping 139 matching lines @@
   }
 
   dynamic runUnaryGuarded(f(arg), arg) {
     try {
       return runUnary(f, arg);
     } catch (e, s) {
       return handleUncaughtError(_asyncError(e, s));
     }
   }
 
-  ZoneCallback bindCallback(f(), { bool runGuarded }) {
+  ZoneCallback bindCallback(f(), { bool runGuarded: true }) {
     ZoneCallback registered = registerCallback(f);
     if (runGuarded) {
       return () => this.runGuarded(registered);
     } else {
       return () => this.run(registered);
     }
   }
 
-  ZoneUnaryCallback bindUnaryCallback(f(arg), { bool runGuarded }) {
+  ZoneUnaryCallback bindUnaryCallback(f(arg), { bool runGuarded: true }) {
     ZoneUnaryCallback registered = registerUnaryCallback(f);
     if (runGuarded) {
       return (arg) => this.runUnaryGuarded(registered, arg);
     } else {
       return (arg) => this.runUnary(registered, arg);
     }
   }
 
   operator [](Symbol key) {
     var result = _map[key];
@@ skipping 254 matching lines @@
   ZoneSpecification specification =
     new ZoneSpecification(handleUncaughtError: errorHandler,
                         scheduleMicrotask: asyncHandler);
   Zone zone = Zone.current.fork(specification: specification);
   if (onError != null) {
     return zone.runGuarded(body);
   } else {
     return zone.run(body);
   }
 }