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 Task TaskCreate(TaskSpecification taskSpecification, Zone zone);

[Lasse Reichstein Nielsen, 2016/04/01 21:26:35]

Which zone are we passing to the create function?

[floitsch, 2016/04/05 20:07:17]

The zone in which the task should execute, when there is a 'runTask'.
Basically:
zone.createTask(..) calls the delegates with the zone as argument. Each delegate
may change the zone (although it's discouraged). Eventually, the delegate-chain
reaches the root zone (or not) which invokes the 'create' function, giving the
'zone' as argument.

+typedef void TaskCancel(Task task, Zone zone);
+typedef void TaskRun(Task task, Object arg, Zone zone);
+
 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 Task CreateTaskHandler(Zone self, ZoneDelegate parent, Zone zone,
+    TaskSpecification taskSpecification, TaskCreate schedule);
+typedef void CancelTaskHandler(Zone self, ZoneDelegate parent, Zone zone,
+    Task task, TaskCancel cancel);
+typedef void RunTaskHandler(Zone self, ZoneDelegate parent, Zone zone,
+    Task 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';
 }
 
+/// A token-like object that represents an asynchronous operation.
+///
+/// Tasks are always invoked by the event loop. For example, a [Timer] contains
+/// a [Task] object that represents the scheduled operation.
+///
+/// Tasks can be thought as advanced tokens (containing the task specification),
+/// and aren't necessarily distributed to users.
+abstract class Task {
+  /// The specification that was used to create this task.
+  TaskSpecification get specification;
+
+  /// The zone in which the tasks has been created and should run whenever the
+  /// event loop runs the task.
+  Zone get zone;

[floitsch, 2016/03/31 19:18:01]

We could remove this field.

[Lasse Reichstein Nielsen, 2016/04/01 21:26:35]

Agree. I generally prefer not to leak zones, so code can only run in the zone it
is started it, that it creates itself, or that it has deliberately been granted
access to by passing it a zone explicitly. It's better for encapsulation.
(And Zone.root should be private :)

[floitsch, 2016/04/05 20:07:17]

The thing is, that the task needs to keep track of in which zone it has to run.
However, I noticed, that I just captured the zone in a closure anyway. Still:
the task will know in which zone it has to run.
That ship has sailed :)

+}
+
+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 description;
+
+  /// Whether this specification is for an event task.
+  ///
+  /// Event tasks are macro tasks with specific expectations. In particular,
+  /// they may never run, or run multiple times.

[Lasse Reichstein Nielsen, 2016/04/01 21:26:35]

That's rather the absence of specific expectations - something expected to run
exactly once, or at most once, is more specific.

If an event is [isMacroTask] and ![isOneShot], is it then always an event task?
If not, what distinguishes event tasks from that other task? If so, the
[isEventTask] is redundant (might still be useful as a shorthand, though).

All in all, I don't see "eventTask" as useful without a firmer specification of
what it is and isn't (and then only if it's still useful).

[floitsch, 2016/04/05 20:07:17]

Fair enough. It might be more interesting to have a predicate for the more
regular tasks. I will ask Misko, what property exactly they want from
EventTasks. Personally, I don't think it matters much.

+  ///
+  /// Event tasks are never [isOneShot].
+  ///
+  /// Event tasks imply [isMacroTask].
+  bool get isEventTask;
+
+  /// Whether this specification is for a macro task.
+  ///
+  /// Macro tasks are triggered from the event loop and start a new micro task

[Lasse Reichstein Nielsen, 2016/04/01 21:26:35]

"triggered from the event loop" is vague (as in: I still can't pinpoint what it
means, especially the "triggered" word).
It really is just "events" - that's why it's called "the event loop".

How about:

 Macro tasks are tasks executed by the main event loop. Each such task
 may schedule a number of microtasks to be executed before the next 
 macro task.
 Macro tasks include tasks triggered by timer events, system events
 (like I/O or DOM events) and port message events.

