Add tasks to zones.

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 ZoneBinaryCallback(arg1, arg2);
 
+typedef Object TaskCreate(TaskSpecification taskSpecification, Zone zone);
+typedef void TaskCancel(Object task);
+typedef void TaskRun(Object task, Object arg);
+
 typedef dynamic HandleUncaughtErrorHandler(
     Zone self, ZoneDelegate parent, Zone zone, error, StackTrace stackTrace);
 typedef dynamic RunHandler(Zone self, ZoneDelegate parent, Zone zone, f());
 typedef dynamic RunUnaryHandler(
     Zone self, ZoneDelegate parent, Zone zone, f(arg), arg);
 typedef dynamic RunBinaryHandler(
     Zone self, ZoneDelegate parent, Zone zone, f(arg1, arg2), arg1, arg2);
 typedef ZoneCallback RegisterCallbackHandler(
     Zone self, ZoneDelegate parent, Zone zone, f());
 typedef ZoneUnaryCallback RegisterUnaryCallbackHandler(
     Zone self, ZoneDelegate parent, Zone zone, f(arg));
 typedef ZoneBinaryCallback RegisterBinaryCallbackHandler(
     Zone self, ZoneDelegate parent, Zone zone, f(arg1, arg2));
 typedef AsyncError ErrorCallbackHandler(Zone self, ZoneDelegate parent,
     Zone zone, Object error, StackTrace stackTrace);
+typedef Object CreateTaskHandler(Zone self, ZoneDelegate parent, Zone zone,
+    TaskSpecification taskSpecification, TaskCreate schedule);

[Lasse Reichstein Nielsen, 2016/05/18 11:40:55]

schedule -> create.

+typedef void CancelTaskHandler(Zone self, ZoneDelegate parent, Zone zone,
+    Object task, TaskCancel cancel);
+typedef void RunTaskHandler(Zone self, ZoneDelegate parent, Zone zone,
+    Object task, Object arg1, TaskRun run);
 typedef void ScheduleMicrotaskHandler(
     Zone self, ZoneDelegate parent, Zone zone, f());
-typedef Timer CreateTimerHandler(
-    Zone self, ZoneDelegate parent, Zone zone, Duration duration, void f());
-typedef Timer CreatePeriodicTimerHandler(
-    Zone self, ZoneDelegate parent, Zone zone,
-    Duration period, void f(Timer timer));
 typedef void PrintHandler(
     Zone self, ZoneDelegate parent, Zone zone, String line);
 typedef Zone ForkHandler(Zone self, ZoneDelegate parent, Zone zone,
                          ZoneSpecification specification,
                          Map zoneValues);
 
+// Typedefs for deprecated methods.
+typedef Timer CreateTimerHandler(
+    Zone self, ZoneDelegate parent, Zone zone, Duration duration, void f());
+typedef Timer CreatePeriodicTimerHandler(
+    Zone self, ZoneDelegate parent, Zone zone,
+    Duration period, void f(Timer timer));
+
 /** Pair of error and stack trace. Returned by [Zone.errorCallback]. */
 class AsyncError implements Error {
   final error;
   final StackTrace stackTrace;
 
   AsyncError(this.error, this.stackTrace);
 
   String toString() => '$error';
 }
 
