Add option to gen_snapshot for creating a Makefile describing a snapshot's dependencies.

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;
+static const intptr_t _Dart_kResolveAsFilePath = 10;
 
 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),
@@ skipping 143 matching lines @@
   Dart_ListSetAt(request, 5, library_url);
 
   if (Dart_Post(loader_port, request)) {
     MonitorLocker ml(monitor_);
     pending_operations_++;
   }
 }
 
 
 // Forward a request from the tag handler to the service isolate.
-void Loader::SendRequest(Dart_LibraryTag tag,
+void Loader::SendRequest(intptr_t tag,
                          Dart_Handle url,
                          Dart_Handle library_url) {
   // This port delivers loading messages to the service isolate.
   Dart_Port loader_port = Builtin::LoadPort();
   ASSERT(loader_port != ILLEGAL_PORT);
 
   Dart_Handle request = Dart_NewList(6);
   Dart_ListSetAt(request, 0, trace_loader ? Dart_True() : Dart_False());
   Dart_ListSetAt(request, 1, Dart_NewInteger(Dart_GetMainPortId()));
   Dart_ListSetAt(request, 2, Dart_NewInteger(tag));
@@ skipping 220 matching lines @@
       // Remember the error if we encountered one.
       loader->error_ = dart_result;
       return false;
     }
   }
 
   return true;
 }
 
 
-bool Loader::ProcessUrlLoadResultLocked(Loader* loader,
+bool Loader::ProcessPayloadResultLocked(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;
@@ skipping 72 matching lines @@
 
     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) {
+Dart_Handle Loader::SendAndProcessReply(intptr_t tag,
+                                        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());
+  loader->SendRequest(tag, url, Dart_Null());
 
   // Wait for a reply to the load request.
-  loader->BlockUntilComplete(ProcessUrlLoadResultLocked);
+  loader->BlockUntilComplete(ProcessPayloadResultLocked);
 
   // 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::LoadUrlContents(Dart_Handle url,
+                                    uint8_t** payload,
+                                    intptr_t* payload_length) {
+  return SendAndProcessReply(Dart_kScriptTag, url, payload, payload_length);
+}
+
+
+Dart_Handle Loader::ResolveAsFilePath(Dart_Handle url,
+                                      uint8_t** payload,
+                                      intptr_t* payload_length) {
+  return SendAndProcessReply(_Dart_kResolveAsFilePath, url, payload,
+                             payload_length);
+}
+
+
 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 251 matching lines @@
   MutexLocker ml(loader_infos_lock_);
   Loader* loader = LoaderForLocked(dest_port_id);
   if (loader == NULL) {
     return;
   }
   loader->QueueMessage(message);
 }
 
 }  // namespace bin
 }  // namespace dart