Use "self" instead of globalThis.

dart/sdk/lib/_internal/lib/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 _isolate_helper;
 
 import 'dart:async';
 import 'dart:collection' show Queue, HashMap;
 import 'dart:isolate';
 import 'dart:_js_helper' show
@@ skipping 210 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); }})(#, #)",
         DART_CLOSURE_TO_JS(IsolateNatives._processWorkerMessage),
         mainManager);
-    JS("void", r"#.onmessage = #", globalThis, function);
+    JS("void", r"self.onmessage = #", function);
     // We define dartPrint so that the implementation of the Dart
     // print method knows what to call.
     // TODO(ngeoffray): Should we forward to the main isolate? What if
     // it exited?
-    JS('void', r'#.dartPrint = function (object) {}', globalThis);
+    JS('void', r'self.dartPrint = function (object) {}');
   }
 
 
   /**
    * Close the worker running this code if all isolates are done and
    * there are no active async JavaScript tasks still running.
    */
   void maybeCloseWorker() {
     if (isWorker
         && isolates.isEmpty
@@ skipping 149 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', '#.console != null && '
-                     'typeof #.console.error == "function"',
-                     globalThis, globalThis)) {
-        JS('void', '#.console.error(#, #)', globalThis, error, stackTrace);
+      if (JS('bool', '!!self.console && !!self.console.error')) {
+        JS('void', 'self.console.error(#, #)', 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 258 matching lines @@
     //
     // See: http://www.w3.org/TR/workers/#the-global-scope
     // and: http://www.w3.org/TR/Window/#dfn-self-attribute
     JS("void", r"self.postMessage(#)", msg);
   }
 }
 
 const String _SPAWNED_SIGNAL = "spawned";
 const String _SPAWN_FAILED_SIGNAL = "spawn failed";
 
-var globalThis = Primitives.computeGlobalThis();
-var globalWindow = JS('', "#.window", globalThis);
-var globalWorker = JS('', "#.Worker", globalThis);
-bool globalPostMessageDefined =
-    JS('', "#.postMessage !== (void 0)", globalThis);
+get globalWindow => JS('', "self.window");
+get globalWorker => JS('', "self.Worker");
+bool get globalPostMessageDefined => JS('bool', "!!self.postMessage");
 
 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 {
 
   // We set [enableSpawnWorker] to true (not null) when calling isolate
@@ skipping 159 matching lines @@
     } else {
       try {
         _consoleLog(msg);
       } catch (e, trace) {
         throw new Exception(trace);
       }
     }
   }
 
   static void _consoleLog(msg) {
-    JS("void", r"#.console.log(#)", globalThis, msg);
+    JS("void", r"self.console.log(#)", msg);
   }
 
   static _getJSFunctionFromName(String functionName) {
     return JS("", "init.globalFunctions[#]()", functionName);
   }
 
   /**
    * Get a string name for the function, if possible.  The result for
    * anonymous functions is browser-dependent -- it may be "" or "anonymous"
    * but you should probably not count on this.
@@ skipping 822 matching lines @@
     } else if (hasTimer()) {
 
       void internalCallback() {
         _handle = null;
         leaveJsAsync();
         callback();
       }
 
       enterJsAsync();
 
-      _handle = JS('int', '#.setTimeout(#, #)',
-                   globalThis,
+      _handle = JS('int', 'self.setTimeout(#, #)',
                    convertDartClosureToJS(internalCallback, 0),
                    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', '#.setInterval(#, #)',
-                   globalThis,
+      _handle = JS('int', 'self.setInterval(#, #)',
                    convertDartClosureToJS(() { callback(this); }, 0),
                    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', '#.clearTimeout(#)', globalThis, _handle);
+        JS('void', 'self.clearTimeout(#)', _handle);
       } else {
-        JS('void', '#.clearInterval(#)', globalThis, _handle);
+        JS('void', 'self.clearInterval(#)', _handle);
       }
       _handle = null;
     } else {
       throw new UnsupportedError("Canceling a timer.");
     }
   }
 
   bool get isActive => _handle != null;
 }
 
-bool hasTimer() => JS('', '#.setTimeout', globalThis) != null;
+bool hasTimer() => JS('', 'self.setTimeout') != 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. */
   final int _id;
@@ skipping 18 matching lines @@
   }
 
   bool operator==(Object other) {
     if (identical(other, this)) return true;
     if (other is CapabilityImpl) {
       return identical(_id, other._id);
     }
     return false;
   }
 }