+abstract class TaskSpecification {
+  /// Description of the task.
+  ///
+  /// This string is unused by the root-zone, but might be used for debugging,
+  /// and testing. As such, it should be relatively unique in its category.
+  String get name;
+
+  /// Whether the scheduled task triggers at most once.
+  ///
+  /// If the task is not a one-shot task, it may need to be canceled to prevent
+  /// further iterations of the task.
+  bool get isOneShot;
+}
+
+class _TimerTaskWrapper implements Timer {
+  final TimerTask _task;
+
+  _TimerTaskWrapper(this._task);
+
+  static _cancel(TimerTask task) {
+    task.timer.cancel();
+  }
+
+   void cancel() {
+    _task.zone.cancelTask(_task, _cancel);
+  }
+
+  bool get isActive => _task.timer.isActive;
+}
+
+abstract class TimerTask {

[Lasse Reichstein Nielsen, 2016/05/18 11:40:55]

Maybe document the class - where is it used, what can it be used for.

+  final Zone zone;
+  /// The native timer.
+  final Timer timer;
+
+  TimerTask(this.timer, this.zone);
+}
+
+class SingleShotTimerTask extends TimerTask {

[Lasse Reichstein Nielsen, 2016/05/18 11:40:55]

Consider moving the timer-specific classes to the same file as the timer
implementation. 

+  final ZoneCallback callback;
+
+  SingleShotTimerTask(Timer timer, this.callback, Zone zone)
+      : super(timer, zone);
+}
+
+class PeriodicTimerTask extends TimerTask {
+  final ZoneUnaryCallback callback;
+
+  PeriodicTimerTask(Timer timer, this.callback, Zone zone)
+      : super(timer, zone);
+}
+
+class SingleShotTimerTaskSpecification implements TaskSpecification {
+  final Duration duration;
+  final ZoneCallback callback;
+
+  SingleShotTimerTaskSpecification(this.duration, void this.callback());
+
+  String get name => "Timer";
+  bool get isOneShot => true;
+  bool get isEventTask => false;
+  bool get isMacroTask => true;
+}
+
+class PeriodicTimerTaskSpecification implements TaskSpecification {
+  final Duration duration;
+  final ZoneUnaryCallback callback;
+
+  PeriodicTimerTaskSpecification(
+      this.duration, void this.callback(Timer timer));
+
+  String get name => "Periodic Timer";
+  bool get isOneShot => false;
+  bool get isEventTask => false;
+  bool get isMacroTask => true;
+}
 
 class _ZoneFunction {
   final _Zone zone;
   final Function function;
+
   const _ZoneFunction(this.zone, this.function);
 }
 
 /**
  * This class provides the specification for a forked zone.
  *
  * When forking a new zone (see [Zone.fork]) one can override the default
  * behavior of the zone by providing callbacks. These callbacks must be
  * given in an instance of this class.
  *
@@ skipping 24 matching lines @@
     ZoneCallback registerCallback(
         Zone self, ZoneDelegate parent, Zone zone, f()),
     ZoneUnaryCallback registerUnaryCallback(
         Zone self, ZoneDelegate parent, Zone zone, f(arg)),
     ZoneBinaryCallback registerBinaryCallback(
         Zone self, ZoneDelegate parent, Zone zone, f(arg1, arg2)),
     AsyncError errorCallback(Zone self, ZoneDelegate parent, Zone zone,
                              Object error, StackTrace stackTrace),
     void scheduleMicrotask(
         Zone self, ZoneDelegate parent, Zone zone, f()),
+    Object createTask(Zone self, ZoneDelegate parent, Zone zone,
+        TaskSpecification taskSpecification, TaskCreate create),
+    void runTask(Zone self, ZoneDelegate parent, Zone zone, Object task,
+        Object arg, TaskRun run),
+    void cancelTask(Zone self, ZoneDelegate parent, Zone zone, Object task,
+        TaskCancel cancel),
+
+    void print(Zone self, ZoneDelegate parent, Zone zone, String line),
+    Zone fork(Zone self, ZoneDelegate parent, Zone zone,
+        ZoneSpecification specification, Map zoneValues),
+
+    @deprecated
     Timer createTimer(Zone self, ZoneDelegate parent, Zone zone,
                       Duration duration, void f()),
+    @deprecated
     Timer createPeriodicTimer(Zone self, ZoneDelegate parent, Zone zone,
-                              Duration period, void f(Timer timer)),
-    void print(Zone self, ZoneDelegate parent, Zone zone, String line),
-    Zone fork(Zone self, ZoneDelegate parent, Zone zone,
-              ZoneSpecification specification, Map zoneValues)
+                              Duration period, void f(Timer timer))
   }) = _ZoneSpecification;
 
   /**
    * Creates a specification from [other] with the provided handlers overriding
    * the ones in [other].
    */
   factory ZoneSpecification.from(ZoneSpecification other, {
     dynamic handleUncaughtError(Zone self, ZoneDelegate parent, Zone zone,
                                 error, StackTrace stackTrace): null,
     dynamic run(Zone self, ZoneDelegate parent, Zone zone, f()): null,
     dynamic runUnary(
         Zone self, ZoneDelegate parent, Zone zone, f(arg), arg): null,
     dynamic runBinary(Zone self, ZoneDelegate parent, Zone zone,
                       f(arg1, arg2), arg1, arg2): null,
     ZoneCallback registerCallback(
         Zone self, ZoneDelegate parent, Zone zone, f()): null,
     ZoneUnaryCallback registerUnaryCallback(
         Zone self, ZoneDelegate parent, Zone zone, f(arg)): null,
     ZoneBinaryCallback registerBinaryCallback(
         Zone self, ZoneDelegate parent, Zone zone, f(arg1, arg2)): null,
     AsyncError errorCallback(Zone self, ZoneDelegate parent, Zone zone,
                              Object error, StackTrace stackTrace),
     void scheduleMicrotask(
         Zone self, ZoneDelegate parent, Zone zone, f()): null,
-    Timer createTimer(Zone self, ZoneDelegate parent, Zone zone,
-                      Duration duration, void f()): null,
-    Timer createPeriodicTimer(Zone self, ZoneDelegate parent, Zone zone,
-                              Duration period, void f(Timer timer)): null,
+
+    Object createTask(Zone self, ZoneDelegate parent, Zone zone,
+        TaskSpecification taskSpecification, TaskCreate create): null,
+    void runTask(Zone self, ZoneDelegate parent, Zone zone, Object task,
+        TaskRun run): null,
+    void cancelTask(Zone self, ZoneDelegate parent, Zone zone, Object task,
+        TaskCancel cancel): null,
+
     void print(Zone self, ZoneDelegate parent, Zone zone, String line): null,
     Zone fork(Zone self, ZoneDelegate parent, Zone zone,
               ZoneSpecification specification,
-              Map zoneValues): null
+              Map zoneValues): null,
+
+    @deprecated
+    Timer createTimer(Zone self, ZoneDelegate parent, Zone zone,
+        Duration duration, void f()): null,
+    @deprecated
+    Timer createPeriodicTimer(Zone self, ZoneDelegate parent, Zone zone,
+        Duration period, void f(Timer timer)): null
   }) {
     return new ZoneSpecification(
       handleUncaughtError: handleUncaughtError ?? other.handleUncaughtError,
       run: run ?? other.run,
       runUnary: runUnary ?? other.runUnary,
       runBinary: runBinary ?? other.runBinary,
       registerCallback: registerCallback ?? other.registerCallback,
       registerUnaryCallback: registerUnaryCallback ??
                              other.registerUnaryCallback,
       registerBinaryCallback: registerBinaryCallback ??
                               other.registerBinaryCallback,
       errorCallback: errorCallback ?? other.errorCallback,
+
+      createTask: createTask ?? other.createTask,
+      runTask: runTask ?? other.runTask,
+      cancelTask: cancelTask ?? other.cancelTask,
+      print : print ?? other.print,
+      fork: fork ?? other.fork,
       scheduleMicrotask: scheduleMicrotask ?? other.scheduleMicrotask,
       createTimer : createTimer ?? other.createTimer,
-      createPeriodicTimer: createPeriodicTimer ?? other.createPeriodicTimer,
-      print : print ?? other.print,
-      fork: fork ?? other.fork);
+      createPeriodicTimer: createPeriodicTimer ?? other.createPeriodicTimer);
   }
 
   HandleUncaughtErrorHandler get handleUncaughtError;
   RunHandler get run;
   RunUnaryHandler get runUnary;
   RunBinaryHandler get runBinary;
   RegisterCallbackHandler get registerCallback;
   RegisterUnaryCallbackHandler get registerUnaryCallback;
   RegisterBinaryCallbackHandler get registerBinaryCallback;
   ErrorCallbackHandler get errorCallback;
   ScheduleMicrotaskHandler get scheduleMicrotask;
