Move service into VM

runtime/bin/main.cc

 // Copyright (c) 2012, 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 <stdlib.h>
 #include <string.h>
 #include <stdio.h>
 
 #include "include/dart_api.h"
 #include "include/dart_debugger_api.h"
@@ skipping 506 matching lines @@
     char errbuf[256];
     snprintf(errbuf, sizeof(errbuf),
              "Expected a library when loading script: %s",
              script_uri);
     *error = strdup(errbuf);
     Dart_ExitScope();
     Dart_ShutdownIsolate();
     return NULL;
   }
 
+
   Platform::SetPackageRoot(package_root);
-  Dart_Handle io_lib_url = DartUtils::NewString("dart:io");
+  Dart_Handle io_lib_url = DartUtils::NewString(DartUtils::kIOLibURL);
   CHECK_RESULT(io_lib_url);
   Dart_Handle io_lib = Dart_LookupLibrary(io_lib_url);
   CHECK_RESULT(io_lib);
-  Dart_Handle platform_class_name = DartUtils::NewString("Platform");
-  CHECK_RESULT(platform_class_name);
-  Dart_Handle platform_type =
-      Dart_GetType(io_lib, platform_class_name, 0, NULL);
+  Dart_Handle platform_type = DartUtils::GetDartType(DartUtils::kIOLibURL,
+                                                     "Platform");
   CHECK_RESULT(platform_type);
-  Dart_Handle script_name_name = DartUtils::NewString("_nativeScript");
-  CHECK_RESULT(script_name_name);
+  Dart_Handle script_name = DartUtils::NewString("_nativeScript");
+  CHECK_RESULT(script_name);
   Dart_Handle dart_script = DartUtils::NewString(script_uri);
   CHECK_RESULT(dart_script);
   Dart_Handle set_script_name =
-      Dart_SetField(platform_type, script_name_name, dart_script);
+      Dart_SetField(platform_type, script_name, dart_script);
   CHECK_RESULT(set_script_name);
 
-  VmService::SendIsolateStartupMessage();
-
   // Make the isolate runnable so that it is ready to handle messages.
   Dart_ExitScope();
   Dart_ExitIsolate();
   bool retval = Dart_IsolateMakeRunnable(isolate);
   if (!retval) {
     *error = strdup("Invalid isolate state - Unable to make it runnable");
     Dart_EnterIsolate(isolate);
     Dart_ShutdownIsolate();
     return NULL;
   }
 
   return isolate;

[siva, 2014/01/14 18:19:00]

I think we should define CHECK_RESULT in the beginning of this function
and #undef it over here. It doesn't make sense to use the same macro in your new
function with a dummy is_compilation_error variable.

[Cutch, 2014/01/14 19:53:26]

Done.

 }
 
 
 static Dart_Isolate CreateIsolateAndSetup(const char* script_uri,
                                           const char* main,
                                           void* data, char** error) {
   bool is_compile_error = false;
   if (script_uri == NULL) {
     if (data == NULL) {
       *error = strdup("Invalid 'callback_data' - Unable to spawn new isolate");
       return NULL;
     }
     IsolateData* parent_isolate_data = reinterpret_cast<IsolateData*>(data);
     script_uri = parent_isolate_data->script_url;
     if (script_uri == NULL) {
       *error = strdup("Invalid 'callback_data' - Unable to spawn new isolate");
       return NULL;
     }
   }
   IsolateData* isolate_data = new IsolateData(script_uri);
   return CreateIsolateAndSetupHelper(script_uri,
                                      main,
                                      isolate_data,
                                      error,
                                      &is_compile_error);
 }
 
 
