Make zone variables accept any value as key.

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 14 matching lines @@
     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<Symbol, dynamic> zoneValues);
+                         Map zoneValues);
 
 /**
  * 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.
  *
  * Handlers have the same signature as the same-named methods on [Zone] but
  * receive three additional arguments:
@@ skipping 56 matching lines @@
         Zone self, ZoneDelegate parent, Zone zone, f(arg1, arg2)): null,
     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,
     void print(Zone self, ZoneDelegate parent, Zone zone, String line): null,
     Zone fork(Zone self, ZoneDelegate parent, Zone zone,
               ZoneSpecification specification,
-              Map<Symbol, dynamic> zoneValues): null
+              Map zoneValues): null
   }) {
     return new ZoneSpecification(
       handleUncaughtError: handleUncaughtError != null
                            ? handleUncaughtError
                            : other.handleUncaughtError,
       run: run != null ? run : other.run,
       runUnary: runUnary != null ? runUnary : other.runUnary,
       runBinary: runBinary != null ? runBinary : other.runBinary,
       registerCallback: registerCallback != null
                         ? registerCallback
@@ skipping 125 matching lines @@
   /**
    * Returns true if `this` and [otherZone] are in the same error zone.
    *
    * Two zones are in the same error zone if they share the same
    * [handleUncaughtError] callback.
    */
   bool inSameErrorZone(Zone otherZone);
 
   /**
    * Creates a new zone as a child of `this`.
+   *
+   * The new zone will have behavior like the current zone, except where
+   * overridden by functions in [specification].
+   *
+   * The new zone will have the same stored values (accessed through
+   * `operator []`) as this zone, but updated with the keys and values
+   * in [zoneValues]. If a key is in both this zone's values and in
+   * `zoneValues`, the new zone will use the value from `zoneValues``.
    */
   Zone fork({ ZoneSpecification specification,
-              Map<Symbol, dynamic> zoneValues });
+              Map zoneValues });
 
   /**
    * Executes the given function [f] in this zone.
    */
   dynamic run(f());
 
   /**
    * Executes the given callback [f] with argument [arg] in this zone.
    */
   dynamic runUnary(f(arg), var arg);
@@ skipping 134 matching lines @@
   static void _leave(Zone previous) {
     assert(previous != null);
     Zone._current = previous;
   }
 
   /**
    * Retrieves the zone-value associated with [key].
    *
    * If this zone does not contain the value looks up the same key in the
    * parent zone. If the [key] is not found returns `null`.
+   *
+   * Any object can be used as key, as long as it has compatible `operator ==`
+   * and `hashCode` implementations.
+   * By controlling access to the key, a zone can grant or deny access to the
+   * zone value.
    */
-  operator[](Symbol key);
+  operator [](Object key);
 }
 
 class _ZoneDelegate implements ZoneDelegate {
   final _BaseZone _degelationTarget;
 
   Zone get _zone => _degelationTarget;
 
   const _ZoneDelegate(this._degelationTarget);
 
   dynamic handleUncaughtError(Zone zone, error, StackTrace stackTrace) {
@@ skipping 90 matching lines @@
   void print(Zone zone, String line) {
     _BaseZone parent = _degelationTarget;
     while (parent._specification.print == null) {
       parent = parent.parent;
     }
     (parent._specification.print)(
         parent, new _ZoneDelegate(parent.parent), zone, line);
   }
 
   Zone fork(Zone zone, ZoneSpecification specification,
-            Map<Symbol, dynamic> zoneValues) {
+            Map zoneValues) {
     _BaseZone parent = _degelationTarget;
     while (parent._specification.fork == null) {
       parent = parent.parent;
     }
     _ZoneDelegate grandParent = new _ZoneDelegate(parent.parent);
     return (parent._specification.fork)(
         parent, grandParent, zone, specification, zoneValues);
   }
 }
 
@@ skipping 73 matching lines @@
 
 
 /**
  * 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;
+  final Map _map;
 
   const _CustomizedZone(this.parent, this._specification, this._map);
 
   Zone get _errorZone {
     if (_specification.handleUncaughtError != null) return this;
     return parent._errorZone;
   }
 
-  operator [](Symbol key) {
+  operator [](Object 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;
   }
 
   // Methods that can be customized by the zone specification.
 
@@ skipping 137 matching lines @@
 void _rootPrint(Zone self, ZoneDelegate parent, Zone zone, String line) {
   printToConsole(line);
 }
 
 void _printToZone(String line) {
   Zone.current.print(line);
 }
 
 Zone _rootFork(Zone self, ZoneDelegate parent, Zone zone,
                ZoneSpecification specification,
-               Map<Symbol, dynamic> zoneValues) {
+               Map zoneValues) {
   // TODO(floitsch): it would be nice if we could get rid of this hack.
   // Change the static zoneOrDirectPrint function to go through zones
   // from now on.
   printToZone = _printToZone;
 
   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();
+  Map copiedMap = new HashMap();
   if (zoneValues != null) {
-    zoneValues.forEach((Symbol key, value) {
-      if (key == null) {
-        throw new ArgumentError("ZoneValue key must not be null");
-      }
+    zoneValues.forEach((key, value) {
       copiedMap[key] = value;
     });
   }
   return new _CustomizedZone(zone, specification, copiedMap);
 }
 
 class _RootZoneSpecification implements ZoneSpecification {
   const _RootZoneSpecification();
 
   HandleUncaughtErrorHandler get handleUncaughtError =>
@@ skipping 16 matching lines @@
 
 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;
+  operator [](Object 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);
@@ skipping 47 matching lines @@
  *       }, onError: (e) { print("unused error handler"); });
  *     }, onError: (e) { print("catches error of first error-zone."); });
  *
  * Example:
  *
  *     runZoned(() {
  *       new Future(() { throw "asynchronous error"; });
  *     }, onError: print);  // Will print "asynchronous error".
  */
 dynamic runZoned(body(),
-                 { Map<Symbol, dynamic> zoneValues,
+                 { Map zoneValues,
                    ZoneSpecification zoneSpecification,
                    Function onError }) {
   HandleUncaughtErrorHandler errorHandler;
   if (onError != null) {
     errorHandler = (Zone self, ZoneDelegate parent, Zone zone,
                     error, StackTrace stackTrace) {
       try {
         if (onError is ZoneBinaryCallback) {
           return self.parent.runBinary(onError, error, stackTrace);
         }
@@ skipping 16 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);
   }
 }