Add tasks to zones.

sdk/lib/async/timer.dart

 // Copyright (c) 2012, 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;
 
+abstract class _TimerTask implements Timer {
+  final Zone _zone;
+  final Timer _nativeTimer;
+
+  _TimerTask(this._nativeTimer, this._zone);
+
+  void cancel() {
+    _nativeTimer.cancel();
+  }
+
+  bool get isActive => _nativeTimer.isActive;
+}
+
+class _SingleShotTimerTask extends _TimerTask {
+  // TODO(floitsch): the generic argument should be 'void'.
+  final ZoneCallback<dynamic> _callback;
+
+  _SingleShotTimerTask(Timer timer, this._callback, Zone zone)
+      : super(timer, zone);
+}
+
+class _PeriodicTimerTask extends _TimerTask {
+  // TODO(floitsch): the first generic argument should be 'void'.
+  final ZoneUnaryCallback<dynamic, Timer> _callback;
+
+  _PeriodicTimerTask(Timer timer, this._callback, Zone zone)
+      : super(timer, zone);
+}
+
+/**
+ * A task specification for a single-shot timer.
+ *
+ * *Experimental*. Might disappear without notice.
+ */
+class SingleShotTimerTaskSpecification implements TaskSpecification {
+  static const String specificationName = "dart.async.timer";
+
+  /** The duration after which the timer should invoke the [callback]. */
+  final Duration duration;
+
+  /** The callback that should be run when the timer triggers. */
+  // TODO(floitsch): the generic argument should be void.
+  final ZoneCallback<dynamic> callback;
+
+  SingleShotTimerTaskSpecification(this.duration, void this.callback());
+
+  @override
+  String get name => specificationName;
+
+  @override
+  bool get isOneShot => true;
+}
+
+/**
+ * A task specification for a periodic timer.
+ *
+ * *Experimental*. Might disappear without notice.
+ */
+class PeriodicTimerTaskSpecification implements TaskSpecification {
+  static const String specificationName = "dart.async.periodic-timer";
+
+  /** The interval at which the periodic timer should invoke the [callback]. */
+  final Duration duration;
+
+  /** The callback that should be run when the timer triggers. */
+  // TODO(floitsch): the first generic argument should be void.
+  final ZoneUnaryCallback<dynamic, Timer> callback;
+
+  PeriodicTimerTaskSpecification(
+      this.duration, void this.callback(Timer timer));
+
+  @override
+  String get name => specificationName;
+
+  @override
+  bool get isOneShot => false;
+}
+
 /**
  * A count-down timer that can be configured to fire once or repeatedly.
  *
  * The timer counts down from the specified duration to 0.
  * When the timer reaches 0, the timer invokes the specified callback function.
  * Use a periodic timer to repeatedly count down the same interval.
  *
  * A negative duration is treated the same as a duration of 0.
  * If the duration is statically known to be 0, consider using [run].
  *
@@ skipping 23 matching lines @@
   /**
    * Creates a new timer.
    *
    * The [callback] function is invoked after the given [duration].
    *
    */
   factory Timer(Duration duration, void callback()) {
     if (Zone.current == Zone.ROOT) {
       // No need to bind the callback. We know that the root's timer will
       // be invoked in the root zone.
-      return Zone.current.createTimer(duration, callback);
+      return Timer._createTimer(duration, callback);
     }
-    return Zone.current.createTimer(
-        duration, Zone.current.bindCallback(callback, runGuarded: true));
+    return Zone.current.createTimer(duration, callback);
+  }
+
+  factory Timer._task(Zone zone, Duration duration, void callback()) {
+    SingleShotTimerTaskSpecification specification =
+        new SingleShotTimerTaskSpecification(duration, callback);
+    return zone.createTask(_createSingleShotTimerTask, specification);
   }
 
   /**
    * Creates a new repeating timer.
    *
    * The [callback] is invoked repeatedly with [duration] intervals until
    * canceled with the [cancel] function.
    *
    * The exact timing depends on the underlying timer implementation.
    * No more than `n` callbacks will be made in `duration * n` time,
    * but the time between two consecutive callbacks
    * can be shorter and longer than `duration`.
    *
    * In particular, an implementation may schedule the next callback, e.g.,
    * a `duration` after either when the previous callback ended,
    * when the previous callback started, or when the previous callback was
    * scheduled for - even if the actual callback was delayed.
    */
   factory Timer.periodic(Duration duration,
-                         void callback(Timer timer)) {
+      void callback(Timer timer)) {
     if (Zone.current == Zone.ROOT) {
       // No need to bind the callback. We know that the root's timer will
       // be invoked in the root zone.
-      return Zone.current.createPeriodicTimer(duration, callback);
+      return Timer._createPeriodicTimer(duration, callback);
     }
+    return Zone.current.createPeriodicTimer(duration, callback);
+  }
+
+  factory Timer._periodicTask(Zone zone, Duration duration,
+      void callback(Timer timer)) {
+    PeriodicTimerTaskSpecification specification =
+        new PeriodicTimerTaskSpecification(duration, callback);
+    return zone.createTask(_createPeriodicTimerTask, specification);
+  }
+
+  static Timer _createSingleShotTimerTask(
+      SingleShotTimerTaskSpecification specification, Zone zone) {
+    ZoneCallback registeredCallback = identical(_ROOT_ZONE, zone)
+        ? specification.callback
+        : zone.registerCallback(specification.callback);
+
+    _TimerTask timerTask;
+
+    Timer nativeTimer = Timer._createTimer(specification.duration, () {
+      timerTask._zone.runTask(_runSingleShotCallback, timerTask, null);
+    });
+
+    timerTask = new _SingleShotTimerTask(nativeTimer, registeredCallback, zone);
+    return timerTask;
+  }
+
+  static void _runSingleShotCallback(_SingleShotTimerTask timerTask, Object _) {
+    timerTask._callback();
+  }
+
+  static Timer _createPeriodicTimerTask(
+      PeriodicTimerTaskSpecification specification, Zone zone) {
     // TODO(floitsch): the return type should be 'void', and the type
     // should be inferred.
-    var boundCallback = Zone.current.bindUnaryCallback/*<dynamic, Timer>*/(
-        callback, runGuarded: true);
-    return Zone.current.createPeriodicTimer(duration, boundCallback);
+    ZoneUnaryCallback<dynamic, Timer> registeredCallback =
+        identical(_ROOT_ZONE, zone)
+        ? specification.callback
+        : zone.registerUnaryCallback/*<dynamic, Timer>*/(
+            specification.callback);
+
+    _TimerTask timerTask;
+
+    Timer nativeTimer =
+        Timer._createPeriodicTimer(specification.duration, (Timer _) {
+      timerTask._zone.runTask(_runPeriodicCallback, timerTask, null);
+    });
+
+    timerTask = new _PeriodicTimerTask(nativeTimer, registeredCallback, zone);
+    return timerTask;
+  }
+
+  static void _runPeriodicCallback(_PeriodicTimerTask timerTask, Object _) {
+    timerTask._callback(timerTask);
   }
 
   /**
    * Runs the given [callback] asynchronously as soon as possible.
    *
    * This function is equivalent to `new Timer(Duration.ZERO, callback)`.
    */
   static void run(void callback()) {
     new Timer(Duration.ZERO, callback);
   }
@@ skipping 11 matching lines @@
    *
    * A periodic timer is active if it has not been canceled.
    */
   bool get isActive;
 
   external static Timer _createTimer(Duration duration, void callback());
   external static Timer _createPeriodicTimer(Duration duration,
                                              void callback(Timer timer));
 }