-  CreateTimerHandler get createTimer;
-  CreatePeriodicTimerHandler get createPeriodicTimer;
+  CreateTaskHandler get createTask;
+  RunTaskHandler get runTask;
+  CancelTaskHandler get cancelTask;
   PrintHandler get print;
   ForkHandler get fork;
+
+  @deprecated
+  CreateTimerHandler get createTimer;
+  @deprecated
+  CreatePeriodicTimerHandler get createPeriodicTimer;
 }
 
 /**
  * Internal [ZoneSpecification] class.
  *
  * The implementation wants to rely on the fact that the getters cannot change
  * dynamically. We thus require users to go through the redirecting
  * [ZoneSpecification] constructor which instantiates this class.
  */
 class _ZoneSpecification implements ZoneSpecification {
   const _ZoneSpecification({
     this.handleUncaughtError: null,
     this.run: null,
     this.runUnary: null,
     this.runBinary: null,
     this.registerCallback: null,
     this.registerUnaryCallback: null,
     this.registerBinaryCallback: null,
     this.errorCallback: null,
     this.scheduleMicrotask: null,
+    this.createTask: null,
+    this.runTask: null,
+    this.cancelTask: null,
+    this.print: null,
+    this.fork: null,
+    @deprecated
     this.createTimer: null,
-    this.createPeriodicTimer: null,
-    this.print: null,
-    this.fork: null
+    @deprecated
+    this.createPeriodicTimer: null
   });
 
   final HandleUncaughtErrorHandler handleUncaughtError;
   final RunHandler run;
   final RunUnaryHandler runUnary;
   final RunBinaryHandler runBinary;
   final RegisterCallbackHandler registerCallback;
   final RegisterUnaryCallbackHandler registerUnaryCallback;
   final RegisterBinaryCallbackHandler registerBinaryCallback;
   final ErrorCallbackHandler errorCallback;
   final ScheduleMicrotaskHandler scheduleMicrotask;
-  final CreateTimerHandler createTimer;
-  final CreatePeriodicTimerHandler createPeriodicTimer;
+  final CreateTaskHandler createTask;
+  final RunTaskHandler runTask;
+  final CancelTaskHandler cancelTask;
   final PrintHandler print;
   final ForkHandler fork;
+
+  @deprecated
+  final CreateTimerHandler createTimer;
+  @deprecated
+  final CreatePeriodicTimerHandler createPeriodicTimer;
 }
 
 /**
  * This class wraps zones for delegation.
  *
  * When forwarding to parent zones one can't just invoke the parent zone's
  * exposed functions (like [Zone.run]), but one needs to provide more
  * information (like the zone the `run` was initiated). Zone callbacks thus
  * receive more information including this [ZoneDelegate] class. When delegating
  * to the parent zone one should go through the given instance instead of
  * directly invoking the parent zone.
  */
 abstract class ZoneDelegate {
   dynamic handleUncaughtError(Zone zone, error, StackTrace stackTrace);
   dynamic run(Zone zone, f());
   dynamic runUnary(Zone zone, f(arg), arg);
   dynamic runBinary(Zone zone, f(arg1, arg2), arg1, arg2);
   ZoneCallback registerCallback(Zone zone, f());
   ZoneUnaryCallback registerUnaryCallback(Zone zone, f(arg));
   ZoneBinaryCallback registerBinaryCallback(Zone zone, f(arg1, arg2));
   AsyncError errorCallback(Zone zone, Object error, StackTrace stackTrace);
   void scheduleMicrotask(Zone zone, f());
-  Timer createTimer(Zone zone, Duration duration, void f());
-  Timer createPeriodicTimer(Zone zone, Duration period, void f(Timer timer));
+  Object createTask(Zone zone, TaskSpecification task, TaskCreate schedule);
+  void runTask(Zone zone, Object task, Object arg, TaskRun run);
+  void cancelTask(Zone zone, Object task, TaskCancel cancel);
   void print(Zone zone, String line);
   Zone fork(Zone zone, ZoneSpecification specification, Map zoneValues);
+
+  @deprecated
+  Timer createTimer(Zone zone, Duration duration, void f());
+  @deprecated
+  Timer createPeriodicTimer(Zone zone, Duration period, void f(Timer timer));
 }
 
 /**
  * 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
  * the `then` was invoked.
  */
 abstract class Zone {
   // Private constructor so that it is not possible instantiate a Zone class.
@@ skipping 163 matching lines @@
    * the new pair of error and stack trace.
    * If the [AsyncError.error] is `null`, it is replaced by a [NullThrownError].
    */
   AsyncError errorCallback(Object error, StackTrace stackTrace);
 
   /**
    * Runs [f] asynchronously in this zone.
    */
   void scheduleMicrotask(void f());
 
+  Object createTask(TaskSpecification task, TaskCreate create);
+  void runTask(Object task, Object arg1, TaskRun run);
+  void cancelTask(Object task, TaskCancel cancel);
+
   /**
    * Creates a Timer where the callback is executed in this zone.
    */
+  @deprecated
   Timer createTimer(Duration duration, void callback());
 
   /**
    * Creates a periodic Timer where the callback is executed in this zone.
    */
+  @deprecated
   Timer createPeriodicTimer(Duration period, void callback(Timer timer));
 
   /**
    * Prints the given [line].
    */
   void print(String line);
 
   /**
    * Call to enter the Zone.
    *
@@ skipping 102 matching lines @@
                    error, stackTrace);
   }
 
   void scheduleMicrotask(Zone zone, f()) {
     _ZoneFunction implementation = _delegationTarget._scheduleMicrotask;
     _Zone implZone = implementation.zone;
     ScheduleMicrotaskHandler handler = implementation.function;
     handler(implZone, _parentDelegate(implZone), zone, f);
   }
 
-  Timer createTimer(Zone zone, Duration duration, void f()) {
-    _ZoneFunction implementation = _delegationTarget._createTimer;
+  Object createTask(Zone zone, TaskSpecification task, TaskCreate create) {
+    _ZoneFunction implementation = _delegationTarget._createTask;
     _Zone implZone = implementation.zone;
-    CreateTimerHandler handler = implementation.function;
-    return handler(implZone, _parentDelegate(implZone), zone, duration, f);
+    CreateTaskHandler handler = implementation.function;
+    return handler(implZone, _parentDelegate(implZone), zone, task, create);
   }
 
-  Timer createPeriodicTimer(Zone zone, Duration period, void f(Timer timer)) {
-    _ZoneFunction implementation = _delegationTarget._createPeriodicTimer;
+  void runTask(Zone zone, Object task, Object arg, TaskRun run) {
+    _ZoneFunction implementation = _delegationTarget._runTask;
     _Zone implZone = implementation.zone;
-    CreatePeriodicTimerHandler handler = implementation.function;
-    return handler(implZone, _parentDelegate(implZone), zone, period, f);
+    RunTaskHandler handler = implementation.function;
+    handler(implZone, _parentDelegate(implZone), zone, task, arg, run);
+  }
+
+  void cancelTask(Zone zone, Object task, TaskCancel cancel) {
+    _ZoneFunction implementation = _delegationTarget._cancelTask;
+    _Zone implZone = implementation.zone;
+    CancelTaskHandler handler = implementation.function;
+    handler(implZone, _parentDelegate(implZone), zone, task, cancel);
   }
 
   void print(Zone zone, String line) {
     _ZoneFunction implementation = _delegationTarget._print;
     _Zone implZone = implementation.zone;
     PrintHandler handler = implementation.function;
     handler(implZone, _parentDelegate(implZone), zone, line);
   }
 
   Zone fork(Zone zone, ZoneSpecification specification,
             Map zoneValues) {
     _ZoneFunction implementation = _delegationTarget._fork;
     _Zone implZone = implementation.zone;
     ForkHandler handler = implementation.function;
     return handler(
         implZone, _parentDelegate(implZone), zone, specification, zoneValues);
   }
+
+  @deprecated
+  Timer createTimer(Zone zone, Duration duration, void f()) {
+    _ZoneFunction implementation = _delegationTarget._createTimer;
+    _Zone implZone = implementation.zone;
+    CreateTimerHandler handler = implementation.function;
+    return handler(implZone, _parentDelegate(implZone), zone, duration, f);
+  }
+
+  @deprecated
+  Timer createPeriodicTimer(Zone zone, Duration period, void f(Timer timer)) {
+    _ZoneFunction implementation = _delegationTarget._createPeriodicTimer;
+    _Zone implZone = implementation.zone;
+    CreatePeriodicTimerHandler handler = implementation.function;
+    return handler(implZone, _parentDelegate(implZone), zone, period, f);
+  }
 }
 
 
 /**
  * Base class for Zone implementations.
  */
 abstract class _Zone implements Zone {
   const _Zone();
 
   _ZoneFunction get _runUnary;
   _ZoneFunction get _run;
   _ZoneFunction get _runBinary;
   _ZoneFunction get _registerCallback;
   _ZoneFunction get _registerUnaryCallback;
   _ZoneFunction get _registerBinaryCallback;
   _ZoneFunction get _errorCallback;
   _ZoneFunction get _scheduleMicrotask;
-  _ZoneFunction get _createTimer;
-  _ZoneFunction get _createPeriodicTimer;
+  _ZoneFunction get _createTask;
+  _ZoneFunction get _runTask;
+  _ZoneFunction get _cancelTask;
   _ZoneFunction get _print;
   _ZoneFunction get _fork;
   _ZoneFunction get _handleUncaughtError;
+
+  @deprecated
+  _ZoneFunction get _createTimer;
+  @deprecated
+  _ZoneFunction get _createPeriodicTimer;
+
   _Zone get parent;
   _ZoneDelegate get _delegate;
   Map get _map;
 
   bool inSameErrorZone(Zone otherZone) {
     return identical(this, otherZone) ||
            identical(errorZone, otherZone.errorZone);
   }
 }
 
 class _CustomZone extends _Zone {
   // The actual zone and implementation of each of these
   // inheritable zone functions.
   _ZoneFunction _runUnary;
   _ZoneFunction _run;
   _ZoneFunction _runBinary;
   _ZoneFunction _registerCallback;
   _ZoneFunction _registerUnaryCallback;
   _ZoneFunction _registerBinaryCallback;
   _ZoneFunction _errorCallback;
   _ZoneFunction _scheduleMicrotask;
-  _ZoneFunction _createTimer;
-  _ZoneFunction _createPeriodicTimer;
+  _ZoneFunction _createTask;
+  _ZoneFunction _runTask;
+  _ZoneFunction _cancelTask;
   _ZoneFunction _print;
   _ZoneFunction _fork;
   _ZoneFunction _handleUncaughtError;
 
+  @deprecated
+  _ZoneFunction _createTimer;
+  @deprecated
+  _ZoneFunction _createPeriodicTimer;
+
   // A cached delegate to this zone.
   ZoneDelegate _delegateCache;
 
   /// The parent zone.
   final _Zone parent;
 
   /// The zone's scoped value declaration map.
   ///
   /// This is always a [HashMap].
   final Map _map;
@@ skipping 25 matching lines @@
         : parent._registerUnaryCallback;
     _registerBinaryCallback = (specification.registerBinaryCallback != null)
         ? new _ZoneFunction(this, specification.registerBinaryCallback)
         : parent._registerBinaryCallback;
     _errorCallback = (specification.errorCallback != null)
         ? new _ZoneFunction(this, specification.errorCallback)
         : parent._errorCallback;
     _scheduleMicrotask = (specification.scheduleMicrotask != null)
         ? new _ZoneFunction(this, specification.scheduleMicrotask)
         : parent._scheduleMicrotask;
-    _createTimer = (specification.createTimer != null)
-        ? new _ZoneFunction(this, specification.createTimer)
-        : parent._createTimer;
-    _createPeriodicTimer = (specification.createPeriodicTimer != null)
-        ? new _ZoneFunction(this, specification.createPeriodicTimer)
-        : parent._createPeriodicTimer;
+    _createTask = (specification.createTask != null)
+        ? new _ZoneFunction(this, specification.createTask)
+        : parent._createTask;
+    _runTask = (specification.runTask != null)
+        ? new _ZoneFunction(this, specification.runTask)
+        : parent._runTask;
+    _cancelTask = (specification.cancelTask != null)
+        ? new _ZoneFunction(this, specification.runTask)
+        : parent._cancelTask;
     _print = (specification.print != null)
         ? new _ZoneFunction(this, specification.print)
         : parent._print;
     _fork = (specification.fork != null)
         ? new _ZoneFunction(this, specification.fork)
         : parent._fork;
     _handleUncaughtError = (specification.handleUncaughtError != null)
         ? new _ZoneFunction(this, specification.handleUncaughtError)
         : parent._handleUncaughtError;
+
+    // Deprecated fields.
+    _createTimer = (specification.createTimer != null)
+        ? new _ZoneFunction(this, specification.createTimer)
+        : parent._createTimer;
+    _createPeriodicTimer = (specification.createPeriodicTimer != null)
+        ? new _ZoneFunction(this, specification.createPeriodicTimer)
+        : parent._createPeriodicTimer;
   }
 
   /**
    * The closest error-handling zone.
    *
    * Returns `this` if `this` has an error-handler. Otherwise returns the
    * parent's error-zone.
    */
   Zone get errorZone => _handleUncaughtError.zone;
 
@@ skipping 146 matching lines @@
     ErrorCallbackHandler handler = implementation.function;
     return handler(
         implementationZone, parentDelegate, this, error, stackTrace);
   }
 
   void scheduleMicrotask(void f()) {
     _ZoneFunction implementation = this._scheduleMicrotask;
     assert(implementation != null);
     ZoneDelegate parentDelegate = _parentDelegate(implementation.zone);
     ScheduleMicrotaskHandler handler = implementation.function;
-    return handler(implementation.zone, parentDelegate, this, f);
+    handler(implementation.zone, parentDelegate, this, f);
   }
 
