Reload native extensions when starting from a snapshot.

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"
 #include "bin/file.h"
 #include "bin/lockers.h"
 #include "bin/utils.h"
+#include "include/dart_tools_api.h"
 
 namespace dart {
 namespace bin {
 
 // Development flag.
 static bool trace_loader = false;
 // Keep in sync with loader.dart.
 static const intptr_t _Dart_kImportExtension = 9;
 
 Loader::Loader(IsolateData* isolate_data)
@@ skipping 330 matching lines @@
   intptr_t tag = result->tag;
 
   // No touching.
   result = NULL;
 
   // We must drop the lock here because the tag handler may be recursively
   // invoked and it will attempt to acquire the lock to queue more work.
   loader->monitor_->Exit();
 
   Dart_Handle dart_result = Dart_Null();
+  bool reload_extensions = false;
 
   switch (tag) {
     case Dart_kImportTag:
       dart_result = Dart_LoadLibrary(uri, resolved_uri, source, 0, 0);
     break;
     case Dart_kSourceTag: {
       ASSERT(library_uri != Dart_Null());
       Dart_Handle library = Dart_LookupLibrary(library_uri);
       ASSERT(!Dart_IsError(library));
       dart_result = Dart_LoadSource(library, uri, resolved_uri, source, 0, 0);
     }
     break;
     case Dart_kScriptTag:
       if (payload_type == DartUtils::kSnapshotMagicNumber) {
         dart_result = Dart_LoadScriptFromSnapshot(payload, payload_length);
+        reload_extensions = true;
       } else if (payload_type == DartUtils::kKernelMagicNumber) {
         dart_result = Dart_LoadKernel(payload, payload_length);
       } else {
         dart_result = Dart_LoadScript(uri, resolved_uri, source, 0, 0);
       }
     break;
     default:
       UNREACHABLE();
   }
 
   // Re-acquire the lock before exiting the function (it was held before entry),
   loader->monitor_->Enter();
   if (Dart_IsError(dart_result)) {
     // Remember the error if we encountered one.
     loader->error_ = dart_result;
     return false;
   }
 
+  if (reload_extensions) {
+    dart_result = ReloadNativeExtensions();
+    if (Dart_IsError(dart_result)) {
+      // Remember the error if we encountered one.
+      loader->error_ = dart_result;
+      return false;
+    }
+  }
+
   return true;
 }
 
 
 bool Loader::ProcessUrlLoadResultLocked(Loader* loader,
                                         Loader::IOResult* result) {
   // 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 error = Dart_NewStringFromUTF8(result->payload,
@@ skipping 34 matching lines @@
   // Send the init message.
   loader->Init(isolate_data->package_root,
                isolate_data->packages_file,
                DartUtils::original_working_directory,
                snapshot_uri);
   // Destroy the loader. The destructor does a bunch of leg work.
   delete loader;
 }
 
 
+#define RETURN_ERROR(result) \
+  if (Dart_IsError(result)) return result;
+
+Dart_Handle Loader::ReloadNativeExtensions() {
+  // For each library
+  Dart_Handle library_ids = Dart_GetLibraryIds();
+  RETURN_ERROR(library_ids);
+  intptr_t libraries_length = -1;
+  Dart_Handle result = Dart_ListLength(library_ids, &libraries_length);
+  RETURN_ERROR(result);
+  for (intptr_t i = 0; i < libraries_length; i++) {
+    int64_t library_id = -1;
+    result = Dart_IntegerToInt64(Dart_ListGetAt(library_ids, i),
+                                 &library_id);

[siva, 2016/11/02 23:48:38]

You could use Dart_ListGetRange to extract the library objects into
an array of handles, that way the expensive Dart_ListGetAt does not
run on every iteration of the loop.

+    RETURN_ERROR(result);
+    Dart_Handle import_ids = Dart_GetLibraryImports(library_id);
+    RETURN_ERROR(import_ids);
+    intptr_t imports_length = -1;
+    result = Dart_ListLength(import_ids, &imports_length);
+    RETURN_ERROR(result);
+
+    // For each import
+    for (intptr_t j = 1; j < imports_length; j += 2) {
+      int64_t import_id = -1;
+      result = Dart_IntegerToInt64(Dart_ListGetAt(import_ids, j),
+                                   &import_id);

[siva, 2016/11/02 23:48:38]

Ditto comment about Dart_ListGetAt

+      RETURN_ERROR(result);
+      const char* extension_uri = NULL;
+      result = Dart_StringToCString(Dart_GetLibraryURL(import_id),
+                                    &extension_uri);
+      RETURN_ERROR(result);
+
+      // If import starts with dart-ext:
+      if (strncmp(extension_uri, "dart-ext:", 9) == 0) {

[siva, 2016/11/02 23:48:38]

magic numbers 9 , 7 etc. use named constants.

[Cutch, 2016/11/03 17:45:34]

Also, these schemes already exist: DartUtils::kDartExtensionScheme

and there is already a function:

bool DartUtils::IsDartExtensionSchemeURL(const char* url);

+        const char* extension_path = DartUtils::RemoveScheme(extension_uri);
+
+        Dart_Handle library = Dart_GetLibraryFromId(library_id);
+        RETURN_ERROR(library);
+        const char* lib_uri = NULL;
+        result = Dart_StringToCString(Dart_GetLibraryURL(library_id),
+                                      &lib_uri);
+        RETURN_ERROR(result);
+
+        char* lib_path = NULL;
+        if (strncmp(lib_uri, "file://", 7) == 0) {
+          lib_path = DartUtils::RemoveFilename(
+              DartUtils::RemoveScheme(lib_uri));
+        } else {
+          lib_path = strdup(lib_uri);
+        }
+
+        result = Extensions::LoadExtension(lib_path,
+                                           extension_path,
+                                           library);
+        free(lib_path);
+        RETURN_ERROR(result);
+      }
+    }
+  }

[siva, 2016/11/02 23:48:38]

This seems like an expensive loop we have to run through always
irrespective of whether an extension exists of not.

How about adding a new API method

Dart_Handle Dart_GetExtensions();
that returns a list of tuples
<library, extension URL> of the extensions that have been loaded
into a library.

[Cutch, 2016/11/03 17:45:34]

I agree with the spirit, but, extensions are technically part of the embedder
and the scheme (dart-ext: is not standardized).

[siva, 2016/11/03 17:53:01]

Agree, maybe the API could be something like
Dart_Handle Dart_GetLibrariesMatchingScheme(Dart_Handle scheme)

+
+  return Dart_True();
+}
+
+
 Dart_Handle Loader::LoadUrlContents(Dart_Handle url,
                                     uint8_t** payload,
                                     intptr_t* payload_length) {
   IsolateData* isolate_data =
       reinterpret_cast<IsolateData*>(Dart_CurrentIsolateData());
   ASSERT(isolate_data != NULL);
   ASSERT(!isolate_data->HasLoader());
   Loader* loader = NULL;
 
   // Setup the loader. The constructor does a bunch of leg work.
@@ skipping 294 matching lines @@
   MutexLocker ml(loader_infos_lock_);
   Loader* loader = LoaderForLocked(dest_port_id);
   if (loader == NULL) {
     return;
   }
   loader->QueueMessage(message);
 }
 
 }  // namespace bin
 }  // namespace dart