Create _RootZone and _RootSpecification.

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);
 
@@ skipping 503 matching lines @@
       parent = parent.parent;
     }
     _ZoneDelegate grandParent = new _ZoneDelegate(parent.parent);
     return (parent._specification.fork)(
         parent, grandParent, zone, specification, zoneValues);
   }
 }
 
 
 /**
- * Default implementation of a [Zone].
+ * Base class for Zone implementations.
  */
-class _CustomizedZone implements Zone {
+abstract class _BaseZone implements Zone {
+  const _BaseZone();
+
   /// The parent zone.
-  final _CustomizedZone parent;
+  _BaseZone get parent;
   /// The zone's handlers.
-  final ZoneSpecification _specification;
-  /// The zone's value map.
-  final Map<Symbol, dynamic> _map;
-
-  const _CustomizedZone(this.parent, this._specification, this._map);
-
-  Zone get _errorZone {
-    if (_specification.handleUncaughtError != null) return this;
-    return parent._errorZone;
-  }
+  ZoneSpecification get _specification;
+  /**
+   * The closest error-handling zone.
+   *
+   * Returns `this` if `this` has an error-handler. Otherwise returns the
+   * parent's error-zone.
+   */
+  Zone get _errorZone;
 
   bool inSameErrorZone(Zone otherZone) => _errorZone == otherZone._errorZone;
 
   dynamic runGuarded(f()) {
     try {
       return run(f);
     } catch (e, s) {
       return handleUncaughtError(e, s);
     }
   }
@@ skipping 34 matching lines @@
 
   ZoneBinaryCallback bindBinaryCallback(
       f(arg1, arg2), { bool runGuarded: true }) {
     ZoneBinaryCallback registered = registerBinaryCallback(f);
     if (runGuarded) {
       return (arg1, arg2) => this.runBinaryGuarded(registered, arg1, arg2);
     } else {
       return (arg1, arg2) => this.runBinary(registered, arg1, arg2);
     }
   }
+}
+
+
+/**
+ * Default implementation of a [Zone].
+ */
+class _CustomizedZone extends _BaseZone {
+  final _BaseZone parent;
+  final ZoneSpecification _specification;
+
+  /// The zone's value map.
+  final Map<Symbol, dynamic> _map;
+
+  const _CustomizedZone(this.parent, this._specification, this._map);
+
+  Zone get _errorZone {
+    if (_specification.handleUncaughtError != null) return this;
+    return parent._errorZone;
+  }
 
   operator [](Symbol key) {
     var result = _map[key];
     if (result != null || _map.containsKey(key)) return result;
     // If we are not the root zone look up in the parent zone.
     if (parent != null) return parent[key];
     assert(this == Zone.ROOT);
     return null;
   }
 
@@ skipping 145 matching lines @@
     zoneValues.forEach((Symbol key, value) {
       if (key == null) {
         throw new ArgumentError("ZoneValue key must not be null");
       }
       copiedMap[key] = value;
     });
   }
   return new _CustomizedZone(zone, specification, copiedMap);
 }
 
-const _ROOT_SPECIFICATION = const ZoneSpecification(
-  handleUncaughtError: _rootHandleUncaughtError,
-  run: _rootRun,
-  runUnary: _rootRunUnary,
-  runBinary: _rootRunBinary,
-  registerCallback: _rootRegisterCallback,
-  registerUnaryCallback: _rootRegisterUnaryCallback,
-  registerBinaryCallback: _rootRegisterBinaryCallback,
-  scheduleMicrotask: _rootScheduleMicrotask,
-  createTimer: _rootCreateTimer,
-  createPeriodicTimer: _rootCreatePeriodicTimer,
-  fork: _rootFork
-);
+class _RootZoneSpecification implements ZoneSpecification {
+  const _RootZoneSpecification();
 
-const _ROOT_ZONE =
-    const _CustomizedZone(null, _ROOT_SPECIFICATION, const <Symbol, dynamic>{});
+  HandleUncaughtErrorHandler get handleUncaughtError =>
+      _rootHandleUncaughtError;
+  RunHandler get run => _rootRun;
+  RunUnaryHandler get runUnary => _rootRunUnary;
+  RunBinaryHandler get runBinary => _rootRunBinary;
+  RegisterCallbackHandler get registerCallback => _rootRegisterCallback;
+  RegisterUnaryCallbackHandler get registerUnaryCallback =>
+      _rootRegisterUnaryCallback;
+  RegisterBinaryCallbackHandler get registerBinaryCallback =>
+      _rootRegisterBinaryCallback;
+  ScheduleMicrotaskHandler get scheduleMicrotask => _rootScheduleMicrotask;
+  @deprecated
+  RunAsyncHandler get runAsync => null;
+  CreateTimerHandler get createTimer => _rootCreateTimer;
+  CreatePeriodicTimerHandler get createPeriodicTimer =>
+      _rootCreatePeriodicTimer;
+  ForkHandler get fork => _rootFork;
+}
+
+class _RootZone extends _BaseZone {
+  const _RootZone();
+
+  Zone get parent => null;
+  ZoneSpecification get _specification => const _RootZoneSpecification();
+  Zone get _errorZone => this;
+
+  bool inSameErrorZone(Zone otherZone) => otherZone._errorZone == this;
+
+  operator [](Symbol key) => null;
+
+  // Methods that can be customized by the zone specification.
+
+  dynamic handleUncaughtError(error, StackTrace stackTrace) =>
+      _rootHandleUncaughtError(this, null, this, error, stackTrace);
+
+  Zone fork({ZoneSpecification specification, Map zoneValues}) =>
+      _rootFork(this, null, this, specification, zoneValues);
+
+  dynamic run(f()) => _rootRun(this, null, this, f);
+
+  dynamic runUnary(f(arg), arg) => _rootRunUnary(this, null, this, f, arg);
+
+  dynamic runBinary(f(arg1, arg2), arg1, arg2) =>
+      _rootRunBinary(this, null, this, f, arg1, arg2);
+
+  ZoneCallback registerCallback(f()) =>
+      _rootRegisterCallback(this, null, this, f);
+
+  ZoneUnaryCallback registerUnaryCallback(f(arg)) =>
+      _rootRegisterUnaryCallback(this, null, this, f);
+
+  ZoneBinaryCallback registerBinaryCallback(f(arg1, arg2)) =>
+      _rootRegisterBinaryCallback(this, null, this, f);
+
+  void scheduleMicrotask(void f()) {
+    _rootScheduleMicrotask(this, null, this, f);
+  }
+
+  @deprecated
+  void runAsync(void f()) {
+    scheduleMicrotask(f);
+  }
+
+  Timer createTimer(Duration duration, void f()) =>
+      _rootCreateTimer(this, null, this, duration, f);
+
+  Timer createPeriodicTimer(Duration duration, void f(Timer timer)) =>
+      _rootCreatePeriodicTimer(this, null, this, duration, f);
+}
+
+const _ROOT_ZONE = const _RootZone();
 
 
 /**
  * Runs [body] in its own zone.
  *
  * If [onError] is non-null the zone is considered an error zone. All uncaught
  * errors, synchronous or asynchronous, in the zone are caught and handled
  * by the callback.
  *
  * Errors may never cross error-zone boundaries. This is intuitive for leaving
@@ skipping 106 matching lines @@
   ZoneSpecification specification =
     new ZoneSpecification(handleUncaughtError: errorHandler,
                           scheduleMicrotask: asyncHandler);
   Zone zone = Zone.current.fork(specification: specification);
   if (onError != null) {
     return zone.runGuarded(body);
   } else {
     return zone.run(body);
   }
 }