Bring up the service isolate and use it for package resolution in gen_snapshot

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 <stdlib.h>
 #include <string.h>
 #include <stdio.h>
 
 #include "include/dart_api.h"
 
 #include "bin/builtin.h"
 #include "bin/dartutils.h"
+#include "bin/eventhandler.h"
 #include "bin/file.h"
 #include "bin/log.h"
 #include "bin/thread.h"
+#include "bin/vmservice_impl.h"
 
 #include "platform/globals.h"
 
 
 namespace dart {
 namespace bin {
 
 #define CHECK_RESULT(result)                                                   \
   if (Dart_IsError(result)) {                                                  \
     Log::PrintErr("Error: %s", Dart_GetError(result));                         \
@@ skipping 479 matching lines @@
   if (Dart_IsError(result)) {
     const char* err_msg = Dart_GetError(library);
     Log::PrintErr("Errors encountered while loading: %s\n", err_msg);
     Dart_ExitScope();
     Dart_ShutdownIsolate();
     exit(255);
   }
 }
 
 
+static Dart_Isolate CreateServiceIsolate(const char* script_uri,
+                                         const char* main,
+                                         const char* package_root,
+                                         const char** package_map,
+                                         Dart_IsolateFlags* flags,
+                                         void* data,
+                                         char** error) {
+  Dart_Isolate isolate = NULL;
+  isolate = Dart_CreateIsolate(script_uri,
+                               main,
+                               NULL,
+                               NULL,
+                               NULL,
+                               error);
+
+  if (isolate == NULL) {
+    Log::PrintErr("Error: Could not create service isolate");
+    return NULL;
+  }
+
+  Dart_EnterScope();
+  if (!Dart_IsServiceIsolate(isolate)) {
+    Log::PrintErr("Error: We only expect to create the service isolate");
+    return NULL;
+  }
+  Dart_Handle result = Dart_SetLibraryTagHandler(DartUtils::LibraryTagHandler);
+  // Setup the native resolver.
+  Builtin::LoadAndCheckLibrary(Builtin::kBuiltinLibrary);
+  Builtin::LoadAndCheckLibrary(Builtin::kIOLibrary);
+  if (Dart_IsError(result)) {
+    Log::PrintErr("Error: Could not set tag handler for service isolate");
+    return NULL;
+  }
+  CHECK_RESULT(result);
+  ASSERT(Dart_IsServiceIsolate(isolate));
+  // Load embedder specific bits and return. Will not start http server.
+  if (!VmService::Setup("127.0.0.1", -1)) {
+    *error = strdup(VmService::GetErrorMessage());
+    return NULL;
+  }
+  Dart_ExitScope();
+  Dart_ExitIsolate();
+  return isolate;
+}
+
+
 int main(int argc, char** argv) {
   const int EXTRA_VM_ARGUMENTS = 2;
   CommandLineOptions vm_options(argc + EXTRA_VM_ARGUMENTS);
 
   // Initialize the URL mapping array.
   CommandLineOptions url_mapping_array(argc);
   url_mapping = &url_mapping_array;
 
   // Parse command line arguments.
   if (ParseArguments(argc,
                      argv,
                      &vm_options,
                      &app_script_name) < 0) {
     PrintUsage();
     return 255;
   }
 
   Thread::InitOnce();
   DartUtils::SetOriginalWorkingDirectory();
+  // Start event handler.
+  EventHandler::Start();
 
   vm_options.AddArgument("--load_deferred_eagerly");
   // Workaround until issue 21620 is fixed.
   // (https://github.com/dart-lang/sdk/issues/21620)
   vm_options.AddArgument("--no-concurrent_sweep");
   Dart_SetVMFlags(vm_options.count(), vm_options.arguments());
 
   // Initialize the Dart VM.
   // Note: We don't expect isolates to be created from dart code during
   // snapshot generation.
-  char* error = Dart_Initialize(NULL, NULL,
-      NULL, NULL, NULL, NULL,
+  char* error = Dart_Initialize(
+      NULL,
+      NULL,
+      CreateServiceIsolate,
+      NULL,
+      NULL,
+      NULL,
       DartUtils::OpenFile,
       DartUtils::ReadFile,
       DartUtils::WriteFile,
       DartUtils::CloseFile,
       DartUtils::EntropySource);
   if (error != NULL) {
     Log::PrintErr("VM initialization failed: %s\n", error);
     free(error);
     return 255;
   }
@@ skipping 65 matching lines @@
     result = Dart_FinalizeLoading(false);
     CHECK_RESULT(result);
     CreateAndWriteSnapshot();
 
     Dart_EnterIsolate(UriResolverIsolateScope::isolate);
     Dart_ShutdownIsolate();
   } else {
     SetupForGenericSnapshotCreation();
     CreateAndWriteSnapshot();
   }
+  EventHandler::Stop();
   return 0;
 }
 
 }  // namespace bin
 }  // namespace dart
 
 int main(int argc, char** argv) {
   return dart::bin::main(argc, argv);
 }