Fix some assertion failures on Fuchsia

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>
@@ skipping 538 matching lines @@
  private:
   Dart_Isolate snapshotted_isolate_;
 
   DISALLOW_COPY_AND_ASSIGN(UriResolverIsolateScope);
 };
 
 
 Dart_Isolate UriResolverIsolateScope::isolate = NULL;
 
 
-static char* ResolveAsFilePath(const char* uri_string) {
-  UriResolverIsolateScope scope;
-  uint8_t* scoped_file_path = NULL;
-  intptr_t scoped_file_path_length = -1;
-  Dart_Handle uri = Dart_NewStringFromCString(uri_string);
-  ASSERT(!Dart_IsError(uri));
-  Dart_Handle result = Loader::ResolveAsFilePath(uri, &scoped_file_path,
-                                                 &scoped_file_path_length);
-  if (Dart_IsError(result)) {
-    Log::Print("Error resolving dependency: %s\n", Dart_GetError(result));
-    exit(kErrorExitCode);
-  }
-  return StringUtils::StrNDup(reinterpret_cast<const char*>(scoped_file_path),
-                              scoped_file_path_length);
-}
-
-
 static void AddDependency(const char* uri_string) {
   IsolateData* isolate_data =
       reinterpret_cast<IsolateData*>(Dart_CurrentIsolateData());
   MallocGrowableArray<char*>* dependencies = isolate_data->dependencies();
   if (dependencies != NULL) {
-    dependencies->Add(ResolveAsFilePath(uri_string));
+    dependencies->Add(strdup(uri_string));
   }
 }
 
 
 static Dart_Handle LoadUrlContents(const char* uri_string) {
   bool failed = false;
   char* error_string = NULL;
   uint8_t* payload = NULL;
   intptr_t payload_length = 0;
   // Switch to the UriResolver Isolate and load the script.
@@ skipping 83 matching lines @@
 
 
 static void CreateAndWriteDependenciesFile() {
   IsolateData* isolate_data =
       reinterpret_cast<IsolateData*>(Dart_CurrentIsolateData());
   MallocGrowableArray<char*>* dependencies = isolate_data->dependencies();
   if (dependencies == NULL) {
     return;
   }
 
+  Loader::ResolveDependenciesAsFilePaths();
+
   ASSERT((dependencies_filename != NULL) || print_dependencies);
   bool success = true;
   File* file = NULL;
   if (dependencies_filename != NULL) {
     file = File::Open(dependencies_filename, File::kWriteTruncate);
     if (file == NULL) {
       Log::PrintErr("Error: Unable to open dependencies file: %s\n\n",
                     dependencies_filename);
       exit(kErrorExitCode);
     }
@@ skipping 848 matching lines @@
     exit(kErrorExitCode);
   }
 
   Dart_Handle result;
   Dart_Handle library;
   Dart_EnterScope();
 
   result = Dart_SetEnvironmentCallback(EnvironmentCallback);
   CHECK_RESULT(result);
 
-  ASSERT(vm_snapshot_data_filename != NULL);
-  ASSERT(isolate_snapshot_data_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.
@@ skipping 10 matching lines @@
     result = DartUtils::SetupPackageRoot(commandline_package_root,
                                          commandline_packages_file);
     CHECK_RESULT(result);
 
     UriResolverIsolateScope::isolate = isolate;
     Dart_ExitScope();
     Dart_ExitIsolate();
 
     // 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, NULL);
+    isolate_data = new IsolateData(app_script_name, commandline_package_root,
+                                   commandline_packages_file, NULL);
     const uint8_t* kernel = NULL;
     intptr_t kernel_length = 0;
     const bool is_kernel_file =
         TryReadKernel(app_script_name, &kernel, &kernel_length);
 
     if ((dependencies_filename != NULL) || print_dependencies) {
       isolate_data->set_dependencies(new MallocGrowableArray<char*>());
     }
 
     void* kernel_program = NULL;
@@ skipping 98 matching lines @@
   delete mapped_isolate_snapshot_data;
   return 0;
 }
 
 }  // namespace bin
 }  // namespace dart
 
 int main(int argc, char** argv) {
   return dart::bin::main(argc, argv);
 }