Revert zone tasks.

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 Timer._createTimer(duration, callback);
+      return Zone.current.createTimer(duration, callback);
     }
-    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);
+    return Zone.current.createTimer(
+        duration, Zone.current.bindCallback(callback, runGuarded: true));
   }
 
   /**
    * 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 Timer._createPeriodicTimer(duration, callback);
+      return Zone.current.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.
-    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);
+    var boundCallback = Zone.current.bindUnaryCallback/*<dynamic, Timer>*/(
+        callback, runGuarded: true);
+    return Zone.current.createPeriodicTimer(duration, boundCallback);
   }
 
   /**
    * 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));
 }