Only reload libraries when they may have been modified.

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 48 matching lines @@
   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);
+  ASSERT(message->value.as_array.length == 5);
   Dart_CObject* tag_message = message->value.as_array.values[0];
   ASSERT(tag_message != NULL);
   Dart_CObject* uri_message = message->value.as_array.values[1];
   ASSERT(uri_message != NULL);
-  Dart_CObject* library_uri_message = message->value.as_array.values[2];
+  Dart_CObject* resolved_uri_message = message->value.as_array.values[2];
+  ASSERT(resolved_uri_message != NULL);
+  Dart_CObject* library_uri_message = message->value.as_array.values[3];
   ASSERT(library_uri_message != NULL);
-  Dart_CObject* payload_message = message->value.as_array.values[3];
+  Dart_CObject* payload_message = message->value.as_array.values[4];
   ASSERT(payload_message != NULL);
 
   // Grab the tag.
   ASSERT(tag_message->type == Dart_CObject_kInt32);
   tag = tag_message->value.as_int32;
 
   // Grab the uri id.
   ASSERT(uri_message->type == Dart_CObject_kString);
   uri = strdup(uri_message->value.as_string);
 
+  // Grab the resolved uri.
+  ASSERT(resolved_uri_message->type == Dart_CObject_kString);
+  resolved_uri = strdup(resolved_uri_message->value.as_string);
+
   // Grab the library uri if one is present.
   if (library_uri_message->type != Dart_CObject_kNull) {
     ASSERT(library_uri_message->type == Dart_CObject_kString);
     library_uri = strdup(library_uri_message->value.as_string);
   } else {
     library_uri = NULL;
   }
 
   // Grab the payload.
   if (payload_message->type == Dart_CObject_kString) {
     // Payload is an error message.
     payload_length = strlen(payload_message->value.as_string);
     payload =
         reinterpret_cast<uint8_t*>(strdup(payload_message->value.as_string));
   } else {
     // Payload is the contents of a file.
     ASSERT(payload_message->type == Dart_CObject_kTypedData);
     ASSERT(payload_message->value.as_typed_data.type == Dart_TypedData_kUint8);
     payload_length = payload_message->value.as_typed_data.length;
     payload = reinterpret_cast<uint8_t*>(malloc(payload_length));
     memmove(payload,
             payload_message->value.as_typed_data.values,
             payload_length);
   }
 }
 
 
 void Loader::IOResult::Cleanup() {
   free(uri);
+  free(resolved_uri);
   free(library_uri);
   free(payload);
 }
 
 
 // Send the Loader Initialization message to the service isolate. This
 // message is sent the first time a loader is constructed for an isolate and
 // seeds the service isolate with some initial state about this isolate.
 void Loader::Init(const char* package_root,
                   const char* packages_file,
@@ skipping 135 matching lines @@
   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 resolved_uri =
+      Dart_NewStringFromCString(reinterpret_cast<char*>(result->resolved_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);
@@ skipping 72 matching lines @@
   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();
 
   switch (tag) {
     case Dart_kImportTag:
-      dart_result = Dart_LoadLibrary(uri, source, 0, 0);
+      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, source, 0, 0);
+      dart_result = Dart_LoadSource(library, uri, resolved_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);
+        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.
@@ skipping 259 matching lines @@
                                  " on the stand-alone VM. Trying to load"
                                  " '%s'.\n", library_url_string, url_string);
     }
     // Prepend the library URI to form a unique script URI for the part.
     intptr_t len = snprintf(NULL, 0, "%s/%s", library_url_string, url_string);
     char* part_uri = reinterpret_cast<char*>(malloc(len + 1));
     snprintf(part_uri, len + 1, "%s/%s", library_url_string, url_string);
     Dart_Handle part_uri_obj = DartUtils::NewString(part_uri);
     free(part_uri);
     return Dart_LoadSource(library,
-                           part_uri_obj,
+                           part_uri_obj, Dart_Null(),
                            Builtin::PartSource(id, url_string), 0, 0);
   }
   // All cases should have been handled above.
   UNREACHABLE();
 }
 
 
 void Loader::InitOnce() {
   loader_infos_lock_ = new Mutex();
 }
@@ skipping 81 matching lines @@
   MutexLocker ml(loader_infos_lock_);
   Loader* loader = LoaderForLocked(dest_port_id);
   if (loader == NULL) {
     return;
   }
   loader->QueueMessage(message);
 }
 
 }  // namespace bin
 }  // namespace dart