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

runtime/bin/gen_snapshot.cc

 // Copyright (c) 2013, 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.
 
 // Generate a snapshot file after loading all the scripts specified on the
 // command line.
 
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 
 #include <cstdarg>
 
 #include "bin/builtin.h"
 #include "bin/dartutils.h"
 #include "bin/eventhandler.h"
 #include "bin/file.h"
+#include "bin/loader.h"
 #include "bin/log.h"
 #include "bin/thread.h"
 #include "bin/utils.h"
 #include "bin/vmservice_impl.h"
 
 #include "include/dart_api.h"
 
 #include "platform/hashmap.h"
 #include "platform/globals.h"
 
@@ skipping 46 matching lines @@
 // (This pointer points into an argv buffer and does not need to be
 // free'd.)
 static const char* commandline_packages_file = NULL;
 
 
 // Global state which contains a pointer to the script name for which
 // a snapshot needs to be created (NULL would result in the creation
 // of a generic snapshot that contains only the corelibs).
 static char* app_script_name = NULL;
 
-
-// Global state that captures the URL mappings specified on the command line.
-static CommandLineOptions* url_mapping = NULL;
-
 // Global state that captures the entry point manifest files specified on the
 // command line.
 static CommandLineOptions* entry_points_files = NULL;
 
 static bool IsValidFlag(const char* name,
                         const char* prefix,
                         intptr_t prefix_length) {
   intptr_t name_length = strlen(name);
   return ((name_length > prefix_length) &&
           (strncmp(name, prefix, prefix_length) == 0));
@@ skipping 177 matching lines @@
   return false;
 }
 
 
 static bool ProcessURLmappingOption(const char* option) {
   const char* mapping = ProcessOption(option, "--url_mapping=");
   if (mapping == NULL) {
     mapping = ProcessOption(option, "--url-mapping=");
   }
   if (mapping != NULL) {
-    url_mapping->AddArgument(mapping);
+    DartUtils::url_mapping->AddArgument(mapping);
     return true;
   }
   return false;
 }
 
 
 static bool IsSnapshottingForPrecompilation() {
   return (assembly_filename != NULL) || (instructions_blob_filename != NULL);
 }
 
@@ skipping 115 matching lines @@
   }
 
   static Dart_Isolate isolate;
 
  private:
   Dart_Isolate snapshotted_isolate_;
 
   DISALLOW_COPY_AND_ASSIGN(UriResolverIsolateScope);
 };
 
+
 Dart_Isolate UriResolverIsolateScope::isolate = NULL;
 
 
