Add package config support to dart:isolate

runtime/lib/isolate_patch.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.
 
 import "dart:collection" show HashMap;
 import "dart:_internal";
 
 patch class ReceivePort {
   /* patch */ factory ReceivePort() = _ReceivePortImpl;
 
@@ skipping 252 matching lines @@
     } else {
       entryPoint(message);
     }
   };
   // Make sure the message handler is triggered.
   port.sendPort.send(null);
 }
 
 patch class Isolate {
   static final _currentIsolate = _getCurrentIsolate();
+  static final _rootUri = _getCurrentRootUri();
 
   /* patch */ static Isolate get current => _currentIsolate;
 
+  /* patch */ static Future<Uri> get packageRoot {
+    var hook = VMLibraryHooks.packageRootUriFuture;
+    if (hook == null) {
+      throw new UnsupportedError("Isolate.packageRoot");
+    }
+    return hook();
+  }
+
+  /* patch */ static Future<Uri> get packageConfig {
+    var hook = VMLibraryHooks.packageConfigUriFuture;
+    if (hook == null) {
+      throw new UnsupportedError("Isolate.packageConfig");
+    }
+    return hook();
+  }
+
+  /* patch */ static Future<Uri> resolvePackageUri(Uri packageUri) {
+    var hook = VMLibraryHooks.resolvePackageUriFuture;
+    if (hook == null) {
+      throw new UnsupportedError("Isolate.resolvePackageUri");
+    }
+    return hook(packageUri);
+  }
+
+  static bool _packageSupported() =>
+      (VMLibraryHooks.packageRootUriFuture != null) &&
+      (VMLibraryHooks.packageConfigUriFuture != null);
+
   /* patch */ static Future<Isolate> spawn(
       void entryPoint(message), var message,
       {bool paused: false, bool errorsAreFatal,
-       SendPort onExit, SendPort onError}) {
+       SendPort onExit, SendPort onError}) async {
     // `paused` isn't handled yet.
     RawReceivePort readyPort;
     try {
       // The VM will invoke [_startIsolate] with entryPoint as argument.
       readyPort = new RawReceivePort();
+      var packageRoot = null;
+      var packageConfig = null;
+      if (Isolate._packageSupported()) {
+        packageRoot = (await Isolate.packageRoot)?.toString();
+        packageConfig = (await Isolate.packageConfig)?.toString();
+      }
+
       _spawnFunction(readyPort.sendPort, entryPoint, message,
-                     paused, errorsAreFatal, onExit, onError);
-      return _spawnCommon(readyPort);
+                     paused, errorsAreFatal, onExit, onError,
+                     packageRoot, packageConfig);
+      return await _spawnCommon(readyPort);
     } catch (e, st) {
       if (readyPort != null) {
         readyPort.close();
       }
-      return new Future<Isolate>.error(e, st);
+      return await new Future<Isolate>.error(e, st);
     }
   }
 
   /* patch */ static Future<Isolate> spawnUri(
       Uri uri, List<String> args, var message,
       {bool paused: false,
        SendPort onExit,
        SendPort onError,
        bool errorsAreFatal,
        bool checked,
        Map<String, String> environment,
-       Uri packageRoot}) {
+       Uri packageRoot,
+       Uri packageConfig,
+       bool automaticPackageResolution: false}) async {
     RawReceivePort readyPort;
-    if (environment != null) throw new UnimplementedError("environment");
+    if (environment != null) {
+      throw new UnimplementedError("environment");
+    }
+
+    // Verify that no mutually exclusive arguments have been passed.
+    if (automaticPackageResolution) {
+      if (packageRoot != null) {
+        throw new ArgumentError("Cannot simultaneously request "
+                                "automaticPackageResolution and specify a"
+                                "packageRoot.");
+      }
+      if (packageConfig != null) {
+        throw new ArgumentError("Cannot simultaneously request "
+                                "automaticPackageResolution and specify a"
+                                "packageConfig.");
+      }
+    } else {
+      if ((packageRoot != null) && (packageConfig != null)) {
+        throw new ArgumentError("Cannot simultaneously specify a "
+                                "packageRoot and a packageConfig.");
+      }
+    }
     try {
+      // Resolve the uri agains the current isolate's root Uri first.
+      var spawnedUri = _rootUri.resolveUri(uri);
+
+      // Inherit this isolate's package resolution setup if not overridden.
+      if (!automaticPackageResolution &&
+          (packageRoot == null) &&
+          (packageConfig == null)) {
+        if (Isolate._packageSupported()) {
+          packageRoot = await Isolate.packageRoot;
+          packageConfig = await Isolate.packageConfig;
+        }
+      }
+
       // The VM will invoke [_startIsolate] and not `main`.
       readyPort = new RawReceivePort();
-      var packageRootString =
-          (packageRoot == null) ? null : packageRoot.toString();
-      var packagesList = null;
+      var packageRootString = packageRoot?.toString();
+      var packageConfigString = packageConfig?.toString();
 
-      _spawnUri(readyPort.sendPort, uri.toString(),
+      _spawnUri(readyPort.sendPort, spawnedUri.toString(),
                 args, message,
                 paused, onExit, onError,
                 errorsAreFatal, checked,
                 null, /* environment */
-                packageRootString, packagesList);
-      return _spawnCommon(readyPort);
+                packageRootString, packageConfigString);
+      return await _spawnCommon(readyPort);
     } catch (e, st) {
       if (readyPort != null) {
         readyPort.close();
       }
-      return new Future<Isolate>.error(e, st);
+      return await new Future<Isolate>.error(e, st);
     }
   }
 
   static Future<Isolate> _spawnCommon(RawReceivePort readyPort) {
     Completer completer = new Completer<Isolate>.sync();
     readyPort.handler = (readyMessage) {
       readyPort.close();
       if (readyMessage is List && readyMessage.length == 2) {
         SendPort controlPort = readyMessage[0];
         List capabilities = readyMessage[1];
@@ skipping 23 matching lines @@
   static const _KILL = 4;
   static const _ADD_EXIT = 5;
   static const _DEL_EXIT = 6;
   static const _ADD_ERROR = 7;
   static const _DEL_ERROR = 8;
   static const _ERROR_FATAL = 9;
 
 
   static void _spawnFunction(SendPort readyPort, Function topLevelFunction,
                              var message, bool paused, bool errorsAreFatal,
-                             SendPort onExit, SendPort onError)
+                             SendPort onExit, SendPort onError,
+                             String packageRoot, String packageConfig)
       native "Isolate_spawnFunction";
 
   static void _spawnUri(SendPort readyPort, String uri,
                         List<String> args, var message,
                         bool paused, SendPort onExit, SendPort onError,
                         bool errorsAreFatal, bool checked,
                         List environment,
-                        String packageRoot, List packages)
+                        String packageRoot, String packageConfig)
       native "Isolate_spawnUri";
 
   static void _sendOOB(port, msg) native "Isolate_sendOOB";
 
   /* patch */ void _pause(Capability resumeCapability) {
     var msg = new List(4)
         ..[0] = 0  // Make room for OOB message type.
         ..[1] = _PAUSE
         ..[2] = pauseCapability
         ..[3] = resumeCapability;
@@ skipping 74 matching lines @@
 
   static Isolate _getCurrentIsolate() {
     List portAndCapabilities = _getPortAndCapabilitiesOfCurrentIsolate();
     return new Isolate(portAndCapabilities[0],
                        pauseCapability: portAndCapabilities[1],
                        terminateCapability: portAndCapabilities[2]);
   }
 
   static List _getPortAndCapabilitiesOfCurrentIsolate()
       native "Isolate_getPortAndCapabilitiesOfCurrentIsolate";
+
+  static Uri _getCurrentRootUri() {
+    try {
+      return Uri.parse(_getCurrentRootUriStr());
+    } catch (e, s) {
+      return null;
+    }
+  }
+
+  static String _getCurrentRootUriStr()
+      native "Isolate_getCurrentRootUriStr";
 }