fixes #168, dart:js implementation with a test

tool/input_sdk/private/isolate_helper.dart

 // Copyright (c) 2012, 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.
 
 library dart._isolate_helper;
 
 import 'dart:_js_embedded_names' show
     CLASS_ID_EXTRACTOR,
     CLASS_FIELDS_EXTRACTOR,
     CURRENT_SCRIPT,
     GLOBAL_FUNCTIONS,
     INITIALIZE_EMPTY_INSTANCE,
     INSTANCE_FROM_CLASS_ID;
 
 import 'dart:async';
 import 'dart:collection' show Queue, HashMap;
 import 'dart:isolate';
 import 'dart:_native_typed_data' show NativeByteBuffer, NativeTypedData;
 
 import 'dart:_js_helper' show
     InternalMap,
     Null,
     Primitives,
-    convertDartClosureToJS,
     random64;
 
-import 'dart:_foreign_helper' show DART_CLOSURE_TO_JS,
-                                   JS,
+import 'dart:_foreign_helper' show JS,
                                    JS_CREATE_ISOLATE,
                                    JS_CURRENT_ISOLATE_CONTEXT,
                                    JS_CURRENT_ISOLATE,
                                    JS_EMBEDDED_GLOBAL,
                                    JS_SET_CURRENT_ISOLATE,
                                    IsolateContext;
 
 import 'dart:_interceptors' show Interceptor,
                                  JSArray,
                                  JSExtendableArray,
@@ skipping 199 matching lines @@
 
     isWorker = !isWindowDefined && globalPostMessageDefined;
     supportsWorkers = isWorker
        || (isWorkerDefined && IsolateNatives.thisScript != null);
     fromCommandLine = !isWindowDefined && !isWorker;
   }
 
   void _nativeInitWorkerMessageHandler() {
     var function = JS('',
         "(function (f, a) { return function (e) { f(a, e); }})(#, #)",
-        DART_CLOSURE_TO_JS(IsolateNatives._processWorkerMessage),
+        IsolateNatives._processWorkerMessage,
         mainManager);
     JS("void", r"self.onmessage = #", function);
     // We ensure dartPrint is defined so that the implementation of the Dart
     // print method knows what to call.
     JS('', '''self.dartPrint = self.dartPrint || (function(serialize) {
   return function (object) {
     if (self.console && self.console.log) {
       self.console.log(object)
     } else {
       self.postMessage(serialize(object));
     }
   }
-})(#)''', DART_CLOSURE_TO_JS(_serializePrintMessage));
+})(#)''', _serializePrintMessage);
   }
 
   static _serializePrintMessage(object) {
     return _serializeMessage({"command": "print", "msg": object});
   }
 
   /**
    * Close the worker running this code if all isolates are done and
    * there are no active async JavaScript tasks still running.
    */
@@ skipping 821 matching lines @@
     // top-level or static methods, and the trampoline allows us to capture
     // arguments and values which can be passed to a static method.
     final onerrorTrampoline = JS(
         '',
         '''
 (function (f, u, c) {
   return function(e) {
     return f(e, u, c)
   }
 })(#, #, #)''',
-        DART_CLOSURE_TO_JS(workerOnError), uri, onError);
+        workerOnError, uri, onError);
     JS('void', '#.onerror = #', worker, onerrorTrampoline);
 
     var processWorkerMessageTrampoline = JS(
         '',
         """
 (function (f, a) {
   return function (e) {
     // We can stop listening for errors when the first message is received as
     // we only listen for messages to determine if the uri was bad.
     e.onerror = null;
     return f(a, e);
   }
 })(#, #)""",
-        DART_CLOSURE_TO_JS(_processWorkerMessage),
+        _processWorkerMessage,
         worker);
     JS('void', '#.onmessage = #', worker, processWorkerMessageTrampoline);
     var workerId = _globalState.nextManagerId++;
     // We also store the id on the worker itself so that we can unregister it.
     workerIds[worker] = workerId;
     _globalState.managers[workerId] = worker;
     JS('void', '#.postMessage(#)', worker, _serializeMessage({
         'command': 'start',
         'id': workerId,
         // Note: we serialize replyPort twice because the child worker needs to
@@ skipping 232 matching lines @@
     } else if (hasTimer()) {
 
       void internalCallback() {
         _handle = null;
         leaveJsAsync();
         callback();
       }
 
       enterJsAsync();
 
-      _handle = JS('int', 'self.setTimeout(#, #)',
-                   convertDartClosureToJS(internalCallback, 0),
-                   milliseconds);
+      _handle = JS(
+          'int', 'self.setTimeout(#, #)', internalCallback, milliseconds);
     } else {
       assert(milliseconds > 0);
       throw new UnsupportedError("Timer greater than 0.");
     }
   }
 
   TimerImpl.periodic(int milliseconds, void callback(Timer timer))
       : _once = false {
     if (hasTimer()) {
       enterJsAsync();
       _handle = JS('int', 'self.setInterval(#, #)',
-                   convertDartClosureToJS(() { callback(this); }, 0),
-                   milliseconds);
+          () { callback(this); }, milliseconds);
     } else {
       throw new UnsupportedError("Periodic timer.");
     }
   }
 
   void cancel() {
     if (hasTimer()) {
       if (_inEventLoop) {
         throw new UnsupportedError("Timer in event loop cannot be canceled.");
       }
@@ skipping 47 matching lines @@
   }
 
   bool operator==(Object other) {
     if (identical(other, this)) return true;
     if (other is CapabilityImpl) {
       return identical(_id, other._id);
     }
     return false;
   }
 }