+  Object createTask(TaskSpecification task, TaskCreate create) {
+    _ZoneFunction implementation = this._createTask;
+    ZoneDelegate parentDelegate = _parentDelegate(implementation.zone);
+    CreateTaskHandler handler = implementation.function;
+    return handler(implementation.zone, parentDelegate, this, task, create);
+  }
+
+  void runTask(Object task, Object arg1, TaskRun run) {
+    _ZoneFunction implementation = this._runTask;
+    ZoneDelegate parentDelegate = _parentDelegate(implementation.zone);
+    RunTaskHandler handler = implementation.function;
+    handler(implementation.zone, parentDelegate, this, task, arg1, run);
+  }
+
+  void cancelTask(Object task, TaskCancel cancel) {
+    _ZoneFunction implementation = this._cancelTask;
+    ZoneDelegate parentDelegate = _parentDelegate(implementation.zone);
+    CancelTaskHandler handler = implementation.function;
+    handler(implementation.zone, parentDelegate, this, task, cancel);
+  }
+
+  void print(String line) {
+    _ZoneFunction implementation = this._print;
+    assert(implementation != null);
+    ZoneDelegate parentDelegate = _parentDelegate(implementation.zone);
+    PrintHandler handler = implementation.function;
+    return handler(implementation.zone, parentDelegate, this, line);
+  }
+
+  @deprecated
   Timer createTimer(Duration duration, void f()) {
     _ZoneFunction implementation = this._createTimer;
     assert(implementation != null);
     ZoneDelegate parentDelegate = _parentDelegate(implementation.zone);
     CreateTimerHandler handler = implementation.function;
     return handler(implementation.zone, parentDelegate, this, duration, f);
   }
 
