- Fix Isolate.spawn when running from snapshot.

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 282 matching lines @@
   /* 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);
+      (VMLibraryHooks.packageConfigUriFuture != null) &&
+      (VMLibraryHooks.resolvePackageUriFuture != null);
 
   /* patch */ static Future<Isolate> spawn(
       void entryPoint(message), var message,
       {bool paused: false, bool errorsAreFatal,
        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,
+      var script = VMLibraryHooks.platformScript;
+      if (script != null) {
+        if (script.scheme == "package") {
+          script = await Isolate.resolvePackageUri(script);
+        }
+      }
+
+      _spawnFunction(readyPort.sendPort, script.toString(), entryPoint, message,
                      paused, errorsAreFatal, onExit, onError,
                      packageRoot, packageConfig);
       return await _spawnCommon(readyPort);
     } catch (e, st) {
       if (readyPort != null) {
         readyPort.close();
       }
       return await new Future<Isolate>.error(e, st);
     }
   }
@@ skipping 26 matching lines @@
                                 "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.
+      // Resolve the uri against 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;
         }
       }
 
       // Ensure to resolve package: URIs being handed in as parameters.
-      packageRoot = (packageRoot == null) ? null :
-          await Isolate.resolvePackageUri(packageRoot);
-      packageConfig = (packageConfig == null) ? null :
-          await Isolate.resolvePackageUri(packageConfig);
+      if (packageRoot != null) {
+        // Avoid calling resolvePackageUri if not stricly necessary in case
+        // the API is not supported.
+        if (packageRoot.scheme == "package") {
+          packageRoot = await Isolate.resolvePackageUri(packageRoot);
+        }
+      } else if (packageConfig != null) {
+        // Avoid calling resolvePackageUri if not strictly necessary in case
+        // the API is not supported.
+        if (packageConfig.scheme == "package") {
+          packageConfig = await Isolate.resolvePackageUri(packageConfig);
+        }
+      }
 
       // The VM will invoke [_startIsolate] and not `main`.
       readyPort = new RawReceivePort();
       var packageRootString = packageRoot?.toString();
       var packageConfigString = packageConfig?.toString();
 
       _spawnUri(readyPort.sendPort, spawnedUri.toString(),
                 args, message,
                 paused, onExit, onError,
                 errorsAreFatal, checked,
                 null, /* environment */
                 packageRootString, packageConfigString);
       return await _spawnCommon(readyPort);
     } catch (e, st) {
       if (readyPort != null) {
         readyPort.close();
       }
-      return await new Future<Isolate>.error(e, st);
+      rethrow;
     }
   }
 
   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 21 matching lines @@
   static const _RESUME = 2;
   static const _PING = 3;
   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,
+  static void _spawnFunction(SendPort readyPort, String uri,
+                             Function topLevelFunction,
                              var message, bool paused, bool errorsAreFatal,
                              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,
@@ skipping 97 matching lines @@
     try {
       return Uri.parse(_getCurrentRootUriStr());
     } catch (e, s) {
       return null;
     }
   }
 
   static String _getCurrentRootUriStr()
       native "Isolate_getCurrentRootUriStr";
 }