Use the new loader mechanism to resolve URIs and load script files in gen_snapshot. This should all…

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/lockers.h"
 #include "bin/utils.h"
 
 namespace dart {
 namespace bin {
 
 // Development flag.
 static bool trace_loader = false;
 
 Loader::Loader(IsolateData* isolate_data)
     : port_(ILLEGAL_PORT),
       isolate_data_(isolate_data),
       error_(Dart_Null()),
       monitor_(NULL),
       pending_operations_(0),
       results_(NULL),
       results_length_(0),
-      results_capacity_(0) {
+      results_capacity_(0),
+      payload_(NULL),
+      payload_length_(0) {
   monitor_ = new Monitor();
   ASSERT(isolate_data_ != NULL);
   port_ = Dart_NewNativePort("Loader",
                              Loader::NativeMessageHandler,
                              false);
   isolate_data_->set_loader(this);
   AddLoader(port_, isolate_data_);
 }
 
 
 Loader::~Loader() {
   ASSERT(port_ != ILLEGAL_PORT);
   // Enter the monitor while we close the Dart port. After the Dart port is
   // closed, no more results can be queued.
   monitor_->Enter();
   Dart_CloseNativePort(port_);
   monitor_->Exit();
   RemoveLoader(port_);
   port_ = ILLEGAL_PORT;
   isolate_data_->set_loader(NULL);
   isolate_data_ = NULL;
   delete monitor_;
   monitor_ = NULL;
   for (intptr_t i = 0; i < results_length_; i++) {
     results_[i].Cleanup();
   }
   free(results_);
   results_ = NULL;
+  payload_ = NULL;
+  payload_length_ = 0;
 }
 
 
 // Copy the contents of |message| into an |IOResult|.
 void Loader::IOResult::Setup(Dart_CObject* message) {
   ASSERT(message->type == Dart_CObject_kArray);
   ASSERT(message->value.as_array.length == 4);
   Dart_CObject* tag_message = message->value.as_array.values[0];
   ASSERT(tag_message != NULL);
   Dart_CObject* uri_message = message->value.as_array.values[1];
@@ skipping 117 matching lines @@
     ASSERT(results_ != NULL);
   }
   ASSERT(results_ != NULL);
   ASSERT(results_length_ < results_capacity_);
   results_[results_length_].Setup(message);
   results_length_++;
   ml.Notify();
 }
 
 
-void Loader::BlockUntilComplete() {
+void Loader::BlockUntilComplete(ProcessResult process_result) {
   MonitorLocker ml(monitor_);
 
   while (true) {
     // If |ProcessQueueLocked| returns false, we've hit an error and should
     // stop loading.
-    if (!ProcessQueueLocked()) {
+    if (!ProcessQueueLocked(process_result)) {
       break;
     }
 
     // When |pending_operations_| hits 0, we are done loading.
     if (pending_operations_ == 0) {
       break;
     }
 
     // Wait to be notified about new I/O results.
     ml.Wait();
   }
 }
 
 
 static bool LibraryHandleError(Dart_Handle library, Dart_Handle error) {
   if (!Dart_IsNull(library) && !Dart_IsError(library)) {
     ASSERT(Dart_IsLibrary(library));
     Dart_Handle res = Dart_LibraryHandleError(library, error);
     if (Dart_IsNull(res)) {
       // Error was handled by library.
       return true;
     }
   }
   return false;
 }
 
 
-bool Loader::ProcessResultLocked(Loader::IOResult* result) {
+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
-    error_ = Dart_NewUnhandledExceptionError(error);
+    loader->error_ = Dart_NewUnhandledExceptionError(error);
     return false;
   }
 
 
   // 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();
   if (!is_snapshot) {
     source = Dart_NewStringFromUTF8(result->payload,
                                     result->payload_length);
     if (Dart_IsError(source)) {
-      error_  = DartUtils::NewError("%s is not a valid UTF-8 script",
-                                    reinterpret_cast<char*>(result->uri));
+      loader->error_ = DartUtils::NewError(
+          "%s is not a valid UTF-8 script",
+          reinterpret_cast<char*>(result->uri));
       return false;
     }
   }
   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.
-  monitor_->Exit();
+  loader->monitor_->Exit();
 
   Dart_Handle dart_result = Dart_Null();
 
   switch (tag) {
     case Dart_kImportTag:
       dart_result = Dart_LoadLibrary(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, source, 0, 0);
     }
     break;
     case Dart_kScriptTag:
       if (is_snapshot) {
         dart_result = Dart_LoadScriptFromSnapshot(payload, payload_length);
       } else {
         dart_result = Dart_LoadScript(uri, source, 0, 0);
       }
     break;
     default:
       UNREACHABLE();
   }
 
   // Re-acquire the lock before exiting the function (it was held before entry),
-  monitor_->Enter();
+  loader->monitor_->Enter();
   if (Dart_IsError(dart_result)) {
     // Remember the error if we encountered one.
-    error_ = dart_result;
+    loader->error_ = dart_result;
     return false;
   }
 
   return true;
 }
 
 
-bool Loader::ProcessQueueLocked() {
+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,
+                                               result->payload_length);
+    loader->error_ = Dart_NewUnhandledExceptionError(error);
+    return false;
+  }
+  loader->payload_length_ = result->payload_length;
+  loader->payload_ =
+      reinterpret_cast<uint8_t*>(::malloc(loader->payload_length_));
+  memmove(loader->payload_, result->payload, loader->payload_length_);
+  return true;
+}
+
+
+bool Loader::ProcessQueueLocked(ProcessResult process_result) {
   bool hit_error = false;
   for (intptr_t i = 0; i < results_length(); i++) {
     if (!hit_error) {
-      hit_error = !ProcessResultLocked(&results_[i]);
+      hit_error = !(*process_result)(this, &results_[i]);
     }
     pending_operations_--;
     ASSERT(hit_error || (pending_operations_ >= 0));
     results_[i].Cleanup();
   }
   results_length_ = 0;
   return !hit_error;
 }
 
 
