Dart: Roll runtime forward

mojo/dart/embedder/dart_controller.cc

 // Copyright 2014 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/files/file_util.h"
 #include "base/logging.h"
 #include "base/path_service.h"
 #include "base/rand_util.h"
@@ skipping 27 matching lines @@
 extern const uint8_t* isolate_snapshot_buffer;
 
 static const char* kAsyncLibURL = "dart:async";
 static const char* kInternalLibURL = "dart:_internal";
 static const char* kIsolateLibURL = "dart:isolate";
 static const char* kCoreLibURL = "dart:core";
 
 static uint8_t snapshot_magic_number[] = { 0xf5, 0xf5, 0xdc, 0xdc };
 
 static Dart_Handle PrepareBuiltinLibraries(const std::string& package_root,
-                                           const std::string& base_uri) {
+                                           const std::string& base_uri,
+                                           const std::string& script_uri) {
   // First ensure all required libraries are available.
   Dart_Handle builtin_lib = Builtin::PrepareLibrary(Builtin::kBuiltinLibrary);
   Builtin::PrepareLibrary(Builtin::kMojoInternalLibrary);
   Builtin::PrepareLibrary(Builtin::kDartMojoIoLibrary);
   Dart_Handle url = Dart_NewStringFromCString(kInternalLibURL);
   DART_CHECK_VALID(url);
   Dart_Handle internal_lib = Dart_LookupLibrary(url);
   DART_CHECK_VALID(internal_lib);
   url = Dart_NewStringFromCString(kCoreLibURL);
   DART_CHECK_VALID(url);
@@ skipping 24 matching lines @@
   Dart_Handle print = Dart_Invoke(builtin_lib,
                                   Dart_NewStringFromCString("_getPrintClosure"),
                                   0,
                                   nullptr);
   DART_CHECK_VALID(print);
   result = Dart_SetField(internal_lib,
                          Dart_NewStringFromCString("_printClosure"),
                          print);
   DART_CHECK_VALID(result);
 
-  DART_CHECK_VALID(Dart_Invoke(
-      builtin_lib, Dart_NewStringFromCString("_setupHooks"), 0, nullptr));
-  DART_CHECK_VALID(Dart_Invoke(
-      isolate_lib, Dart_NewStringFromCString("_setupHooks"), 0, nullptr));
-
   // Setup the 'scheduleImmediate' closure.
   Dart_Handle schedule_immediate_closure = Dart_Invoke(
       isolate_lib,
       Dart_NewStringFromCString("_getIsolateScheduleImmediateClosure"),
       0,
       nullptr);
   Dart_Handle schedule_args[1];
   schedule_args[0] = schedule_immediate_closure;
   result = Dart_Invoke(
       async_lib,
       Dart_NewStringFromCString("_setScheduleImmediateClosure"),
       1,
       schedule_args);
   DART_CHECK_VALID(result);
 
+  // Set the script location.
+  Dart_Handle uri = Dart_NewStringFromUTF8(
+      reinterpret_cast<const uint8_t*>(script_uri.c_str()),
+      script_uri.length());
+  DART_CHECK_VALID(uri);
+  result = Dart_SetField(builtin_lib,
+                         Dart_NewStringFromCString("_rawScript"),
+                         uri);
+  DART_CHECK_VALID(result);
+
   // Set the base URI.
-  Dart_Handle uri = Dart_NewStringFromUTF8(
+  uri = Dart_NewStringFromUTF8(
       reinterpret_cast<const uint8_t*>(base_uri.c_str()),
       base_uri.length());
   DART_CHECK_VALID(uri);
   result = Dart_SetField(builtin_lib,
                          Dart_NewStringFromCString("_rawUriBase"),
                          uri);
   DART_CHECK_VALID(result);
 
   // Setup the uriBase with the base uri of the mojo app.
   Dart_Handle uri_base = Dart_Invoke(
       builtin_lib,
       Dart_NewStringFromCString("_getUriBaseClosure"),
       0,
       nullptr);
   DART_CHECK_VALID(uri_base);
   result = Dart_SetField(core_lib,
                          Dart_NewStringFromCString("_uriBaseClosure"),
                          uri_base);
   DART_CHECK_VALID(result);
+
+  DART_CHECK_VALID(Dart_Invoke(
+      builtin_lib, Dart_NewStringFromCString("_setupHooks"), 0, nullptr));
+  DART_CHECK_VALID(Dart_Invoke(
+      isolate_lib, Dart_NewStringFromCString("_setupHooks"), 0, nullptr));
+
   return result;
 }
 
 static const intptr_t kStartIsolateArgumentsLength = 2;
 
 static void SetupStartIsolateArguments(
     const DartControllerConfig& config,
     Dart_Handle main_closure,
     Dart_Handle* start_isolate_args) {
   // start_isolate_args:
@@ skipping 167 matching lines @@
       isolate_data->set_library_provider(
           new tonic::DartLibraryProviderNetwork(network_service));
     } else {
       isolate_data->set_library_provider(
           new tonic::DartLibraryProviderFiles(
               base::FilePath(package_root_str)));
     }
     Dart_Handle result = Dart_SetLibraryTagHandler(LibraryTagHandler);
     DART_CHECK_VALID(result);
     // Prepare builtin and its dependent libraries.
-    result = PrepareBuiltinLibraries(package_root, base_uri);
+    result = PrepareBuiltinLibraries(package_root, base_uri, script_uri);
     DART_CHECK_VALID(result);
 
     // Set the handle watcher's control handle in the spawning isolate.
     result = SetHandleWatcherControlHandle();
     DART_CHECK_VALID(result);
 
     if (!use_dart_run_loop) {
       // Verify that we are being created on a thread with a message loop.
       DCHECK(base::MessageLoop::current());
       // Set the task runner.
@@ skipping 88 matching lines @@
   Dart_Handle control_port_value =
       Dart_NewInteger(handle_watcher_producer_handle_);
   Dart_Handle result =
       Dart_SetField(handle_watcher_type, field_name, control_port_value);
   return result;
 }
 
 Dart_Isolate DartController::IsolateCreateCallback(const char* script_uri,
                                                    const char* main,
                                                    const char* package_root,
-                                                   const char** package_map,
+                                                   const char* package_config,
                                                    Dart_IsolateFlags* flags,
                                                    void* callback_data,
                                                    char** error) {
+  DCHECK(script_uri != nullptr);
   auto parent_isolate_data = MojoDartState::Cast(callback_data);
-  std::string script_uri_string;
+  std::string script_uri_string(script_uri);
   std::string package_root_string;
   std::string base_uri_string;
 
-  if (script_uri == nullptr) {
+  // If it's a file URI, strip the scheme.
+  const char* file_scheme = "file://";
+  if (StartsWithASCII(script_uri_string, file_scheme, true)) {
+    script_uri_string = script_uri_string.substr(strlen(file_scheme));
+  }
+
+  if ((parent_isolate_data != nullptr) &&
+      (parent_isolate_data->script_uri() == script_uri_string)) {
     // We are spawning a function, use the parent isolate's base URI.
-    if (callback_data == nullptr) {
-      *error = strdup("Invalid 'callback_data' - Unable to spawn new isolate");
-      return nullptr;
-    }
-    script_uri_string = parent_isolate_data->script_uri();
     base_uri_string = parent_isolate_data->base_uri();
   } else {
     // If we are spawning a URI directly, use the URI as the base URI.
-    script_uri_string = std::string(script_uri);
-    base_uri_string = script_uri_string;
+    base_uri_string = std::string(script_uri);
   }
 
   if (package_root == nullptr) {
     if (parent_isolate_data != nullptr) {
       package_root_string = parent_isolate_data->package_root();
     }
   } else {
     package_root_string = std::string(package_root);
   }
   // Inherit parameters from parent isolate (if any).
@@ skipping 273 matching lines @@
   }
   BlockForServiceIsolateLocked();
   HandleWatcher::StopAll();
   Dart_Cleanup();
   service_isolate_running_ = false;
   initialized_ = false;
 }
 
 }  // namespace apps
 }  // namespace mojo