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 726 matching lines @@
 
 Zone _rootFork(Zone self, ZoneDelegate parent, Zone zone,
                ZoneSpecification specification,
                Map<Symbol, dynamic> zoneValues) {
   if (specification == null) {
     specification = const ZoneSpecification();
   } else if (specification is! _ZoneSpecification) {
     throw new ArgumentError("ZoneSpecifications must be instantiated"
         " with the provided constructor.");
   }
   Map<Symbol, dynamic> copiedMap = new HashMap();

[Lasse Reichstein Nielsen, 2013/10/15 12:04:07]

Why was the zoneValues based on Symbols only?
I see no problem using any kind of key.

[floitsch, 2013/10/15 13:06:07]

We can change later.

   if (zoneValues != null) {
     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 _CustomizedZone {
+  const _RootZone()
+      : super(null, const _RootZoneSpecification(), const <Symbol, dynamic>{});

[Lasse Reichstein Nielsen, 2013/10/15 12:04:07]

Can you replace the map with null, since it is never read?

You override ... 15 out of 22 methods. 
Are you sure it wouldn't be easier to implement Zone and do the remaining five,
instead of passing irrelevant data to the super constructor.

[floitsch, 2013/10/15 13:06:07]

Done.

+
+  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_SPECIFICATION = const _RootZoneSpecification();
+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);
   }
 }