gen_snapshot now generates two snapshot buffers, one for the vm isolate

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"
 #include "dart/runtime/include/dart_api.h"
 #include "dart/runtime/include/dart_native_api.h"
 #include "mojo/dart/embedder/builtin.h"
 #include "mojo/dart/embedder/dart_controller.h"
 #include "mojo/dart/embedder/isolate_data.h"
 #include "mojo/public/c/system/core.h"
 
 namespace mojo {
 namespace dart {
 
-extern const uint8_t* snapshot_buffer;
+extern const uint8_t* vm_isolate_snapshot_buffer;
+extern const uint8_t* isolate_snapshot_buffer;
 
 const char* kDartScheme = "dart:";
 const char* kAsyncLibURL = "dart:async";
 const char* kInternalLibURL = "dart:_internal";
 const char* kIsolateLibURL = "dart:isolate";
 const char* kIOLibURL = "dart:io";
 const char* kCoreLibURL = "dart:core";
 
 static bool IsDartSchemeURL(const char* url_name) {
   static const intptr_t kDartSchemeLen = strlen(kDartScheme);
@@ skipping 160 matching lines @@
                                   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, NULL));
+      builtin_lib, Dart_NewStringFromCString("_setupHooks"), 0, nullptr));
   DART_CHECK_VALID(Dart_Invoke(
-      isolate_lib, Dart_NewStringFromCString("_setupHooks"), 0, NULL));
+      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(
@@ skipping 22 matching lines @@
                      Dart_NewStringFromCString("_setPackageRoot"),
                      kNumArgs,
                      dart_args);
   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,
-      NULL);
+      nullptr);
   DART_CHECK_VALID(uri_base);
   result = Dart_SetField(core_lib,
                          Dart_NewStringFromCString("_uriBaseClosure"),
                          uri_base);
   DART_CHECK_VALID(result);
 
   return result;
 }
 
 static Dart_Isolate CreateServiceIsolateHelper(const char* script_uri,
                                                char** error) {
   // TODO(johnmccutchan): Add support the service isolate.
   // No callbacks for service isolate.
   IsolateCallbacks callbacks;
   IsolateData* isolate_data =
-      new IsolateData(NULL, false, callbacks, "", "", "");
+      new IsolateData(nullptr, false, callbacks, "", "", "");
   Dart_Isolate isolate = Dart_CreateIsolate(script_uri,
                                             "main",
-                                            snapshot_buffer,
+                                            isolate_snapshot_buffer,
                                             isolate_data,
                                             error);
   if (isolate == nullptr) {
     delete isolate_data;
     return nullptr;
   }
   return isolate;
 }
 
 static Dart_Isolate CreateIsolateHelper(void* dart_app,
                                         bool strict_compilation,
                                         IsolateCallbacks callbacks,
                                         const std::string& script,
                                         const std::string& script_uri,
                                         const std::string& package_root,
                                         char** error) {
   IsolateData* isolate_data = new IsolateData(
       dart_app,
       strict_compilation,
       callbacks,
       script,
       script_uri,
       package_root);
   Dart_Isolate isolate = Dart_CreateIsolate(
-      script_uri.c_str(), "main", snapshot_buffer, isolate_data, error);
+      script_uri.c_str(), "main", isolate_snapshot_buffer, isolate_data, error);
   if (isolate == nullptr) {
     delete isolate_data;
     return nullptr;
   }
 
   DPCHECK(!Dart_IsServiceIsolate(isolate));
   Dart_EnterScope();
 
   Dart_IsolateSetStrictCompilation(strict_compilation);
 
   // Setup the native resolvers for the builtin libraries as they are not set
   // up when the snapshot is read.
-  CHECK(snapshot_buffer != nullptr);
+  CHECK(isolate_snapshot_buffer != nullptr);
   Builtin::PrepareLibrary(Builtin::kBuiltinLibrary);
   Builtin::PrepareLibrary(Builtin::kMojoInternalLibrary);
 
   if (!callbacks.create.is_null()) {
     callbacks.create.Run(script_uri.c_str(),
                          "main",
                          package_root.c_str(),
                          isolate_data,
                          error);
   }
@@ skipping 133 matching lines @@
   // that isn't there anymore.
   args[0] = "--worker-timeout-millis=0";
 
   for (int i = 0; i < arguments_count; ++i) {
     args[i + 1] = arguments[i];
   }
 
   bool result = Dart_SetVMFlags(kNumArgs, args);
   CHECK(result);
 
-  result = Dart_Initialize(IsolateCreateCallback,
+  result = Dart_Initialize(vm_isolate_snapshot_buffer,
+                           IsolateCreateCallback,
                            nullptr,  // Isolate interrupt callback.
                            UnhandledExceptionCallback,
                            IsolateShutdownCallback,
                            // File IO callbacks.
                            nullptr, nullptr, nullptr, nullptr,
                            entropy);
   CHECK(result);
   initialized_ = true;
 }
 
@@ skipping 243 matching lines @@
 
   Dart_ExitScope();
   Dart_ShutdownIsolate();
   Dart_Cleanup();
   root_isolate_ = nullptr;
   initialized_ = false;
 }
 
 }  // namespace apps
 }  // namespace mojo