+  @deprecated
   Timer createPeriodicTimer(Duration duration, void f(Timer timer)) {
     _ZoneFunction implementation = this._createPeriodicTimer;
     assert(implementation != null);
     ZoneDelegate parentDelegate = _parentDelegate(implementation.zone);
     CreatePeriodicTimerHandler handler = implementation.function;
     return handler(
         implementation.zone, parentDelegate, this, duration, f);
   }
-
-  void print(String line) {
-    _ZoneFunction implementation = this._print;
-    assert(implementation != null);
-    ZoneDelegate parentDelegate = _parentDelegate(implementation.zone);
-    PrintHandler handler = implementation.function;
-    return handler(implementation.zone, parentDelegate, this, line);
-  }
 }
 
 void _rootHandleUncaughtError(
     Zone self, ZoneDelegate parent, Zone zone, error, StackTrace stackTrace) {
   _schedulePriorityAsyncCallback(() {
     if (error == null) error = new NullThrownError();
     if (stackTrace == null) throw error;
     _rethrow(error, stackTrace);
   });
 }
@@ skipping 55 matching lines @@
 void _rootScheduleMicrotask(Zone self, ZoneDelegate parent, Zone zone, f()) {
   if (!identical(_ROOT_ZONE, zone)) {
     bool hasErrorHandler = !_ROOT_ZONE.inSameErrorZone(zone);
     f = zone.bindCallback(f, runGuarded: hasErrorHandler);
     // Use root zone as event zone if the function is already bound.
     zone = _ROOT_ZONE;
   }
   _scheduleAsyncCallback(f);
 }
 