+static Dart_Isolate CreateServiceIsolate(void* data, char** error) {
+  const char* script_uri = DartUtils::kVMServiceLibURL;
+  // These two variables are used by the CHECK_RESULT macro.
+  bool is_compile_error_ = false;
+  bool *is_compile_error = &is_compile_error_;

[siva, 2014/01/14 18:19:00]

Instead of these dummy variables define a version of
CHECK_RESULT inside or at the beginning of this function and undef
it at the end.

[Cutch, 2014/01/14 19:53:26]

Done.

+  IsolateData* isolate_data = new IsolateData(script_uri);
+  Dart_Isolate isolate =
+      Dart_CreateIsolate(script_uri, "main", snapshot_buffer, isolate_data,
+                         error);
+  if (isolate == NULL) {
+    return NULL;
+  }
+  Dart_EnterScope();
+  if (snapshot_buffer != NULL) {
+    // Setup the native resolver as the snapshot does not carry it.
+    Builtin::SetNativeResolver(Builtin::kBuiltinLibrary);
+    Builtin::SetNativeResolver(Builtin::kIOLibrary);
+  }
+  // Set up the library tag handler for this isolate.
+  Dart_Handle result = Dart_SetLibraryTagHandler(DartUtils::LibraryTagHandler);
+  CHECK_RESULT(result);
+  result = Dart_SetEnvironmentCallback(EnvironmentCallback);
+  CHECK_RESULT(result);
+  // Prepare builtin and its dependent libraries for use to resolve URIs.
+  Dart_Handle builtin_lib =
+      Builtin::LoadAndCheckLibrary(Builtin::kBuiltinLibrary);
+  CHECK_RESULT(builtin_lib);
+  // Prepare for script loading by setting up the 'print' and 'timer'
+  // closures and setting up 'package root' for URI resolution.
+  result = DartUtils::PrepareForScriptLoading(package_root, builtin_lib);
+  CHECK_RESULT(result);
+  Platform::SetPackageRoot(package_root);
+  Dart_Handle io_lib_url = DartUtils::NewString(DartUtils::kIOLibURL);
+  CHECK_RESULT(io_lib_url);
+  Dart_Handle io_lib = Dart_LookupLibrary(io_lib_url);
+  CHECK_RESULT(io_lib);
+  Dart_Handle platform_type = DartUtils::GetDartType(DartUtils::kIOLibURL,
+                                                     "Platform");
+  CHECK_RESULT(platform_type);
+  Dart_Handle script_name = DartUtils::NewString("_nativeScript");
+  CHECK_RESULT(script_name);
+  Dart_Handle dart_script = DartUtils::NewString(script_uri);
+  CHECK_RESULT(dart_script);
+  Dart_Handle set_script_name =
+      Dart_SetField(platform_type, script_name, dart_script);
+  CHECK_RESULT(set_script_name);
+  Dart_ExitScope();
+  Dart_ExitIsolate();
+  return isolate;
+}

[siva, 2014/01/14 18:19:00]

Another point, this function above looks identical to
CreateIsolateAndSetupHelper with only script_uri being different and the isolate
being made runnable at the end. I am wondering it is possible to use the same
callback with script_uri set to DartUtils::kVMServiceLibURL

+
+
 static void PrintVersion() {
   Log::PrintErr("Dart VM version: %s\n", Dart_VersionString());
 }
 
 
 static void PrintUsage() {
   Log::PrintErr(
       "Usage: dart [<vm-flags>] <dart-script-file> [<dart-options>]\n"
       "\n"
       "Executes the Dart script passed as <dart-script-file>.\n"
@@ skipping 112 matching lines @@
   if (!Dart_IsError(error)) {
     return;
   }
   const int exit_code = Dart_IsCompilationError(error) ?
       kCompilationErrorExitCode : kErrorExitCode;
   ErrorExit(exit_code, "%s\n", Dart_GetError(error));
 }
 
 
 static void ShutdownIsolate(void* callback_data) {
-  VmService::VmServiceShutdownCallback(callback_data);
   IsolateData* isolate_data = reinterpret_cast<IsolateData*>(callback_data);
   delete isolate_data;
 }
 
 
 static Dart_Handle GenerateScriptSource() {
   Dart_Handle library_url = Dart_LibraryUrl(Dart_RootLibrary());
   if (Dart_IsError(library_url)) {
     return library_url;
   }
@@ skipping 75 matching lines @@
   }
 
   Dart_SetVMFlags(vm_options.count(), vm_options.arguments());
 
   // Initialize the Dart VM.
   if (!Dart_Initialize(CreateIsolateAndSetup, NULL, NULL, ShutdownIsolate,
                        DartUtils::OpenFile,
                        DartUtils::ReadFile,
                        DartUtils::WriteFile,
                        DartUtils::CloseFile,
-                       DartUtils::EntropySource)) {
+                       DartUtils::EntropySource,
+                       CreateServiceIsolate)) {

[siva, 2014/01/14 18:19:00]

Another option for the next round of refactoring is to pass in the vmservice
script name that the embedder needs here instead of the createservice isolate
call.

That way the VM does the regular isolate create callback, loads the internal VM
service library and then does a LoadScript of this embedder specified script
here.

[Cutch, 2014/01/14 19:53:26]

Agreed, the next round of refactoring can clean this up further as discussed in
person (hide service isolate completely).

     fprintf(stderr, "%s", "VM initialization failed\n");
     fflush(stderr);
     exit(kErrorExitCode);
   }
 
   // Start the debugger wire protocol handler if necessary.
   if (start_debugger) {
     ASSERT(debug_port >= 0);
     bool print_msg = verbose_debug_seen || (debug_port == 0);
     debug_port = DebuggerConnectionHandler::StartHandler(debug_ip, debug_port);
@@ skipping 159 matching lines @@
   exit(Process::GlobalExitCode());
 }
 
 }  // namespace bin
 }  // namespace dart
 
 int main(int argc, char** argv) {
   dart::bin::main(argc, argv);
   UNREACHABLE();
 }