(Hmm, I used "triggered" and it made sense to me, so my problem was probably
that I don't see the event loop as triggering anything, external events trigger
something, it's then executed by the event loop).

[floitsch, 2016/04/05 20:07:16]

Done.

+  /// loop.
+  bool get isMacroTask;
+
+  /// Whether the scheduled task triggers at most once.
+  ///
+  /// If the task is not a one-shot task, it must be canceled.

[Lasse Reichstein Nielsen, 2016/04/01 21:26:35]

"must be canceled" may be too strong. You can probably also just ignore some
tasks if you know they won't generate more events. Maybe just "may need to be
cancelled to prevent further iterations of the task".

[floitsch, 2016/04/05 20:07:16]

Done.

+  bool get isOneShot;
+}
+
+class _TimerTaskWrapper implements Timer {
+  final TimerTask _task;
+
+  _TimerTaskWrapper(this._task);
+
+  static _cancel(TimerTask task, Zone zone) {
+    task.timer.cancel();
+  }
+
+   void cancel() {
+    _task.zone.cancelTask(_task, _cancel);
+  }
+
+  bool get isActive => _task.timer.isActive;
+}
+
+abstract class TimerTask implements Task {
+  final TaskSpecification specification;
+  final Zone zone;
+  /// The native timer.
+  final Timer timer;
+
+  TimerTask(this.timer, this.specification, this.zone);
+}
+
+class SingleShotTimerTask extends TimerTask {
+  final ZoneCallback callback;
+
+  SingleShotTimerTask(Timer timer, this.callback,
+      TaskSpecification specification, Zone zone)
+      : super(timer, specification, zone);
+}
+
+class PeriodicTimerTask extends TimerTask {
+  final ZoneUnaryCallback callback;
+
+  PeriodicTimerTask(Timer timer, this.callback,
+      TaskSpecification specification, Zone zone)
+      : super(timer, specification, zone);
+}
+
+class SingleShotTimerTaskSpecification implements TaskSpecification {
+  String get description => "Timer";

[Lasse Reichstein Nielsen, 2016/04/01 21:26:35]

Maybe just make this the "toString" of the task-spec instead of having a
description.
You shouldn't be parsing strings anyway, and you need to do that to see that
"Periodic Timer" is a timer. You can't prevent anybody from using "is
PeridocTimerTaskSpecification" either, so any mocking will need to implement the
interface anyway.

That is: if description is solving any problem, then a string isn't the best
solution. If it's just for readability, make it the toString.

[floitsch, 2016/04/05 20:07:16]

This is the identifier that delegates use to intercept task creations.
Ideally, we would like to have unique ids, but that's very hard to enforce.
Instead, we are relying on users to follow conventions and not step on each
other's toes.
I agree, that one could simply use the type of the TaskSpecification, but I find
strings nicer in this use case. If we go for 'toString', then there isn't any
difference to a 'description' field anyway. It would just be easier to make a
mistake (since the description field is very explicit).

+  bool get isOneShot => true;
+  bool get isEventTask => false;
+  bool get isMacroTask => true;
+
+  final Duration duration;
+  final ZoneCallback callback;
+
+  SingleShotTimerTaskSpecification(this.duration, void this.callback());
+}
+
+class PeriodicTimerTaskSpecification implements TaskSpecification {
+  String get description => "Periodic Timer";
+  bool get isOneShot => false;
+  bool get isEventTask => false;
+  bool get isMacroTask => true;

[Lasse Reichstein Nielsen, 2016/04/01 21:26:35]

I still prefer putting getters after the constructor instead of with the fields
(probably because I want to see structure when reading the source of a class,
not API - I'll read the API docs for that).

[floitsch, 2016/04/05 20:07:16]

Done.

+
+  final Duration duration;
+  final ZoneUnaryCallback callback;
+
+  PeriodicTimerTaskSpecification(
+      this.duration, void this.callback(Timer timer));
+}
 
 class _ZoneFunction {
   final _Zone zone;
   final Function function;
   const _ZoneFunction(this.zone, this.function);
 }
 
 /**
  * This class provides the specification for a forked zone.
  *
@@ skipping 28 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()),
+    Task createTask(Zone self, ZoneDelegate parent, Zone zone,
+        TaskSpecification taskSpecification, TaskCreate create),

[Lasse Reichstein Nielsen, 2016/04/01 21:26:35]

I'm still not sure I think the create argument is necessary.
It *feels* redundant.

If the root zone recognizes the system task specifications, then it can create
tasks. If you need to add more task types to the system, then you need to run in
a zone that recognize those specifications.

If you need to replace the create function, then just call that new function
directly and don't call parent.createTask.
This is similar to DOM events where you can stop the propagation.

When you also pass the create function, and you are allowed to replace it, e.g.,
by wrapping the original function, then you can interleave yourself into the
propagation in two ways:

   self.createTask before calling parent.createTask
   parent.createTask before running wrapped create
   self's wrapped create before calling original create
   original create
   self's wrapped create after calling original create 
   parent.createTask after running wrapped create
   self.createTask after calling parent.createTask

This allows the "self" zone to inject itself everywhere. I think that's too much
to reason about - if it was just the outer wrapping, and either recurse to
parent or replace the parent behavior, then it's easier to reason about.

That doesn't allow you to add unknown task types to the root - the zone needs to
know about the task type or it won't be recognized.

[floitsch, 2016/04/05 20:07:16]

I strongly disagree.
The root-zone must be able to deal with html-event tasks, even though it has no
idea that the html library even exists.
Only, zones that want to intercept task creations need to know about specific
tasks (and even then, they might not be able to actually create the task).
You could do that (although I would find it bad style).
However, you still need to handle the standard root-zone case.
I don't think it would be common to wrap the 'create' function. In
testing-zones, for example, one would simply replace the create function, with a
mock-function.
I don't see how this would be possible. The root-zone must be able to deal with
all macro tasks, but doesn't know them yet: the html-library was added after the
fact. Similarly, mojo and flutter introduce their own macrotasks...

+    void runTask(Zone self, ZoneDelegate parent, Zone zone, Task task,
+        Object arg, TaskRun run),
+    void cancelTask(Zone self, ZoneDelegate parent, Zone zone, Task 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,
+
+    Task createTask(Zone self, ZoneDelegate parent, Zone zone,
+        TaskSpecification taskSpecification, TaskCreate create): null,
+    void runTask(Zone self, ZoneDelegate parent, Zone zone, Task task,
+        TaskRun run): null,
+    void cancelTask(Zone self, ZoneDelegate parent, Zone zone, Task 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));
+  Task createTask(Zone zone, TaskSpecification task, TaskCreate schedule);
+  void runTask(Zone zone, Task task, Object arg, TaskRun run);
+  void cancelTask(Zone zone, Task 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());
 
+  Task createTask(TaskSpecification task, TaskCreate create);
+  void runTask(Task task, Object arg1, TaskRun run);
+  void cancelTask(Task 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;
+  Task 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, Task 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, Task 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);
   }
 
+  Task 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(Task 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(Task 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);
 }
 
+Task _rootcreateTask(Zone self, ZoneDelegate parent, Zone zone,
+    TaskSpecification taskSpecification, TaskCreate create) {
+  return create(taskSpecification, zone);
+}
+
+void _rootRunTask(Zone self, ZoneDelegate parent, Zone zone, Task task,
+    Object arg, TaskRun run) {
+  if (Zone._current == zone) run(task, arg, zone);
+
+  Zone old = Zone._enter(zone);
+  try {
+    run(task, arg, zone);
+  } finally {
+    Zone._leave(old);
+  }
+}
+
+void _rootCancelTask(Zone self, ZoneDelegate parent, Zone zone, Task task,
+    TaskCancel cancel) {
+  cancel(task, zone);
+}
+
 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);
 }
 
 Timer _rootCreatePeriodicTimer(
     Zone self, ZoneDelegate parent, Zone zone,
@@ skipping 51 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);
   }
 
+  Task createTask(TaskSpecification task, TaskCreate create) {
+    return _rootcreateTask(null, null, this, task, create);
+  }
+
+  void runTask(Task task, Object arg, TaskRun run) {
+    _rootRunTask(null, null, this, task, arg, run);
+  }
+
+  void cancelTask(Task 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);
   }
 }