-static Dart_Handle ResolveUriInWorkingDirectory(const char* script_uri) {
+static Dart_Handle LoadUrlContents(const char* uri_string) {
   bool failed = false;
   char* result_string = NULL;
-
+  uint8_t* payload = NULL;
+  intptr_t payload_length = 0;
+  // Switch to the UriResolver Isolate and load the script.
   {
     UriResolverIsolateScope scope;
 
-    // Run DartUtils::ResolveUriInWorkingDirectory in context of uri resolver
-    // isolate.
-    Dart_Handle result = DartUtils::ResolveUriInWorkingDirectory(
-        DartUtils::NewString(script_uri));
+    Dart_Handle resolved_uri = Dart_NewStringFromCString(uri_string);
+    Dart_Handle result =  Loader::LoadUrlContents(resolved_uri,
+                                                  &payload,
+                                                  &payload_length);
     if (Dart_IsError(result)) {
       failed = true;
       result_string = strdup(Dart_GetError(result));
-    } else {
-      result_string = strdup(DartUtils::GetStringValue(result));
     }
   }
-
-  Dart_Handle result = failed ? Dart_NewApiError(result_string) :
-                                DartUtils::NewString(result_string);
-  free(result_string);
+  // Switch back to the isolate from which we generate the snapshot and
+  // create the source string for the specified uri.
+  Dart_Handle result;
+  if (!failed) {
+    result = Dart_NewStringFromUTF8(payload, payload_length);
+    free(payload);
+  } else {
+    result = DartUtils::NewString(result_string);
+    free(result_string);
+  }
   return result;
 }
 
 
-static Dart_Handle FilePathFromUri(const char* script_uri) {
-  bool failed = false;
-  char* result_string = NULL;
-
-  {
-    UriResolverIsolateScope scope;
-
-    // Run DartUtils::FilePathFromUri in context of uri resolver isolate.
-    Dart_Handle result = DartUtils::FilePathFromUri(
-        DartUtils::NewString(script_uri));
-    if (Dart_IsError(result)) {
-      failed = true;
-      result_string = strdup(Dart_GetError(result));
-    } else {
-      result_string = strdup(DartUtils::GetStringValue(result));
-    }
+static Dart_Handle LoadSnapshotCreationScript(const char* script_name) {
+  // First resolve the specified script uri with respect to the original
+  // working directory.
+  Dart_Handle resolved_uri = Dart_DefaultCanonicalizeUrl(
+      Dart_NewStringFromCString(DartUtils::original_working_directory),
+      Dart_NewStringFromCString(script_name));
+  if (Dart_IsError(resolved_uri)) {
+    return resolved_uri;
   }
-
-  Dart_Handle result = failed ? Dart_NewApiError(result_string) :
-                                DartUtils::NewString(result_string);
-  free(result_string);
-  return result;
+  // Now load the contents of the specified uri.
+  const char* resolved_uri_string = DartUtils::GetStringValue(resolved_uri);
+  Dart_Handle source =  LoadUrlContents(resolved_uri_string);
+  if (Dart_IsError(source)) {
+    return source;
+  }
+  if (IsSnapshottingForPrecompilation()) {
+    return Dart_LoadScript(resolved_uri, source, 0, 0);
+  } else {
+    return Dart_LoadLibrary(resolved_uri, source, 0, 0);
+  }
 }
 
 
-static Dart_Handle ResolveUri(const char* library_uri, const char* uri) {
-  bool failed = false;
-  char* result_string = NULL;
-
-  {
-    UriResolverIsolateScope scope;
-
-    // Run DartUtils::ResolveUri in context of uri resolver isolate.
-    Dart_Handle result = DartUtils::ResolveUri(
-      DartUtils::NewString(library_uri), DartUtils::NewString(uri));
-    if (Dart_IsError(result)) {
-      failed = true;
-      result_string = strdup(Dart_GetError(result));
-    } else {
-      result_string = strdup(DartUtils::GetStringValue(result));
-    }
-  }
-
-  Dart_Handle result = failed ? Dart_NewApiError(result_string) :
-                                DartUtils::NewString(result_string);
-  free(result_string);
-  return result;
-}
-
-
-
 static Builtin::BuiltinLibraryId BuiltinId(const char* url) {
   if (DartUtils::IsDartBuiltinLibURL(url)) {
     return Builtin::kBuiltinLibrary;
   }
   if (DartUtils::IsDartIOLibURL(url)) {
     return Builtin::kIOLibrary;
   }
   return Builtin::kInvalidLibrary;
 }
 
 
 static Dart_Handle CreateSnapshotLibraryTagHandler(Dart_LibraryTag tag,
                                                    Dart_Handle library,
                                                    Dart_Handle url) {
   if (!Dart_IsLibrary(library)) {
     return Dart_NewApiError("not a library");
   }
   Dart_Handle library_url = Dart_LibraryUrl(library);
   if (Dart_IsError(library_url)) {
     return Dart_NewApiError("accessing library url failed");
   }
   const char* library_url_string = DartUtils::GetStringValue(library_url);
   const char* mapped_library_url_string = DartUtils::MapLibraryUrl(
-      url_mapping, library_url_string);
+      library_url_string);
   if (mapped_library_url_string != NULL) {
-    library_url = ResolveUriInWorkingDirectory(mapped_library_url_string);
+    library_url = Dart_DefaultCanonicalizeUrl(
+        Dart_NewStringFromCString(DartUtils::original_working_directory),
+        Dart_NewStringFromCString(mapped_library_url_string));
     library_url_string = DartUtils::GetStringValue(library_url);
   }
 
   if (!Dart_IsString(url)) {
     return Dart_NewApiError("url is not a string");
   }
   const char* url_string = DartUtils::GetStringValue(url);
-  const char* mapped_url_string = DartUtils::MapLibraryUrl(url_mapping,
-                                                           url_string);
+  const char* mapped_url_string = DartUtils::MapLibraryUrl(url_string);
 
   Builtin::BuiltinLibraryId libraryBuiltinId = BuiltinId(library_url_string);
   if (tag == Dart_kCanonicalizeUrl) {
     if (mapped_url_string) {
       return url;
     }
     // Parts of internal libraries are handled internally.
     if (libraryBuiltinId != Builtin::kInvalidLibrary) {
       return url;
     }
-    return ResolveUri(library_url_string, url_string);
+    return Dart_DefaultCanonicalizeUrl(library_url, url);
   }
 
   Builtin::BuiltinLibraryId builtinId = BuiltinId(url_string);
   if ((builtinId != Builtin::kInvalidLibrary) && (mapped_url_string == NULL)) {
     // Special case for importing a builtin library that isn't remapped.
     if (tag == Dart_kImportTag) {
       return Builtin::LoadLibrary(url, builtinId);
     }
     ASSERT(tag == Dart_kSourceTag);
     return DartUtils::NewError("Unable to part '%s' ", url_string);
   }
 
   if (libraryBuiltinId != Builtin::kInvalidLibrary) {
     // Special case for parting sources of a builtin library.
     if (tag == Dart_kSourceTag) {
       return Dart_LoadSource(library, url,
           Builtin::PartSource(libraryBuiltinId, url_string), 0, 0);
     }
     ASSERT(tag == Dart_kImportTag);
     return DartUtils::NewError("Unable to import '%s' ", url_string);
   }
 
   Dart_Handle resolved_url = url;
   if (mapped_url_string != NULL) {
     // Mapped urls are relative to working directory.
-    resolved_url = ResolveUriInWorkingDirectory(mapped_url_string);
+    resolved_url = Dart_DefaultCanonicalizeUrl(
+        Dart_NewStringFromCString(DartUtils::original_working_directory),
+        Dart_NewStringFromCString(mapped_url_string));
     if (Dart_IsError(resolved_url)) {
       return resolved_url;
     }
   }
-
-  // Get the file path out of the url.
-  Dart_Handle file_path = FilePathFromUri(
-      DartUtils::GetStringValue(resolved_url));
-  if (Dart_IsError(file_path)) {
-    return file_path;
-  }
-  const char* raw_path = DartUtils::GetStringValue(file_path);
-  Dart_Handle source = DartUtils::ReadStringFromFile(raw_path);
+  const char* resolved_uri_string = DartUtils::GetStringValue(resolved_url);
+  Dart_Handle source =  LoadUrlContents(resolved_uri_string);
   if (Dart_IsError(source)) {
     return source;
   }
   if (tag == Dart_kImportTag) {
     return Dart_LoadLibrary(url, source, 0, 0);
   } else {
     ASSERT(tag == Dart_kSourceTag);
     return Dart_LoadSource(library, url, source, 0, 0);
   }
 }
 
 
-static Dart_Handle LoadSnapshotCreationScript(const char* script_name) {
-  Dart_Handle resolved_script_uri = ResolveUriInWorkingDirectory(script_name);
-  if (Dart_IsError(resolved_script_uri)) {
-    return resolved_script_uri;
-  }
-  Dart_Handle script_path = FilePathFromUri(
-      DartUtils::GetStringValue(resolved_script_uri));
-  if (Dart_IsError(script_path)) {
-    return script_path;
-  }
-  Dart_Handle source = DartUtils::ReadStringFromFile(
-      DartUtils::GetStringValue(script_path));
-  if (Dart_IsError(source)) {
-    return source;
-  }
-  if (IsSnapshottingForPrecompilation()) {
-    return Dart_LoadScript(resolved_script_uri, source, 0, 0);
-  } else {
-    return Dart_LoadLibrary(resolved_script_uri, source, 0, 0);
-  }
-}
-
-
 static Dart_Handle LoadGenericSnapshotCreationScript(
     Builtin::BuiltinLibraryId id) {
   Dart_Handle source = Builtin::Source(id);
   if (Dart_IsError(source)) {
     return source;  // source contains the error string.
   }
   Dart_Handle lib;
   // Load the builtin library to make it available in the snapshot
   // for importing.
   lib = Builtin::LoadAndCheckLibrary(id);
@@ skipping 493 matching lines @@
   }
   Dart_ExitScope();
 
   // Shutdown the isolate.
   Dart_ShutdownIsolate();
 }
 
 
 static void SetupForUriResolution() {
   // Set up the library tag handler for this isolate.
-  Dart_Handle result = Dart_SetLibraryTagHandler(DartUtils::LibraryTagHandler);
+  Dart_Handle result = Dart_SetLibraryTagHandler(Loader::LibraryTagHandler);
   if (Dart_IsError(result)) {
     Log::PrintErr("%s", Dart_GetError(result));
     Dart_ExitScope();
     Dart_ShutdownIsolate();
     exit(255);
   }
   // This is a generic dart snapshot which needs builtin library setup.
   Dart_Handle library =
       LoadGenericSnapshotCreationScript(Builtin::kBuiltinLibrary);
   VerifyLoaded(library);
@@ skipping 37 matching lines @@
   if (isolate == NULL) {
     Log::PrintErr("Error: Could not create service isolate");
     return NULL;
   }
 
   Dart_EnterScope();
   if (!Dart_IsServiceIsolate(isolate)) {
     Log::PrintErr("Error: We only expect to create the service isolate");
     return NULL;
   }
-  Dart_Handle result = Dart_SetLibraryTagHandler(DartUtils::LibraryTagHandler);
+  Dart_Handle result = Dart_SetLibraryTagHandler(Loader::LibraryTagHandler);
   // Setup the native resolver.
   Builtin::LoadAndCheckLibrary(Builtin::kBuiltinLibrary);
   Builtin::LoadAndCheckLibrary(Builtin::kIOLibrary);
   if (Dart_IsError(result)) {
     Log::PrintErr("Error: Could not set tag handler for service isolate");
     return NULL;
   }
   CHECK_RESULT(result);
   ASSERT(Dart_IsServiceIsolate(isolate));
   // Load embedder specific bits and return. Will not start http server.
   if (!VmService::Setup("127.0.0.1", -1, false /* running_precompiled */)) {
     *error = strdup(VmService::GetErrorMessage());
     return NULL;
   }
   Dart_ExitScope();
   Dart_ExitIsolate();
   return isolate;
 }
 
 
 int main(int argc, char** argv) {
   const int EXTRA_VM_ARGUMENTS = 2;
   CommandLineOptions vm_options(argc + EXTRA_VM_ARGUMENTS);
 
   // Initialize the URL mapping array.
-  CommandLineOptions url_mapping_array(argc);
-  url_mapping = &url_mapping_array;
+  CommandLineOptions cmdline_url_mapping(argc);
+  DartUtils::url_mapping = &cmdline_url_mapping;
 
   // Initialize the entrypoints array.
   CommandLineOptions entry_points_files_array(argc);
   entry_points_files = &entry_points_files_array;
 
   // Parse command line arguments.
   if (ParseArguments(argc,
                      argv,
                      &vm_options,
                      &app_script_name) < 0) {
@@ skipping 41 matching lines @@
       DartUtils::WriteFile,
       DartUtils::CloseFile,
       DartUtils::EntropySource,
       NULL);
   if (error != NULL) {
     Log::PrintErr("VM initialization failed: %s\n", error);
     free(error);
     return 255;
   }
 
-  IsolateData* isolate_data = new IsolateData(NULL, NULL, NULL);
+  IsolateData* isolate_data = new IsolateData(NULL,
+                                              commandline_package_root,
+                                              commandline_packages_file);
   Dart_Isolate isolate = Dart_CreateIsolate(
       NULL, NULL, NULL, NULL, isolate_data, &error);
   if (isolate == NULL) {
     Log::PrintErr("Error: %s", error);
     free(error);
     exit(255);
   }
 
   Dart_Handle result;
   Dart_Handle library;
   Dart_EnterScope();
 
   result = Dart_SetEnvironmentCallback(EnvironmentCallback);
   CHECK_RESULT(result);
 
   ASSERT(vm_isolate_snapshot_filename != NULL);
   ASSERT(isolate_snapshot_filename != NULL);
   // Load up the script before a snapshot is created.
   if (app_script_name != NULL) {
     // This is the case of a custom embedder (e.g: dartium) trying to
     // create a full snapshot. The current isolate is set up so that we can
     // invoke the dart uri resolution code like _resolveURI. App script is
     // loaded into a separate isolate.
-
     SetupForUriResolution();
 
     // Prepare builtin and its dependent libraries for use to resolve URIs.
     // Set up various closures, e.g: printing, timers etc.
     // Set up 'package root' for URI resolution.
     result = DartUtils::PrepareForScriptLoading(false, false);
     CHECK_RESULT(result);
 
     // Set up the load port provided by the service isolate so that we can
     // load scripts.
     result = DartUtils::SetupServiceLoadPort();
     CHECK_RESULT(result);
 
     // Setup package root if specified.
     result = DartUtils::SetupPackageRoot(commandline_package_root,
                                          commandline_packages_file);
     CHECK_RESULT(result);
 
+    UriResolverIsolateScope::isolate = isolate;
     Dart_ExitScope();
     Dart_ExitIsolate();
 
-    UriResolverIsolateScope::isolate = isolate;
-
     // Now we create an isolate into which we load all the code that needs to
     // be in the snapshot.
     isolate_data = new IsolateData(NULL, NULL, NULL);
     if (Dart_CreateIsolate(
             NULL, NULL, NULL, NULL, isolate_data, &error) == NULL) {
       fprintf(stderr, "%s", error);
       free(error);
       exit(255);
     }
     Dart_EnterScope();
@@ skipping 42 matching lines @@
   EventHandler::Stop();
   return 0;
 }
 
 }  // namespace bin
 }  // namespace dart
 
 int main(int argc, char** argv) {
   return dart::bin::main(argc, argv);
 }