+Object _rootcreateTask(Zone self, ZoneDelegate parent, Zone zone,
+    TaskSpecification taskSpecification, TaskCreate create) {
+  return create(taskSpecification, zone);
+}
+
+void _rootRunTask(Zone self, ZoneDelegate parent, Zone zone, Object task,
+    Object arg, TaskRun run) {
+  if (Zone._current == zone) run(task, arg);
+
+  Zone old = Zone._enter(zone);
+  try {
+    run(task, arg);
+  } finally {
+    Zone._leave(old);
+  }
+}
+
+void _rootCancelTask(Zone self, ZoneDelegate parent, Zone zone, Object task,
+    TaskCancel cancel) {
+  cancel(task);
+}
+
 Timer _rootCreateTimer(Zone self, ZoneDelegate parent, Zone zone,
                        Duration duration, void callback()) {
-  if (!identical(_ROOT_ZONE, zone)) {
-    callback = zone.bindCallback(callback);
-  }
-  return Timer._createTimer(duration, callback);
+  return new Timer._task(zone, duration, callback);
 }
 
 Timer _rootCreatePeriodicTimer(
     Zone self, ZoneDelegate parent, Zone zone,
     Duration duration, void callback(Timer timer)) {
-  if (!identical(_ROOT_ZONE, zone)) {
-    callback = zone.bindUnaryCallback(callback);
-  }
-  return Timer._createPeriodicTimer(duration, callback);
+  return new Timer._periodicTask(zone, duration, callback);
 }
 
 void _rootPrint(Zone self, ZoneDelegate parent, Zone zone, String line) {
   printToConsole(line);
 }
 
 void _printToZone(String line) {
   Zone.current.print(line);
 }
 
