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 322 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 =
@@ skipping 32 matching lines @@
   // 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,
                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() {
+  Dart_Handle scheme =
+      Dart_NewStringFromCString(DartUtils::kDartExtensionScheme);
+  Dart_Handle extension_imports = Dart_GetImportsOfScheme(scheme);
+  RETURN_ERROR(extension_imports);
+
+  intptr_t length = -1;
+  Dart_Handle result = Dart_ListLength(extension_imports, &length);
+  RETURN_ERROR(result);
+  Dart_Handle* import_handles = reinterpret_cast<Dart_Handle*>(
+      Dart_ScopeAllocate(sizeof(Dart_Handle) * length));
+  result = Dart_ListGetRange(extension_imports, 0, length, import_handles);
+  RETURN_ERROR(result);
+  for (intptr_t i = 0; i < length; i += 2) {
+    Dart_Handle importer = import_handles[i];
+    Dart_Handle importee = import_handles[i + 1];
+
+    const char* extension_uri = NULL;
+    result = Dart_StringToCString(Dart_LibraryUrl(importee), &extension_uri);
+    RETURN_ERROR(result);
+    const char* extension_path = DartUtils::RemoveScheme(extension_uri);
+
+    const char* lib_uri = NULL;
+    result = Dart_StringToCString(Dart_LibraryUrl(importer), &lib_uri);
+    RETURN_ERROR(result);
+
+    char* lib_path = NULL;
+    if (strncmp(lib_uri, "file://", 7) == 0) {
+      lib_path = DartUtils::DirName(DartUtils::RemoveScheme(lib_uri));
+    } else {
+      lib_path = strdup(lib_uri);
+    }
+
+    result = Extensions::LoadExtension(lib_path, extension_path, importer);
+    free(lib_path);
+    RETURN_ERROR(result);
+  }
+
+  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 288 matching lines @@
   MutexLocker ml(loader_infos_lock_);
   Loader* loader = LoaderForLocked(dest_port_id);
   if (loader == NULL) {
     return;
   }
   loader->QueueMessage(message);
 }
 
 }  // namespace bin
 }  // namespace dart