Execute callbacks from JS in the correct zone

sdk/lib/js/dartium/js_dartium.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.
 
 /**
  * Support for interoperating with JavaScript.
  * 
  * This library provides access to JavaScript objects from Dart, allowing
  * Dart code to get and set properties, and call methods of JavaScript objects
  * and invoke JavaScript functions. The library takes care of converting
@@ skipping 69 matching lines @@
  * `a` and `b` defined:
  *
  *     var jsMap = new JsObject.jsify({'a': 1, 'b': 2});
  * 
  * This expression creates a JavaScript array:
  *
  *     var jsArray = new JsObject.jsify([1, 2, 3]);
  */
 library dart.js;
 
+import 'dart:async' show Zone;
 import 'dart:collection' show ListMixin;
 import 'dart:nativewrappers';
 
 JsObject _cachedContext;
 
 JsObject get _context native "Js_context_Callback";
 
 JsObject get context {
   if (_cachedContext == null) {
     _cachedContext = _context;
@@ skipping 64 matching lines @@
    * The type of [property] must be either [String] or [num].
    */
   operator[](property) native "JsObject_[]";
 
   /**
    * Sets the value associated with [property] on the proxied JavaScript
    * object.
    *
    * The type of [property] must be either [String] or [num].
    */
-  operator[]=(property, value) native "JsObject_[]=";
+  operator[]=(property, value) {
+    return _setIndex(property, _maybeWrapFunction(value));
+  }
+
+  Object _setIndex(property, value) native "JsObject_[]=";
 
   int get hashCode native "JsObject_hashCode";
 
   operator==(other) => other is JsObject && _identityEquality(this, other);
 
   static bool _identityEquality(JsObject a, JsObject b) native "JsObject_identityEquality";
 
   /**
    * Returns `true` if the JavaScript object contains the specified property
    * either directly or though its prototype chain.
@@ skipping 30 matching lines @@
   String _toString() native "JsObject_toString";
 
   /**
    * Calls [method] on the JavaScript object with the arguments [args] and
    * returns the result.
    *
    * The type of [method] must be either [String] or [num].
    */
   callMethod(String method, [List args]) {
     try {
+      args = args == null ? null : args.map(_maybeWrapFunction).toList();
       return _callMethod(method, args);
     } catch(e) {
       if (hasProperty(method)) {
         rethrow;
       } else {
         throw new NoSuchMethodError(this, new Symbol(method), args, null);
       }
     }
   }
 
   _callMethod(String name, List args) native "JsObject_callMethod";
 }
 
 /**
  * Proxies a JavaScript Function object.
  */
 class JsFunction extends JsObject {
   JsFunction.internal() : super.internal();
 
   /**
    * Returns a [JsFunction] that captures its 'this' binding and calls [f]
    * with the value of this passed as the first argument.
    */
-  factory JsFunction.withThis(Function f) => _withThis(f);
+  factory JsFunction.withThis(Function f) => _withThis(_maybeWrapFunction(f));
 
   /**
    * Invokes the JavaScript function with arguments [args]. If [thisArg] is
    * supplied it is the value of `this` for the invocation.
    */
   dynamic apply(List args, {thisArg}) native "JsFunction_apply";
 
   /**
    * Internal only version of apply which uses debugger proxies of Dart objects
    * rather than opaque handles. This method is private because it cannot be
@@ skipping 93 matching lines @@
     if (skipCount < 0) throw new ArgumentError(skipCount);
     var args = [start, length]..addAll(iterable.skip(skipCount).take(length));
     callMethod('splice', args);
   }
 
   void sort([int compare(E a, E b)]) {
     callMethod('sort', [compare]);
   }
 }
 
+_maybeWrapFunction(value) {
+  if (value is Function) return _applyZoned(value);

[Jacob, 2014/04/10 00:51:53]

nit: the following is cleaner.
_maybeWrapFunction(value) => value is Function ? _applyZoned(value) : value;

[justinfagnani, 2014/04/10 03:55:05]

Done.

+  return value;
+}
+
+_applyZoned(f) {
+  var call = (List arguments) => Function.apply(f, arguments);
+  if (Zone.current == Zone.ROOT) return call;
+  return Zone.current.bindUnaryCallback(call);
+}
+
 /**
  * Placeholder object for cases where we need to determine exactly how many
  * args were passed to a function.
  */
 const _UNDEFINED = const Object();
 
 // FIXME(jacobr): this method is a hack to work around the lack of proper dart
 // support for varargs methods.
 List _stripUndefinedArgs(List args) =>
     args.takeWhile((i) => i != _UNDEFINED).toList();
 
 /**
  * Returns a method that can be called with an arbitrary number (for n less
  * than 11) of arguments without violating Dart type checks.
  */
 Function _wrapAsDebuggerVarArgsFunction(JsFunction jsFunction) =>
   ([a1=_UNDEFINED, a2=_UNDEFINED, a3=_UNDEFINED, a4=_UNDEFINED,
     a5=_UNDEFINED, a6=_UNDEFINED, a7=_UNDEFINED, a8=_UNDEFINED,
     a9=_UNDEFINED, a10=_UNDEFINED]) =>
     jsFunction._applyDebuggerOnly(_stripUndefinedArgs(
         [a1,a2,a3,a4,a5,a6,a7,a8,a9,a10]));