Add Zone support for Timers.

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;
 
 /**
  * A Zone represents the asynchronous version of a dynamic extent. Asynchronous
  * callbacks are executed in the zone they have been queued in. For example,
  * the callback of a `future.then` is executed in the same zone as the one where
@@ skipping 44 matching lines @@
 
   /**
    * Executes the given callback in this zone.
    *
    * Decrements the number of callbacks this zone is waiting for (see
    * [expectCallback]).
    */
   void executeCallback(void fun());
 
   /**
+   * Same as [executeCallback] but catches uncaught errors and gives them to
+   * [handleUncaughtError].
+   */
+  void executeCallbackGuarded(void fun());
+
+  /**
    * Same as [executeCallback] but does not decrement the number of
    * callbacks this zone is waiting for (see [expectCallback]).
    */
   void executePeriodicCallback(void fun());
 
   /**
+   * Same as [executePeriodicCallback] but catches uncaught errors and gives
+   * them to [handleUncaughtError].
+   */
+  void executeGuardedPeriodicCallback(void fun());
+
+  /**
    * Runs [fun] asynchronously in this zone.
    */
   void runAsync(void fun());
 
   /**
+   * Creates a Timer where the callback is executed in this zone.
+   */
+  Timer createTimer(Duration duration, void callback());
+
+  /**
+   * Creates a periodic Timer where the callback is executed in this zone.
+   */
+  Timer createPeriodicTimer(Duration duration, void callback(Timer timer));
+
+  /**
    * The error zone is the one that is responsible for dealing with uncaught
    * errors. Errors are not allowed to cross zones with different error-zones.
    */
   _Zone get _errorZone;
 
   /**
    * Adds [child] as a child of `this`.
    *
    * This usually means that the [child] is in the asynchronous dynamic extent
    * of `this`.
@@ skipping 80 matching lines @@
    *
    * Decrements the open-callback counter and checks (after the call) if the
    * zone is done.
    */
   void executeCallback(void fun()) {
     _openCallbacks--;
     _runInZone(fun);
   }
 
   /**
+   * Same as [executeCallback] but catches uncaught errors and gives them to
+   * [handleUncaughtError].
+   */
+  void executeCallbackGuarded(void fun()) {
+    _openCallbacks--;
+    _runGuarded(fun);
+  }
+
+  /**
    * Same as [executeCallback] but doesn't decrement the open-callback counter.
    */
   void executePeriodicCallback(void fun()) {
     _runInZone(fun);
   }
 
+  /**
+   * Same as [executePeriodicCallback] but catches uncaught errors and gives
+   * them to [handleUncaughtError].
+   */
+  void executeGuardedPeriodicCallback(void fun()) {
+    _runGuarded(fun);
+  }
+
   _runInZone(fun()) {
     if (identical(_Zone._current, this) && _openCallbacks != 0) return fun();
-    return _runGuarded(fun);
-  }
 
-  _runGuarded(void fun()) {
     _Zone oldZone = _Zone._current;
     _Zone._current = this;
     // While we are executing the function we don't want to have other
     // synchronous calls to think that they closed the zone. By incrementing
     // the _openCallbacks count we make sure that their test will fail.
     // As a side effect it will make nested calls faster since they are
     // (probably) in the same zone and have an _openCallbacks > 0.
     _openCallbacks++;
     try {
       return fun();
     } finally {
       _openCallbacks--;
       _Zone._current = oldZone;
       _checkIfDone();
     }
   }
 
+  /**
+   * Runs the function and catches uncaught errors.
+   *
+   * Uncaught errors are given to [handleUncaughtError].
+   */
+  _runGuarded(void fun()) {
+    try {
+      _runInZone(fun);
+    } catch(e, s) {
+      handleUncaughtError(_asyncError(e, s));
+    }
+  }
+
   runAsync(void fun()) {
     _openCallbacks++;
     _scheduleAsyncCallback(() {
       _openCallbacks--;
-      try {
-        _runInZone(fun);
-      } catch(e, s) {
-        handleUncaughtError(_asyncError(e, s));
-      }
+      _runGuarded(fun);
     });
   }
 
+  Timer createTimer(Duration duration, void callback()) {
+    return new _ZoneTimer(this, duration, callback);
+  }
+
+  Timer createPeriodicTimer(Duration duration, void callback(Timer timer)) {
+    return new _PeriodicZoneTimer(this, duration, callback);
+  }
+
   void _addChild(_Zone child) {
     _children.add(child);
   }
 
   void _removeChild(_Zone child) {
     assert(!_children.isEmpty);
     // Children are usually added and removed fifo or filo.
     if (identical(_children.last, child)) {
       _children.length--;
       _checkIfDone();
@@ skipping 84 matching lines @@
 
   Future runWaitForCompletion(void fun()) {
     super.runWaitForCompletion(fun).whenComplete(() {
       errorsController.close();
     });
   }
 
   String toString() => "WithErrors ${super.toString()}";
 }
 
+typedef void _TimerCallback();
+
+/**
+ * A [Timer] class that takes zones into account.
+ */
+class _ZoneTimer implements Timer {
+  final _Zone _zone;
+  final _TimerCallback _callback;
+  Timer _timer;
+  bool _isDone = false;
+
+  _ZoneTimer(this._zone, Duration duration, this._callback) {
+    _zone.expectCallback();
+    _timer = _createTimer(duration, this.run);
+  }
+
+  void run() {
+    _isDone = true;
+    _zone.executeCallbackGuarded(_callback);
+  }
+
+  void cancel() {
+    if (!_isDone) _zone.unexpectCallback();
+    _isDone = true;
+    _timer.cancel();
+  }
+}
+
+typedef void _PeriodicTimerCallback(Timer timer);
+
+/**
+ * A [Timer] class for periodic callbacks that takes zones into account.
+ */
+class _PeriodicZoneTimer implements Timer {
+  final _Zone _zone;
+  final _PeriodicTimerCallback _callback;
+  Timer _timer;
+  bool _isDone = false;
+
+  _PeriodicZoneTimer(this._zone, Duration duration, this._callback) {
+    _zone.expectCallback();
+    _timer = _createPeriodicTimer(duration, this.run);
+  }
+
+  void run(Timer timer) {
+    assert(identical(_timer, timer));
+    _zone.executeGuardedPeriodicCallback(() { _callback(this); });
+  }
+
+  void cancel() {
+    if (!_isDone) _zone.unexpectCallback();
+    _isDone = true;
+    _timer.cancel();
+  }
+}
+
 Stream catchErrors(void body()) {
   _CatchErrorsZone catchErrorsZone = new _CatchErrorsZone(_Zone._current);
   catchErrorsZone.runWaitForCompletion(body);
   return catchErrorsZone.errors;
 }
 
 Future waitForCompletion(void body()) {
   _WaitForCompletionZone zone = new _WaitForCompletionZone(_Zone._current);
   return zone.runWaitForCompletion(body);
 }