Add tasks to zones.

sdk/lib/async/zone.dart

Index: sdk/lib/async/zone.dart
diff --git a/sdk/lib/async/zone.dart b/sdk/lib/async/zone.dart
index 5cc4d88ef71082771c22389db2fb77be48485faa..c3f08d40ae5bd9ec03caf5b2d4a9eb0a00298042 100644
--- a/sdk/lib/async/zone.dart
+++ b/sdk/lib/async/zone.dart
@@ -8,6 +8,10 @@ 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());
@@ -23,19 +27,27 @@ 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);
+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);

[Lasse Reichstein Nielsen, 2016/05/20 22:01:36]

Just noticed: I'd swap the run function and the argument.

In runUnary and runBinary we pass the function before its arguments, this should
be consistent.

 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;
@@ -46,10 +58,87 @@ class AsyncError implements Error {
   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 {
+  final Zone zone;
+  /// The native timer.
+  final Timer timer;
+
+  TimerTask(this.timer, this.zone);
+}
+
+class SingleShotTimerTask extends TimerTask {
+  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);
 }
 
@@ -94,13 +183,23 @@ abstract class ZoneSpecification {
                              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;
 
   /**
@@ -125,14 +224,25 @@ abstract class ZoneSpecification {
                              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,
@@ -145,11 +255,15 @@ abstract class ZoneSpecification {
       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;
@@ -161,10 +275,16 @@ abstract class ZoneSpecification {
   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;
 }
 
 /**
@@ -185,10 +305,15 @@ class _ZoneSpecification implements ZoneSpecification {
     this.registerBinaryCallback: null,
     this.errorCallback: null,
     this.scheduleMicrotask: null,
-    this.createTimer: null,
-    this.createPeriodicTimer: null,
+    this.createTask: null,
+    this.runTask: null,
+    this.cancelTask: null,
     this.print: null,
-    this.fork: null
+    this.fork: null,
+    @deprecated
+    this.createTimer: null,
+    @deprecated
+    this.createPeriodicTimer: null
   });
 
   final HandleUncaughtErrorHandler handleUncaughtError;
@@ -200,10 +325,16 @@ class _ZoneSpecification implements ZoneSpecification {
   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;
 }
 
 /**
@@ -226,10 +357,16 @@ abstract class ZoneDelegate {
   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));
 }
 
 /**
@@ -413,14 +550,20 @@ abstract class 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));
 
   /**
@@ -543,18 +686,25 @@ class _ZoneDelegate implements ZoneDelegate {
     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) {
@@ -572,6 +722,22 @@ class _ZoneDelegate implements ZoneDelegate {
     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);
+  }
 }
 
 
@@ -589,11 +755,18 @@ abstract class _Zone implements Zone {
   _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;
@@ -615,12 +788,18 @@ class _CustomZone extends _Zone {
   _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;
 
@@ -666,12 +845,15 @@ class _CustomZone extends _Zone {
     _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;
@@ -681,6 +863,14 @@ class _CustomZone extends _Zone {
     _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;
   }
 
   /**
@@ -847,9 +1037,39 @@ class _CustomZone extends _Zone {
     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);
@@ -858,6 +1078,7 @@ class _CustomZone extends _Zone {
     return handler(implementation.zone, parentDelegate, this, duration, f);
   }
 
+  @deprecated
   Timer createPeriodicTimer(Duration duration, void f(Timer timer)) {
     _ZoneFunction implementation = this._createPeriodicTimer;
     assert(implementation != null);
@@ -866,14 +1087,6 @@ class _CustomZone extends _Zone {
     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(
@@ -949,21 +1162,40 @@ void _rootScheduleMicrotask(Zone self, ZoneDelegate parent, Zone zone, f()) {
   _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);
+    return;
+  }
+
+  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) {
@@ -1020,10 +1252,12 @@ class _RootZone extends _Zone {
       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 =>
@@ -1031,6 +1265,13 @@ class _RootZone extends _Zone {
   _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;
 
@@ -1155,6 +1396,18 @@ class _RootZone extends _Zone {
     _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);
   }