Support loading dart-ext from within a package when using a package map

runtime/bin/loader.cc

 // Copyright (c) 2016, 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.
 
 
 #include "bin/loader.h"
 
 #include "bin/builtin.h"
 #include "bin/dartutils.h"
 #include "bin/extensions.h"
@@ skipping 134 matching lines @@
                       Dart_NewStringFromCString(working_directory));
   Dart_ListSetAt(request, 7,
                  (root_script_uri == NULL) ? Dart_Null() :
                       Dart_NewStringFromCString(root_script_uri));
 
   bool success = Dart_Post(loader_port, request);
   ASSERT(success);
 }
 
 
+void Loader::SendImportExtensionRequest(Dart_Handle url,
+                                        Dart_Handle library_url) {
+  // This port delivers loading messages to the service isolate.
+  Dart_Port loader_port = Builtin::LoadPort();
+  ASSERT(loader_port != ILLEGAL_PORT);
+
+  // Keep in sync with loader.dart.
+  const intptr_t _Dart_kImportExtension = 9;
+
+  Dart_Handle request = Dart_NewList(6);
+  Dart_ListSetAt(request, 0, trace_loader ? Dart_True() : Dart_False());
+  Dart_ListSetAt(request, 1, Dart_NewInteger(Dart_GetMainPortId()));
+  Dart_ListSetAt(request, 2, Dart_NewInteger(_Dart_kImportExtension));
+  Dart_ListSetAt(request, 3, Dart_NewSendPort(port_));
+
+  Dart_ListSetAt(request, 4, url);
+  Dart_ListSetAt(request, 5, library_url);
+
+  if (Dart_Post(loader_port, request)) {
+    MonitorLocker ml(monitor_);
+    pending_operations_++;
+  }
+}
+
+
 // Forward a request from the tag handler to the service isolate.
 void Loader::SendRequest(Dart_LibraryTag tag,
                          Dart_Handle url,
                          Dart_Handle library_url) {
   // This port delivers loading messages to the service isolate.
   Dart_Port loader_port = Builtin::LoadPort();
   ASSERT(loader_port != ILLEGAL_PORT);
 
   Dart_Handle request = Dart_NewList(6);
   Dart_ListSetAt(request, 0, trace_loader ? Dart_True() : Dart_False());
@@ skipping 57 matching lines @@
     Dart_Handle res = Dart_LibraryHandleError(library, error);
     if (Dart_IsNull(res)) {
       // Error was handled by library.
       return true;
     }
   }
   return false;
 }
 
 
+static bool IsWindowsHost() {
+#if defined(TARGET_OS_WINDOWS)
+  return true;
+#else  // defined(TARGET_OS_WINDOWS)
+  return false;
+#endif  // defined(TARGET_OS_WINDOWS)
+}
+
+
 bool Loader::ProcessResultLocked(Loader* loader, Loader::IOResult* result) {
   // We have to copy everything we care about out of |result| because after
   // dropping the lock below |result| may no longer valid.
   Dart_Handle uri =
       Dart_NewStringFromCString(reinterpret_cast<char*>(result->uri));
   Dart_Handle library_uri = Dart_Null();
   if (result->library_uri != NULL) {
     library_uri =
         Dart_NewStringFromCString(reinterpret_cast<char*>(result->library_uri));
   }
 
   // A negative result tag indicates a loading error occurred in the service
   // isolate. The payload is a C string of the error message.
   if (result->tag < 0) {
     Dart_Handle library = Dart_LookupLibrary(uri);
     Dart_Handle error = Dart_NewStringFromUTF8(result->payload,
                                                result->payload_length);
     // If a library with the given uri exists, give it a chance to handle
     // the error. If the load requests stems from a deferred library load,
     // an IO error is not fatal.
     if (LibraryHandleError(library, error)) {
       return true;
     }
     // Fall through
     loader->error_ = Dart_NewUnhandledExceptionError(error);
     return false;
   }
 
+  const intptr_t _Dart_kImportExtension = 9;

[siva, 2016/07/13 21:25:14]

This is repeated twice in this file whu not put it on the top (global scope) or
in a header file.

[Cutch, 2016/07/13 22:18:24]

Done.

+  if (result->tag == _Dart_kImportExtension) {
+    ASSERT(library_uri != Dart_Null());
+    Dart_Handle library = Dart_LookupLibrary(library_uri);

[siva, 2016/07/13 21:25:14]

The return library object could be an error object, should we check for that and
bail out too.

[Cutch, 2016/07/13 22:18:24]

I check for it before scheduling with the service isolate.

+    const char* lib_path_str = reinterpret_cast<const char*>(result->payload);
+    const char* extension_uri = reinterpret_cast<const char*>(result->uri);
+    const char* extension_path = DartUtils::RemoveScheme(extension_uri);
+    if (strchr(extension_path, '/') != NULL ||
+        (IsWindowsHost() && strchr(extension_path, '\\') != NULL)) {
+      loader->error_ = DartUtils::NewError(
+          "Relative paths for dart extensions are not supported: '%s'",
+          extension_path);
+      return false;
+    }
+    Extensions::LoadExtension(lib_path_str,
+                              extension_path,
+                              library);
+    return true;
+  }
 
   // Check for payload and load accordingly.
   bool is_snapshot = false;
   const uint8_t* payload = result->payload;
   intptr_t payload_length = result->payload_length;
   payload =
       DartUtils::SniffForMagicNumber(payload,
                                      &payload_length,
                                      &is_snapshot);
   Dart_Handle source = Dart_Null();
@@ skipping 78 matching lines @@
     }
     pending_operations_--;
     ASSERT(hit_error || (pending_operations_ >= 0));
     results_[i].Cleanup();
   }
   results_length_ = 0;
   return !hit_error;
 }
 
 