@@ skipping 36 matching lines @@
   _ZoneFunction get _registerCallback =>
       const _ZoneFunction(_ROOT_ZONE, _rootRegisterCallback);
   _ZoneFunction get _registerUnaryCallback =>
       const _ZoneFunction(_ROOT_ZONE, _rootRegisterUnaryCallback);
   _ZoneFunction get _registerBinaryCallback =>
       const _ZoneFunction(_ROOT_ZONE, _rootRegisterBinaryCallback);
   _ZoneFunction get _errorCallback =>
       const _ZoneFunction(_ROOT_ZONE, _rootErrorCallback);
   _ZoneFunction get _scheduleMicrotask =>
       const _ZoneFunction(_ROOT_ZONE, _rootScheduleMicrotask);
-  _ZoneFunction get _createTimer =>
-      const _ZoneFunction(_ROOT_ZONE, _rootCreateTimer);
-  _ZoneFunction get _createPeriodicTimer =>
-      const _ZoneFunction(_ROOT_ZONE, _rootCreatePeriodicTimer);
+  _ZoneFunction get _createTask =>
+      const _ZoneFunction(_ROOT_ZONE, _rootcreateTask);
+  _ZoneFunction get _runTask =>
+      const _ZoneFunction(_ROOT_ZONE, _rootRunTask);
+  _ZoneFunction get _cancelTask =>
+      const _ZoneFunction(_ROOT_ZONE, _rootCancelTask);
   _ZoneFunction get _print =>
       const _ZoneFunction(_ROOT_ZONE, _rootPrint);
   _ZoneFunction get _fork =>
       const _ZoneFunction(_ROOT_ZONE, _rootFork);
   _ZoneFunction get _handleUncaughtError =>
       const _ZoneFunction(_ROOT_ZONE, _rootHandleUncaughtError);
 
