Dart: Adds a content handler and a test.

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/callback.h"
 #include "base/files/file_util.h"
 #include "base/logging.h"
 #include "base/path_service.h"
 #include "base/sys_info.h"
 #include "crypto/random.h"
@@ skipping 353 matching lines @@
 bool DartController::vmIsInitialized = false;
 void DartController::InitVmIfNeeded(Dart_EntropySource entropy,
                                     const char** arguments,
                                     int arguments_count) {
   // TODO(zra): If runDartScript can be called from multiple threads
   // concurrently, then vmIsInitialized will need to be protected by a lock.
   if (vmIsInitialized) {
     return;
   }
 
-  const int kNumArgs = arguments_count + 1;
+  const int kNumArgs = arguments_count + 2;
   const char* args[kNumArgs];
 
   // TODO(zra): Fix Dart VM Shutdown race.
   // There is a bug in Dart VM shutdown which causes its thread pool threads
   // to potentially fail to exit when the rest of the VM is going down. This
   // results in a segfault if they begin running again after the Dart
   // embedder has been unloaded. Setting this flag to 0 ensures that these
   // threads sleep forever instead of waking up and trying to run code
   // that isn't there anymore.
   args[0] = "--worker-timeout-millis=0";
 
+  // Stacktraces for exceptions thrown during await statements are NYI.
+  // TODO(zra): Remove this flag when fixed.
+  args[1] = "--print-stacktrace-at-throw";
+
   for (int i = 0; i < arguments_count; ++i) {
-    args[i + 1] = arguments[i];
+    args[i + 2] = arguments[i];
   }
 
   bool result = Dart_SetVMFlags(kNumArgs, args);
   CHECK(result);
 
   result = Dart_Initialize(IsolateCreateCallback,
                            nullptr,  // Isolate interrupt callback.
                            UnhandledExceptionCallback,
                            IsolateShutdownCallback,
                            // File IO callbacks.
@@ skipping 15 matching lines @@
                                              config.package_root,
                                              config.error);
   if (isolate == nullptr) {
     return false;
   }
 
   Dart_EnterIsolate(isolate);
   Dart_Handle result;
   Dart_EnterScope();
 
-  Dart_Handle root_lib = Dart_RootLibrary();
-  DART_CHECK_VALID(root_lib);
-
-  Dart_Handle builtin_lib =
-      Builtin::LoadAndCheckLibrary(Builtin::kBuiltinLibrary);
-  DART_CHECK_VALID(builtin_lib);
+  // Start the MojoHandleWatcher.
   Dart_Handle mojo_core_lib =
       Builtin::LoadAndCheckLibrary(Builtin::kMojoCoreLibrary);
   DART_CHECK_VALID(mojo_core_lib);
-
-  // Start the MojoHandleWatcher.
   Dart_Handle handle_watcher_type = Dart_GetType(
       mojo_core_lib,
       Dart_NewStringFromCString("MojoHandleWatcher"),
       0,
       nullptr);
   DART_CHECK_VALID(handle_watcher_type);
   result = Dart_Invoke(
       handle_watcher_type,
       Dart_NewStringFromCString("Start"),
       0,
       nullptr);
   DART_CHECK_VALID(result);
 
   // RunLoop until the handle watcher isolate is spun-up.
   result = Dart_RunLoop();
   DART_CHECK_VALID(result);
 
+  // Load the root library into the builtin library so that main can be found.
+  Dart_Handle builtin_lib =
+      Builtin::LoadAndCheckLibrary(Builtin::kBuiltinLibrary);
+  DART_CHECK_VALID(builtin_lib);
+  Dart_Handle root_lib = Dart_RootLibrary();
+  DART_CHECK_VALID(root_lib);
   result = Dart_LibraryImportLibrary(builtin_lib, root_lib, Dart_Null());
   DART_CHECK_VALID(result);
 
   if (config.compile_all) {
     result = Dart_CompileAll();
     DART_CHECK_VALID(result);
   }
 
   Dart_Handle main_closure = Dart_Invoke(
       builtin_lib,
       Dart_NewStringFromCString("_getMainClosure"),
       0,
       nullptr);
   DART_CHECK_VALID(main_closure);
 
   // Call _startIsolate in the isolate library to enable dispatching the
   // initial startup message.
   const intptr_t kNumIsolateArgs = 2;
   Dart_Handle isolate_args[kNumIsolateArgs];
   isolate_args[0] = main_closure;     // entryPoint
-  isolate_args[1] = Dart_NewList(1);  // args
+  isolate_args[1] = Dart_NewList(2);  // args
   DART_CHECK_VALID(isolate_args[1]);
+
+  Dart_Handle script_uri = Dart_NewStringFromUTF8(
+      reinterpret_cast<const uint8_t*>(config.script_uri.data()),
+      config.script_uri.length());
   Dart_ListSetAt(isolate_args[1], 0, Dart_NewInteger(config.handle));
+  Dart_ListSetAt(isolate_args[1], 1, script_uri);
 
   Dart_Handle isolate_lib =
       Dart_LookupLibrary(Dart_NewStringFromCString(kIsolateLibURL));
   DART_CHECK_VALID(isolate_lib);
 
   result = Dart_Invoke(isolate_lib,
                        Dart_NewStringFromCString("_startMainIsolate"),
                        kNumIsolateArgs,
                        isolate_args);
   DART_CHECK_VALID(result);
@@ skipping 13 matching lines @@
   DART_CHECK_VALID(result);
 
   Dart_ExitScope();
   Dart_ShutdownIsolate();
   Dart_Cleanup();
   return true;
 }
 
 }  // namespace apps
 }  // namespace mojo