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

sky/engine/core/script/dart_controller.cc

 // Copyright 2015 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 "sky/engine/config.h"
 #include "sky/engine/core/script/dart_controller.h"
 
 #include "base/bind.h"
 #include "base/logging.h"
 #include "base/single_thread_task_runner.h"
@@ skipping 28 matching lines @@
 
 #if ENABLE(ASSERT)
 static const char* kCheckedModeArgs[] = {
   "--enable_asserts",
   "--enable_type_checks",
   "--error_on_bad_type",
   "--error_on_bad_override",
 };
 #endif
 
-extern const uint8_t* kDartSnapshotBuffer;
+extern const uint8_t* kDartVmIsolateSnapshotBuffer;
+extern const uint8_t* kDartIsolateSnapshotBuffer;
 
 DartController::DartController() {
 }
 
 DartController::~DartController() {
 }
 
 bool DartController::ImportChildLibraries(AbstractModule* module,
                                           Dart_Handle library) {
   // If the document has never seen an <import> tag, it won't have an import
@@ skipping 118 matching lines @@
 // TODO(rafaelw): Right now this only supports the creation of the handle
 // watcher isolate. Presumably, we'll want application isolates to spawn their
 // own isolates.
 static Dart_Isolate IsolateCreateCallback(const char* script_uri,
                                           const char* main,
                                           const char* package_root,
                                           void* callback_data,
                                           char** error) {
 
   if (IsServiceIsolateURL(script_uri)) {
-    return Dart_CreateIsolate(script_uri, "main", kDartSnapshotBuffer, nullptr,
-          error);
+    return Dart_CreateIsolate(script_uri, "main", kDartIsolateSnapshotBuffer,
+          nullptr, error);
   }
 
   // Create & start the handle watcher isolate
-  CHECK(kDartSnapshotBuffer);
+  CHECK(kDartIsolateSnapshotBuffer);
   DartState* dart_state = new DartState();
   Dart_Isolate isolate = Dart_CreateIsolate("sky:handle_watcher", "",
-      kDartSnapshotBuffer, dart_state, error);
+      kDartIsolateSnapshotBuffer, dart_state, error);
   CHECK(isolate) << error;
   dart_state->set_isolate(isolate);
 
   CHECK(!LogIfError(Dart_SetLibraryTagHandler(LibraryTagHandler)));
 
   {
     DartApiScope apiScope;
     Builtin::SetNativeResolver(Builtin::kBuiltinLibrary);
     Builtin::SetNativeResolver(Builtin::kMojoInternalLibrary);
   }
@@ skipping 43 matching lines @@
       0,
       nullptr)));
 
   // RunLoop until the handle watcher isolate is spun-up.
   CHECK(!LogIfError(Dart_RunLoop()));
   handle_watcher_started = true;
 }
 
 void DartController::CreateIsolateFor(Document* document) {
   DCHECK(document);
-  CHECK(kDartSnapshotBuffer);
+  CHECK(kDartIsolateSnapshotBuffer);
   char* error = nullptr;
   dom_dart_state_ = adoptPtr(new DOMDartState(document));
   Dart_Isolate isolate = Dart_CreateIsolate(
-      document->url().string().utf8().data(), "main", kDartSnapshotBuffer,
+      document->url().string().utf8().data(), "main", kDartIsolateSnapshotBuffer,
       static_cast<DartState*>(dom_dart_state_.get()), &error);
   Dart_SetMessageNotifyCallback(MessageNotifyCallback);
   CHECK(isolate) << error;
   dom_dart_state_->set_isolate(isolate);
   Dart_SetGcCallbacks(DartGCPrologue, DartGCEpilogue);
   CHECK(!LogIfError(Dart_SetLibraryTagHandler(LibraryTagHandler)));
 
   {
     DartApiScope apiScope;
 
@@ skipping 22 matching lines @@
 void DartController::InitVM() {
   int argc = 0;
   const char** argv = nullptr;
 
 #if ENABLE(ASSERT)
   argc = arraysize(kCheckedModeArgs);
   argv = kCheckedModeArgs;
 #endif
 
   CHECK(Dart_SetVMFlags(argc, argv));
-  CHECK(Dart_Initialize(IsolateCreateCallback,
+  CHECK(Dart_Initialize(nullptr,  // VM Isolate snapshot buffer.

[zra, 2015/03/31 14:37:33]

nullptr -> kDartVmIsolateSnapshotBuffer

[siva, 2015/03/31 19:52:20]

Done.

+                        IsolateCreateCallback,
                         nullptr,  // Isolate interrupt callback.
                         UnhandledExceptionCallback, IsolateShutdownCallback,
                         // File IO callbacks.
                         nullptr, nullptr, nullptr, nullptr, nullptr));
 }
 
 } // namespace blink