+  @deprecated
+  _ZoneFunction get _createTimer =>
+      const _ZoneFunction(_ROOT_ZONE, _rootCreateTimer);
+  @deprecated
+  _ZoneFunction get _createPeriodicTimer =>
+      const _ZoneFunction(_ROOT_ZONE, _rootCreatePeriodicTimer);
+
   // The parent zone.
   _Zone get parent => null;
 
   /// The zone's scoped value declaration map.
   ///
   /// This is always a [HashMap].
   Map get _map => _rootMap;
 
   static Map _rootMap = new HashMap();
 
@@ skipping 104 matching lines @@
   ZoneUnaryCallback registerUnaryCallback(f(arg)) => f;
 
   ZoneBinaryCallback registerBinaryCallback(f(arg1, arg2)) => f;
 
   AsyncError errorCallback(Object error, StackTrace stackTrace) => null;
 
   void scheduleMicrotask(void f()) {
     _rootScheduleMicrotask(null, null, this, f);
   }
 
+  Object createTask(TaskSpecification task, TaskCreate create) {
+    return _rootcreateTask(null, null, this, task, create);
+  }
+
+  void runTask(Object task, Object arg, TaskRun run) {
+    _rootRunTask(null, null, this, task, arg, run);
+  }
+
+  void cancelTask(Object task, TaskCancel cancel) {
+    _rootCancelTask(null, null, this, task, cancel);
+  }
+
   Timer createTimer(Duration duration, void f()) {
     return Timer._createTimer(duration, f);
   }
 
   Timer createPeriodicTimer(Duration duration, void f(Timer timer)) {
     return Timer._createPeriodicTimer(duration, f);
   }
 
   void print(String line) {
     printToConsole(line);
@@ skipping 58 matching lines @@
                                    handleUncaughtError: errorHandler);
   }
   Zone zone = Zone.current.fork(specification: zoneSpecification,
                                 zoneValues: zoneValues);
   if (onError != null) {
     return zone.runGuarded(body);
   } else {
     return zone.run(body);
   }
 }