-static bool IsWindowsHost() {
-#if defined(TARGET_OS_WINDOWS)
-  return true;
-#else  // defined(TARGET_OS_WINDOWS)
-  return false;
-#endif  // defined(TARGET_OS_WINDOWS)
-}
-
-
 void Loader::InitForSnapshot(const char* snapshot_uri) {
   IsolateData* isolate_data =
       reinterpret_cast<IsolateData*>(Dart_CurrentIsolateData());
   ASSERT(isolate_data != NULL);
   ASSERT(!isolate_data->HasLoader());
   // Setup a loader. The constructor does a bunch of leg work.
   Loader* loader = new Loader(isolate_data);
   // Send the init message.
   loader->Init(isolate_data->package_root,
                isolate_data->packages_file,
@@ skipping 81 matching lines @@
     if (is_dart_scheme_url || is_dart_library) {
       return DartColonLibraryTagHandler(tag,
                                         library,
                                         url,
                                         library_url_string,
                                         url_string);
     }
   }
 
   if (DartUtils::IsDartExtensionSchemeURL(url_string)) {
-    // Load a native code shared library to use in a native extension
+    // Handle early error cases for dart-ext: imports.
     if (tag != Dart_kImportTag) {
       return DartUtils::NewError("Dart extensions must use import: '%s'",
                                  url_string);
     }
     Dart_Handle library_url = Dart_LibraryUrl(library);
     if (Dart_IsError(library_url)) {
       return library_url;
     }
-    Dart_Handle library_file_path = DartUtils::LibraryFilePath(library_url);
-    const char* lib_path_str = NULL;
-    Dart_StringToCString(library_file_path, &lib_path_str);
-    const char* extension_path = DartUtils::RemoveScheme(url_string);
-    if (strchr(extension_path, '/') != NULL ||
-        (IsWindowsHost() && strchr(extension_path, '\\') != NULL)) {
-      return DartUtils::NewError(
-          "Relative paths for dart extensions are not supported: '%s'",
-          extension_path);
-    }
-    return Extensions::LoadExtension(lib_path_str,
-                                     extension_path,
-                                     library);
   }
 
   IsolateData* isolate_data =
       reinterpret_cast<IsolateData*>(Dart_CurrentIsolateData());
   ASSERT(isolate_data != NULL);
 
   // Grab this isolate's loader.
   Loader* loader = NULL;
 
   // The outer invocation of the tag handler for this isolate. We make the outer
@@ skipping 16 matching lines @@
   } else {
     ASSERT(tag != Dart_kScriptTag);
     // The isolate has a loader -- this is an inner invocation that will queue
     // work with the service isolate.
     // Use the existing loader.
     loader = isolate_data->loader();
   }
   ASSERT(loader != NULL);
   ASSERT(isolate_data->HasLoader());
 
-  loader->SendRequest(tag,
-                      url,
-                      (library != Dart_Null()) ?
-                          Dart_LibraryUrl(library) : Dart_Null());
+  if (DartUtils::IsDartExtensionSchemeURL(url_string)) {
+    loader->SendImportExtensionRequest(url, Dart_LibraryUrl(library));
+  } else {
+    loader->SendRequest(tag,
+                        url,
+                        (library != Dart_Null()) ?
+                            Dart_LibraryUrl(library) : Dart_Null());
+  }
+
 
   if (blocking_call) {
     // The outer invocation of the tag handler will block here until all nested
     // invocations complete.
     loader->BlockUntilComplete(ProcessResultLocked);
 
     // Remember the error (if any).
     Dart_Handle error = loader->error();
     // Destroy the loader. The destructor does a bunch of leg work.
     delete loader;
@@ skipping 155 matching lines @@
   MutexLocker ml(loader_infos_lock_);
   Loader* loader = LoaderForLocked(dest_port_id);
   if (loader == NULL) {
     return;
   }
   loader->QueueMessage(message);
 }
 
 }  // namespace bin
 }  // namespace dart