Enable more async code on node

pkg/dev_compiler/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,
@@ skipping 227 matching lines @@
     supportsWorkers = isWorker
        || (isWorkerDefined && IsolateNatives.thisScript != null);
     fromCommandLine = !isWindowDefined && !isWorker;
   }
 
   void _nativeInitWorkerMessageHandler() {
     var function = JS('',
         "(function (f, a) { return function (e) { f(a, e); }})(#, #)",
         IsolateNatives._processWorkerMessage,
         mainManager);
-    JS("void", r"self.onmessage = #", function);
+    JS("void", r"#.onmessage = #", global, 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) {
+    JS('', '''#.dartPrint = #.dartPrint || (function(serialize) {
   return function (object) {
-    if (self.console && self.console.log) {
-      self.console.log(object)
+    var _self = #;
+    if (_self.console && _self.console.log) {
+      _self.console.log(object)
     } else {
-      self.postMessage(serialize(object));
+      _self.postMessage(serialize(object));
     }
   }
-})(#)''', _serializePrintMessage);
+})(#)''', global, global, global, _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 152 matching lines @@
   /** Function called with an uncaught error. */
   void handleUncaughtError(error, StackTrace stackTrace) {
     // Just print the error if there is no error listener registered.
     if (errorPorts.isEmpty) {
       // An uncaught error in the root isolate will terminate the program?
       if (errorsAreFatal && identical(this, _globalState.rootContext)) {
         // The error will be rethrown to reach the global scope, so
         // don't print it.
         return;
       }
-      if (JS('bool', 'self.console && self.console.error')) {
-        JS('void', 'self.console.error(#, #)', error, stackTrace);
+      if (JS('bool', '#.console && #.console.error', global, global)) {
+        JS('void', '#.console.error(#, #)', global, error, stackTrace);
       } else {
         print(error);
         if (stackTrace != null) print(stackTrace);
       }
       return;
     }
     List message = new List(2)
         ..[0] = error.toString()
         ..[1] = (stackTrace == null) ? null : stackTrace.toString();
     for (SendPort port in errorPorts) port.send(message);
@@ skipping 249 matching lines @@
   }
 }
 
 // "self" is a way to refer to the global context object that
 // works in HTML pages and in Web Workers.  It does not work in d8, iojs
 // and Firefox jsshell, because that would have been too easy. In iojs
 // "global" works.
 //
 // See: http://www.w3.org/TR/workers/#the-global-scope
 // and: http://www.w3.org/TR/Window/#dfn-self-attribute
-final _global =
+final global =
   JS("", "typeof global == 'undefined' ? self : global");
 
 /** A stub for interacting with the main manager. */
 class _MainManagerStub {
   void postMessage(msg) {
-    JS("void", r"#.postMessage(#)", _global, msg);
+    JS("void", r"#.postMessage(#)", global, msg);
   }
 }
 
 const String _SPAWNED_SIGNAL = "spawned";
 const String _SPAWN_FAILED_SIGNAL = "spawn failed";
 
 get globalWindow {
-  return JS('', "#.window", _global);
+  return JS('', "#.window", global);
 }
 
 get globalWorker {
-  return JS('', "#.Worker", _global);
+  return JS('', "#.Worker", global);
 }
 bool get globalPostMessageDefined {
-  return JS('bool', "!!#.postMessage", _global);
+  return JS('bool', "!!#.postMessage", global);
 }
 
 typedef _MainFunction();
 typedef _MainFunctionArgs(args);
 typedef _MainFunctionArgsMessage(args, message);
 
 /// Note: IsolateNatives depends on _globalState which is only set up correctly
 /// when 'dart:isolate' has been imported.
 class IsolateNatives {
 
@@ skipping 164 matching lines @@
     } else {
       try {
         _consoleLog(msg);
       } catch (e, trace) {
         throw new Exception(trace);
       }
     }
   }
 
   static void _consoleLog(msg) {
-    JS("void", r"self.console.log(#)", msg);
+    JS("void", r"#.console.log(#)", global, msg);
   }
 
   static _getJSFunctionFromName(String functionName) {
     var globalFunctionsContainer = JS_EMBEDDED_GLOBAL("", GLOBAL_FUNCTIONS);
     return JS("", "#[#]()", globalFunctionsContainer, functionName);
   }
 
   /**
    * Get a string name for the function, if possible.  The result for
    * anonymous functions is browser-dependent -- it may be "" or "anonymous"
@@ skipping 445 matching lines @@
 
       void internalCallback() {
         _handle = null;
         leaveJsAsync();
         callback();
       }
 
       enterJsAsync();
 
       _handle = JS(
-          'int', 'self.setTimeout(#, #)', internalCallback, milliseconds);
+          'int', '#.setTimeout(#, #)', global, 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(#, #)',
-          () { callback(this); }, milliseconds);
+      _handle = JS('int', '#.setInterval(#, #)',
+          global, () { 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.");
       }
       if (_handle == null) return;
       leaveJsAsync();
       if (_once) {
-        JS('void', 'self.clearTimeout(#)', _handle);
+        JS('void', '#.clearTimeout(#)', global, _handle);
       } else {
-        JS('void', 'self.clearInterval(#)', _handle);
+        JS('void', '#.clearInterval(#)', global, _handle);
       }
       _handle = null;
     } else {
       throw new UnsupportedError("Canceling a timer.");
     }
   }
 
   bool get isActive => _handle != null;
 }
 
 bool hasTimer() {
-  return JS('', 'self.setTimeout') != null;
+  return JS('', '#.setTimeout', global) != null;
 }
 
 
 /**
  * Implementation class for [Capability].
  *
  * It has the same name to make it harder for users to distinguish.
  */
 class CapabilityImpl implements Capability {
   /** Internal random secret identifying the capability. */
@@ skipping 19 matching lines @@
   }
 
   bool operator==(Object other) {
     if (identical(other, this)) return true;
     if (other is CapabilityImpl) {
       return identical(_id, other._id);
     }
     return false;
   }
 }