@@ skipping 16 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;
 }
 
 
+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.
+  loader = new Loader(isolate_data);
+  loader->Init(isolate_data->package_root,
+               isolate_data->packages_file,
+               DartUtils::original_working_directory,
+               NULL);
+  ASSERT(loader != NULL);
+  ASSERT(isolate_data->HasLoader());
+
+  // Now send a load request to the service isolate.
+  loader->SendRequest(Dart_kScriptTag, url, Dart_Null());
+
+  // Wait for a reply to the load request.
+  loader->BlockUntilComplete(ProcessUrlLoadResultLocked);
+
+  // Copy fields from the loader before deleting it.
+  // The payload array itself which was malloced above is freed by
+  // the caller of LoadUrlContents.
+  Dart_Handle error = loader->error();
+  *payload = loader->payload_;
+  *payload_length = loader->payload_length_;
+
+  // Destroy the loader. The destructor does a bunch of leg work.
+  delete loader;
+
+  // An error occurred during loading.
+  if (!Dart_IsNull(error)) {
+    return error;
+  }
+  return Dart_Null();
+}
+
+
 Dart_Handle Loader::LibraryTagHandler(Dart_LibraryTag tag,
                                       Dart_Handle library,
                                       Dart_Handle url) {
   if (tag == Dart_kCanonicalizeUrl) {
     Dart_Handle library_url = Dart_LibraryUrl(library);
     if (Dart_IsError(library_url)) {
       return library_url;
     }
     return Dart_DefaultCanonicalizeUrl(library_url, url);
   }
@@ skipping 88 matching lines @@
   ASSERT(isolate_data->HasLoader());
 
   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();
+    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;
 
     // An error occurred during loading.
     if (!Dart_IsNull(error)) {
       if (false && is_deferred_import) {
         // This blocks handles transitive load errors caused by a deferred
@@ skipping 145 matching lines @@
   MutexLocker ml(&loader_infos_lock_);
   Loader* loader = LoaderForLocked(dest_port_id);
   if (loader == NULL) {
     return;
   }
   loader->QueueMessage(message);
 }
 
 }  // namespace bin
 }  // namespace dart