Attach snapshot data blob to the isolate.

test/cctest/test-serialize.cc

 // Copyright 2007-2010 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 157 matching lines @@
   }
   CopyChars(source + head.length() + repeats * body.length(), tail.start(),
             tail.length());
   return Vector<const uint8_t>(const_cast<const uint8_t*>(source),
                                source_length);
 }
 
 
 // Test that the whole heap can be serialized.
 UNINITIALIZED_TEST(Serialize) {
-  if (!Snapshot::HaveASnapshotToStartFrom()) {
+  if (!Snapshot::HaveASnapshotToStartFrom(CcTest::i_isolate())) {
     v8::Isolate::CreateParams params;
     params.enable_serializer = true;
     v8::Isolate* isolate = v8::Isolate::New(params);
     Serialize(isolate);
   }
 }
 
 
 // Test that heap serialization is non-destructive.
 UNINITIALIZED_TEST(SerializeTwice) {
-  if (!Snapshot::HaveASnapshotToStartFrom()) {
+  if (!Snapshot::HaveASnapshotToStartFrom(CcTest::i_isolate())) {
     v8::Isolate::CreateParams params;
     params.enable_serializer = true;
     v8::Isolate* isolate = v8::Isolate::New(params);
     Serialize(isolate);
     Serialize(isolate);
   }
 }
 
 
 //----------------------------------------------------------------------------
@@ skipping 34 matching lines @@
   CHECK(isolate->native_context()->IsContext());
   CHECK(isolate->heap()->string_table()->IsStringTable());
   isolate->factory()->InternalizeOneByteString(STATIC_CHAR_VECTOR("Empty"));
 }
 
 
 UNINITIALIZED_DEPENDENT_TEST(Deserialize, Serialize) {
   // The serialize-deserialize tests only work if the VM is built without
   // serialization.  That doesn't matter.  We don't need to be able to
   // serialize a snapshot in a VM that is booted from a snapshot.
-  if (!Snapshot::HaveASnapshotToStartFrom()) {
+  if (!Snapshot::HaveASnapshotToStartFrom(CcTest::i_isolate())) {
     v8::Isolate* isolate = Deserialize();
     {
       v8::HandleScope handle_scope(isolate);
       v8::Isolate::Scope isolate_scope(isolate);
 
       v8::Local<v8::Context> env = v8::Context::New(isolate);
       env->Enter();
 
       SanityCheck(isolate);
     }
     isolate->Dispose();
   }
 }
 
 
 UNINITIALIZED_DEPENDENT_TEST(DeserializeFromSecondSerialization,
                              SerializeTwice) {
-  if (!Snapshot::HaveASnapshotToStartFrom()) {
+  if (!Snapshot::HaveASnapshotToStartFrom(CcTest::i_isolate())) {
     v8::Isolate* isolate = Deserialize();
     {
       v8::Isolate::Scope isolate_scope(isolate);
       v8::HandleScope handle_scope(isolate);
 
       v8::Local<v8::Context> env = v8::Context::New(isolate);
       env->Enter();
 
       SanityCheck(isolate);
     }
     isolate->Dispose();
   }
 }
 
 
 UNINITIALIZED_DEPENDENT_TEST(DeserializeAndRunScript2, Serialize) {
-  if (!Snapshot::HaveASnapshotToStartFrom()) {
+  if (!Snapshot::HaveASnapshotToStartFrom(CcTest::i_isolate())) {
     v8::Isolate* isolate = Deserialize();
     {
       v8::Isolate::Scope isolate_scope(isolate);
       v8::HandleScope handle_scope(isolate);
 
 
       v8::Local<v8::Context> env = v8::Context::New(isolate);
       env->Enter();
 
       const char* c_source = "\"1234\".length";
       v8::Local<v8::String> source = v8::String::NewFromUtf8(isolate, c_source);
       v8::Local<v8::Script> script = v8::Script::Compile(source);
       CHECK_EQ(4, script->Run()->Int32Value());
     }
     isolate->Dispose();
   }
 }
 
 
 UNINITIALIZED_DEPENDENT_TEST(DeserializeFromSecondSerializationAndRunScript2,
                              SerializeTwice) {
-  if (!Snapshot::HaveASnapshotToStartFrom()) {
+  if (!Snapshot::HaveASnapshotToStartFrom(CcTest::i_isolate())) {
     v8::Isolate* isolate = Deserialize();
     {
       v8::Isolate::Scope isolate_scope(isolate);
       v8::HandleScope handle_scope(isolate);
 
       v8::Local<v8::Context> env = v8::Context::New(isolate);
       env->Enter();
 
       const char* c_source = "\"1234\".length";
       v8::Local<v8::String> source = v8::String::NewFromUtf8(isolate, c_source);
       v8::Local<v8::Script> script = v8::Script::Compile(source);
       CHECK_EQ(4, script->Run()->Int32Value());
     }
     isolate->Dispose();
   }
 }
 
 
 UNINITIALIZED_TEST(PartialSerialization) {
-  if (!Snapshot::HaveASnapshotToStartFrom()) {
+  if (!Snapshot::HaveASnapshotToStartFrom(CcTest::i_isolate())) {
     v8::Isolate::CreateParams params;
     params.enable_serializer = true;
     v8::Isolate* v8_isolate = v8::Isolate::New(params);
     Isolate* isolate = reinterpret_cast<Isolate*>(v8_isolate);
     v8_isolate->Enter();
     {
       Heap* heap = isolate->heap();
 
       v8::Persistent<v8::Context> env;
       {
@@ skipping 52 matching lines @@
 
       startup_name.Dispose();
     }
     v8_isolate->Exit();
     v8_isolate->Dispose();
   }
 }
 
 
 UNINITIALIZED_DEPENDENT_TEST(PartialDeserialization, PartialSerialization) {
-  if (!Snapshot::HaveASnapshotToStartFrom()) {
+  if (!Snapshot::HaveASnapshotToStartFrom(CcTest::i_isolate())) {
     int file_name_length = StrLength(FLAG_testing_serialization_file) + 10;
     Vector<char> startup_name = Vector<char>::New(file_name_length + 1);
     SNPrintF(startup_name, "%s.startup", FLAG_testing_serialization_file);
 
     v8::Isolate* v8_isolate = InitializeFromFile(startup_name.start());
     CHECK(v8_isolate);
     startup_name.Dispose();
     {
       v8::Isolate::Scope isolate_scope(v8_isolate);
 
@@ skipping 29 matching lines @@
         CHECK(root2->IsString());
         CHECK(root.is_identical_to(root2));
       }
     }
     v8_isolate->Dispose();
   }
 }
 
 
 UNINITIALIZED_TEST(ContextSerialization) {
-  if (!Snapshot::HaveASnapshotToStartFrom()) {
+  if (!Snapshot::HaveASnapshotToStartFrom(CcTest::i_isolate())) {
     v8::Isolate::CreateParams params;
     params.enable_serializer = true;
     v8::Isolate* v8_isolate = v8::Isolate::New(params);
     Isolate* isolate = reinterpret_cast<Isolate*>(v8_isolate);
     Heap* heap = isolate->heap();
     {
       v8::Isolate::Scope isolate_scope(v8_isolate);
 
       v8::Persistent<v8::Context> env;
       {
@@ skipping 46 matching lines @@
       WritePayload(startup_snapshot.RawData(), startup_name.start());
 
       startup_name.Dispose();
     }
     v8_isolate->Dispose();
   }
 }
 
 
 UNINITIALIZED_DEPENDENT_TEST(ContextDeserialization, ContextSerialization) {
-  if (!Snapshot::HaveASnapshotToStartFrom()) {
+  if (!Snapshot::HaveASnapshotToStartFrom(CcTest::i_isolate())) {
     int file_name_length = StrLength(FLAG_testing_serialization_file) + 10;
     Vector<char> startup_name = Vector<char>::New(file_name_length + 1);
     SNPrintF(startup_name, "%s.startup", FLAG_testing_serialization_file);
 
     v8::Isolate* v8_isolate = InitializeFromFile(startup_name.start());
     CHECK(v8_isolate);
     startup_name.Dispose();
     {
       v8::Isolate::Scope isolate_scope(v8_isolate);
 
@@ skipping 29 matching lines @@
         CHECK(root2->IsContext());
         CHECK(!root.is_identical_to(root2));
       }
     }
     v8_isolate->Dispose();
   }
 }
 
 
 UNINITIALIZED_TEST(CustomContextSerialization) {
-  if (!Snapshot::HaveASnapshotToStartFrom()) {
+  if (!Snapshot::HaveASnapshotToStartFrom(CcTest::i_isolate())) {
     v8::Isolate::CreateParams params;
     params.enable_serializer = true;
     v8::Isolate* v8_isolate = v8::Isolate::New(params);
     Isolate* isolate = reinterpret_cast<Isolate*>(v8_isolate);
     {
       v8::Isolate::Scope isolate_scope(v8_isolate);
 
       v8::Persistent<v8::Context> env;
       {
         HandleScope scope(isolate);
@@ skipping 67 matching lines @@
       startup_name.Dispose();
     }
     v8_isolate->Dispose();
   }
 }
 
 
 UNINITIALIZED_DEPENDENT_TEST(CustomContextDeserialization,
                              CustomContextSerialization) {
   FLAG_crankshaft = false;
-  if (!Snapshot::HaveASnapshotToStartFrom()) {
+  if (!Snapshot::HaveASnapshotToStartFrom(CcTest::i_isolate())) {
     int file_name_length = StrLength(FLAG_testing_serialization_file) + 10;
     Vector<char> startup_name = Vector<char>::New(file_name_length + 1);
     SNPrintF(startup_name, "%s.startup", FLAG_testing_serialization_file);
 
     v8::Isolate* v8_isolate = InitializeFromFile(startup_name.start());
     CHECK(v8_isolate);
     startup_name.Dispose();
     {
       v8::Isolate::Scope isolate_scope(v8_isolate);
 
@@ skipping 37 matching lines @@
         CHECK_EQ(100001, a);
         int b = CompileRun("b.length")->ToNumber(v8_isolate)->Int32Value();
         CHECK_EQ(100002, b);
       }
     }
     v8_isolate->Dispose();
   }
 }
 
 
+TEST(PerIsolateSnapshotBlobs) {
+  // Disable experimental natives that are loaded after desrialization.

[vogelheim, 2015/02/24 15:16:31]

nitpick: desrialization => deserialization

[Yang, 2015/02/25 08:19:20]

Done.

+  FLAG_harmony_shipping = false;
+  FlagList::EnforceFlagImplications();
+
+  const char* source1 = "function f() { return 42; }";
+  const char* source2 =
+      "function f() { return g() * 2; }"
+      "function g() { return 43; }";
+
+  v8::StartupData data1 = v8::V8::CreateSnapshotDataBlob(source1);
+  v8::StartupData data2 = v8::V8::CreateSnapshotDataBlob(source2);
+
+  v8::Isolate::CreateParams params1;
+  params1.snapshot_blob = &data1;
+  v8::Isolate* isolate1 = v8::Isolate::New(params1);
+  {
+    v8::Isolate::Scope i_scope(isolate1);
+    v8::HandleScope h_scope(isolate1);
+    v8::Local<v8::Context> context = v8::Context::New(isolate1);
+    delete data1.data;  // We can dispose of the snapshot blob now.
+    v8::Context::Scope c_scope(context);
+    CHECK_EQ(42, CompileRun("f()")->ToInt32(isolate1)->Int32Value());
+    CHECK(CompileRun("this.g")->IsUndefined());
+  }
+  isolate1->Dispose();
+
+  v8::Isolate::CreateParams params2;
+  params2.snapshot_blob = &data2;
+  v8::Isolate* isolate2 = v8::Isolate::New(params2);
+  {
+    v8::Isolate::Scope i_scope(isolate2);
+    v8::HandleScope h_scope(isolate2);
+    v8::Local<v8::Context> context = v8::Context::New(isolate2);
+    delete data2.data;  // We can dispose of the snapshot blob now.
+    v8::Context::Scope c_scope(context);
+    CHECK_EQ(86, CompileRun("f()")->ToInt32(isolate2)->Int32Value());
+    CHECK_EQ(43, CompileRun("g()")->ToInt32(isolate2)->Int32Value());
+  }
+  isolate2->Dispose();
+}
+
+
 TEST(TestThatAlwaysSucceeds) {
 }
 
 
 TEST(TestThatAlwaysFails) {
   bool ArtificialFailure = false;
   CHECK(ArtificialFailure);
 }
 
 
@@ skipping 699 matching lines @@
     {
       DisallowCompilation no_compile(reinterpret_cast<Isolate*>(isolate2));
       script = v8::ScriptCompiler::CompileUnbound(
           isolate2, &source, v8::ScriptCompiler::kConsumeCodeCache);
     }
     v8::Local<v8::Value> result = script->BindToCurrentContext()->Run();
     CHECK(result->ToString(isolate2)->Equals(v8_str("XY")));
   }
   isolate2->Dispose();
 }