[snapshot] Move builtins generation into mksnapshot

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 31 matching lines @@
 #include "src/objects-inl.h"
 #include "src/runtime/runtime.h"
 #include "src/snapshot/code-serializer.h"
 #include "src/snapshot/deserializer.h"
 #include "src/snapshot/natives.h"
 #include "src/snapshot/partial-serializer.h"
 #include "src/snapshot/snapshot.h"
 #include "src/snapshot/startup-serializer.h"
 #include "test/cctest/cctest.h"
 #include "test/cctest/heap/heap-utils.h"
+#include "test/cctest/setup-isolate-for-tests.h"
 
 using namespace v8::internal;
 
 void DisableAlwaysOpt() {
   // Isolates prepared for serialization do not optimize. The only exception is
   // with the flag --always-opt.
   FLAG_always_opt = false;
 }
 
 
 // TestIsolate is used for testing isolate serialization.
 class TestIsolate : public Isolate {
  public:
   static v8::Isolate* NewInitialized(bool enable_serializer) {
     i::Isolate* isolate = new TestIsolate(enable_serializer);
+    isolate->setup_delegate_ = new SetupIsolateDelegateForTests();
     v8::Isolate* v8_isolate = reinterpret_cast<v8::Isolate*>(isolate);
     v8::Isolate::Scope isolate_scope(v8_isolate);
     isolate->Init(NULL);
     return v8_isolate;
   }
+  // Wraps v8::Isolate::New, but with a TestIsolate under the hood.
+  // Allows flexibility to bootstrap with or without snapshot even when
+  // the production Isolate class has one or the other behavior baked in.
+  static v8::Isolate* New(const v8::Isolate::CreateParams& params) {
+    i::Isolate* isolate = new TestIsolate(false);
+    isolate->setup_delegate_ = new SetupIsolateDelegateForTests();
+    return v8::IsolateNewImpl(isolate, params);
+  }
   explicit TestIsolate(bool enable_serializer) : Isolate(enable_serializer) {
     set_array_buffer_allocator(CcTest::array_buffer_allocator());
   }
+  void CreateSetupDelegateForTests() {
+    setup_delegate_ = new SetupIsolateDelegateForTests();
+  }
 };
 
 static Vector<const byte> WritePayload(const Vector<const byte>& payload) {
   int length = payload.length();
   byte* blob = NewArray<byte>(length);
   memcpy(blob, payload.begin(), length);
   return Vector<const byte>(const_cast<const byte*>(blob), length);
 }
 
 static Vector<const byte> Serialize(v8::Isolate* isolate) {
@@ skipping 33 matching lines @@
             tail.length());
   return Vector<const uint8_t>(const_cast<const uint8_t*>(source),
                                source_length);
 }
 
 v8::Isolate* InitializeFromBlob(Vector<const byte> blob) {
   v8::Isolate* v8_isolate = NULL;
   {
     SnapshotData snapshot_data(blob);
     Deserializer deserializer(&snapshot_data);
-    Isolate* isolate = new TestIsolate(false);
+    TestIsolate* isolate = new TestIsolate(false);
     v8_isolate = reinterpret_cast<v8::Isolate*>(isolate);
     v8::Isolate::Scope isolate_scope(v8_isolate);
+    isolate->CreateSetupDelegateForTests();
     isolate->Init(&deserializer);
   }
   return v8_isolate;
 }
 
 static v8::Isolate* Deserialize(Vector<const byte> blob) {
   v8::Isolate* isolate = InitializeFromBlob(blob);
   CHECK(isolate);
   return isolate;
 }
@@ skipping 485 matching lines @@
 TEST(CustomSnapshotDataBlob1) {
   DisableAlwaysOpt();
   const char* source1 = "function f() { return 42; }";
 
   v8::StartupData data1 = v8::V8::CreateSnapshotDataBlob(source1);
 
   v8::Isolate::CreateParams params1;
   params1.snapshot_blob = &data1;
   params1.array_buffer_allocator = CcTest::array_buffer_allocator();
 
-  v8::Isolate* isolate1 = v8::Isolate::New(params1);
+  // Test-appropriate equivalent of v8::Isolate::New.
+  v8::Isolate* isolate1 = TestIsolate::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);
     v8::Maybe<int32_t> result =
         CompileRun("f()")->Int32Value(isolate1->GetCurrentContext());
     CHECK_EQ(42, result.FromJust());
     CHECK(CompileRun("this.g")->IsUndefined());
   }
   isolate1->Dispose();
 }
 
 TEST(CustomSnapshotDataBlob2) {
   DisableAlwaysOpt();
   const char* source2 =
       "function f() { return g() * 2; }"
       "function g() { return 43; }"
       "/./.test('a')";
 
   v8::StartupData data2 = v8::V8::CreateSnapshotDataBlob(source2);
 
   v8::Isolate::CreateParams params2;
   params2.snapshot_blob = &data2;
   params2.array_buffer_allocator = CcTest::array_buffer_allocator();
-  v8::Isolate* isolate2 = v8::Isolate::New(params2);
+  // Test-appropriate equivalent of v8::Isolate::New.
+  v8::Isolate* isolate2 = TestIsolate::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);
     v8::Maybe<int32_t> result =
         CompileRun("f()")->Int32Value(isolate2->GetCurrentContext());
     CHECK_EQ(86, result.FromJust());
     result = CompileRun("g()")->Int32Value(isolate2->GetCurrentContext());
@@ skipping 22 matching lines @@
       "})();\n";
 
   const char* source2 = "o.a(42)";
 
   v8::StartupData data = v8::V8::CreateSnapshotDataBlob(source1);
 
   v8::Isolate::CreateParams params;
   params.snapshot_blob = &data;
   params.array_buffer_allocator = CcTest::array_buffer_allocator();
 
-  v8::Isolate* isolate = v8::Isolate::New(params);
+  // Test-appropriate equivalent of v8::Isolate::New.
+  v8::Isolate* isolate = TestIsolate::New(params);
   {
     v8::Isolate::Scope i_scope(isolate);
     v8::HandleScope h_scope(isolate);
 
     v8::Local<v8::ObjectTemplate> global = v8::ObjectTemplate::New(isolate);
     v8::Local<v8::ObjectTemplate> property = v8::ObjectTemplate::New(isolate);
     v8::Local<v8::FunctionTemplate> function =
         v8::FunctionTemplate::New(isolate, SerializationFunctionTemplate);
     property->Set(isolate, "bar", function);
     global->Set(isolate, "foo", property);
@@ skipping 26 matching lines @@
   }
   isolate0->Dispose();
 
   const char* source1 = "function f() { return 42; }";
 
   v8::StartupData data1 = v8::V8::CreateSnapshotDataBlob(source1);
 
   v8::Isolate::CreateParams params1;
   params1.snapshot_blob = &data1;
   params1.array_buffer_allocator = CcTest::array_buffer_allocator();
-  v8::Isolate* isolate1 = v8::Isolate::New(params1);
+  // Test-appropriate equivalent of v8::Isolate::New.
+  v8::Isolate* isolate1 = TestIsolate::New(params1);
   {
     v8::Locker locker(isolate1);
     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);
     v8::Maybe<int32_t> result = CompileRun("f()")->Int32Value(context);
     CHECK_EQ(42, result.FromJust());
   }
@@ skipping 11 matching lines @@
       "  b.push(c);"
       "  b = c;"
       "}";
 
   v8::StartupData data = v8::V8::CreateSnapshotDataBlob(source);
 
   v8::Isolate::CreateParams params;
   params.snapshot_blob = &data;
   params.array_buffer_allocator = CcTest::array_buffer_allocator();
 
-  v8::Isolate* isolate = v8::Isolate::New(params);
+  // Test-appropriate equivalent of v8::Isolate::New.
+  v8::Isolate* isolate = TestIsolate::New(params);
   {
     v8::Isolate::Scope i_scope(isolate);
     v8::HandleScope h_scope(isolate);
     v8::Local<v8::Context> context = v8::Context::New(isolate);
     delete[] data.data;  // We can dispose of the snapshot blob now.
     v8::Context::Scope c_scope(context);
     const char* test =
         "var sum = 0;"
         "while (a) {"
         "  sum += a[0];"
@@ skipping 19 matching lines @@
   const char* warmup = "Math.abs(1); Math.random = 1;";
 
   v8::StartupData cold = v8::V8::CreateSnapshotDataBlob();
   v8::StartupData warm = v8::V8::WarmUpSnapshotDataBlob(cold, warmup);
   delete[] cold.data;
 
   v8::Isolate::CreateParams params;
   params.snapshot_blob = &warm;
   params.array_buffer_allocator = CcTest::array_buffer_allocator();
 
-  v8::Isolate* isolate = v8::Isolate::New(params);
+  // Test-appropriate equivalent of v8::Isolate::New.
+  v8::Isolate* isolate = TestIsolate::New(params);
   {
     v8::Isolate::Scope i_scope(isolate);
     v8::HandleScope h_scope(isolate);
     v8::Local<v8::Context> context = v8::Context::New(isolate);
     delete[] warm.data;
     v8::Context::Scope c_scope(context);
     // Running the warmup script has effect on whether functions are
     // pre-compiled, but does not pollute the context.
     CHECK(IsCompiled("Math.abs"));
     CHECK(!IsCompiled("String.raw"));
@@ skipping 12 matching lines @@
   const char* warmup = "a = f()";
 
   v8::StartupData cold = v8::V8::CreateSnapshotDataBlob(source);
   v8::StartupData warm = v8::V8::WarmUpSnapshotDataBlob(cold, warmup);
   delete[] cold.data;
 
   v8::Isolate::CreateParams params;
   params.snapshot_blob = &warm;
   params.array_buffer_allocator = CcTest::array_buffer_allocator();
 
-  v8::Isolate* isolate = v8::Isolate::New(params);
+  // Test-appropriate equivalent of v8::Isolate::New.
+  v8::Isolate* isolate = TestIsolate::New(params);
   {
     v8::Isolate::Scope i_scope(isolate);
     v8::HandleScope h_scope(isolate);
     v8::Local<v8::Context> context = v8::Context::New(isolate);
     delete[] warm.data;
     v8::Context::Scope c_scope(context);
     // Running the warmup script has effect on whether functions are
     // pre-compiled, but does not pollute the context.
     CHECK(IsCompiled("f"));
     CHECK(IsCompiled("Math.abs"));
@@ skipping 15 matching lines @@
                       STATIC_CHAR_VECTOR("a.push(function() {return 7});"),
                       STATIC_CHAR_VECTOR("\0"), 10000);
 
   v8::StartupData data = v8::V8::CreateSnapshotDataBlob(
       reinterpret_cast<const char*>(source.start()));
 
   v8::Isolate::CreateParams params;
   params.snapshot_blob = &data;
   params.array_buffer_allocator = CcTest::array_buffer_allocator();
 
-  v8::Isolate* isolate = v8::Isolate::New(params);
+  // Test-appropriate equivalent of v8::Isolate::New.
+  v8::Isolate* isolate = TestIsolate::New(params);
   {
     v8::Isolate::Scope i_scope(isolate);
     v8::HandleScope h_scope(isolate);
     v8::Local<v8::Context> context = v8::Context::New(isolate);
     delete[] data.data;  // We can dispose of the snapshot blob now.
     v8::Context::Scope c_scope(context);
     CHECK_EQ(7, CompileRun("a[0]()")->Int32Value(context).FromJust());
   }
   isolate->Dispose();
   source.Dispose();
@@ skipping 994 matching lines @@
       v8::Local<v8::Context> context = v8::Context::New(isolate);
       CHECK_EQ(1u, creator.AddContext(context));
     }
     blob =
         creator.CreateBlob(v8::SnapshotCreator::FunctionCodeHandling::kClear);
   }
 
   v8::Isolate::CreateParams params;
   params.snapshot_blob = &blob;
   params.array_buffer_allocator = CcTest::array_buffer_allocator();
-  v8::Isolate* isolate = v8::Isolate::New(params);
+  // Test-appropriate equivalent of v8::Isolate::New.
+  v8::Isolate* isolate = TestIsolate::New(params);
   {
     v8::Isolate::Scope isolate_scope(isolate);
     {
       v8::HandleScope handle_scope(isolate);
       v8::Local<v8::Context> context = v8::Context::New(isolate);
       v8::Context::Scope context_scope(context);
       ExpectInt32("f()", 1);
     }
     {
       v8::HandleScope handle_scope(isolate);
@@ skipping 101 matching lines @@
     blob =
         creator.CreateBlob(v8::SnapshotCreator::FunctionCodeHandling::kClear);
   }
 
   // Deserialize with the original external reference.
   {
     v8::Isolate::CreateParams params;
     params.snapshot_blob = &blob;
     params.array_buffer_allocator = CcTest::array_buffer_allocator();
     params.external_references = original_external_references;
-    v8::Isolate* isolate = v8::Isolate::New(params);
+    // Test-appropriate equivalent of v8::Isolate::New.
+    v8::Isolate* isolate = TestIsolate::New(params);
     {
       v8::Isolate::Scope isolate_scope(isolate);
       v8::HandleScope handle_scope(isolate);
       v8::Local<v8::Context> context = v8::Context::New(isolate);
       v8::Context::Scope context_scope(context);
       ExpectInt32("f()", 42);
     }
     isolate->Dispose();
   }
 
   // Deserialize with the some other external reference.
   {
     v8::Isolate::CreateParams params;
     params.snapshot_blob = &blob;
     params.array_buffer_allocator = CcTest::array_buffer_allocator();
     params.external_references = replaced_external_references;
-    v8::Isolate* isolate = v8::Isolate::New(params);
+    // Test-appropriate equivalent of v8::Isolate::New.
+    v8::Isolate* isolate = TestIsolate::New(params);
     {
       v8::Isolate::Scope isolate_scope(isolate);
       v8::HandleScope handle_scope(isolate);
       v8::Local<v8::Context> context = v8::Context::New(isolate);
       v8::Context::Scope context_scope(context);
       ExpectInt32("f()", 1337);
     }
     isolate->Dispose();
   }
   delete[] blob.data;
@@ skipping 112 matching lines @@
     delete a1;
     delete b0;
     delete c0;
   }
 
   {
     v8::Isolate::CreateParams params;
     params.snapshot_blob = &blob;
     params.array_buffer_allocator = CcTest::array_buffer_allocator();
     params.external_references = original_external_references;
-    v8::Isolate* isolate = v8::Isolate::New(params);
+    // Test-appropriate equivalent of v8::Isolate::New.
+    v8::Isolate* isolate = TestIsolate::New(params);
     {
       v8::Isolate::Scope isolate_scope(isolate);
       {
         // Create a new context without a new object template.
         v8::HandleScope handle_scope(isolate);
         v8::Local<v8::Context> context =
             v8::Context::FromSnapshot(
                 isolate, 0,
                 v8::DeserializeInternalFieldsCallback(
                     DeserializeInternalFields, reinterpret_cast<void*>(2017)))
@@ skipping 156 matching lines @@
     }
     blob =
         creator.CreateBlob(v8::SnapshotCreator::FunctionCodeHandling::kClear);
   }
 
   {
     v8::Isolate::CreateParams params;
     params.snapshot_blob = &blob;
     params.array_buffer_allocator = CcTest::array_buffer_allocator();
     params.external_references = original_external_references;
-    v8::Isolate* isolate = v8::Isolate::New(params);
+    // Test-appropriate equivalent of v8::Isolate::New.
+    v8::Isolate* isolate = TestIsolate::New(params);
     {
       v8::Isolate::Scope isolate_scope(isolate);
       // We can introduce new extensions, which could override the already
       // snapshotted extension.
       v8::Extension* extension = new v8::Extension("new extension",
                                                    "function i() { return 24; }"
                                                    "function j() { return 25; }"
                                                    "if (o.p == 7) o.p++;");
       extension->set_auto_enable(true);
       v8::RegisterExtension(extension);
@@ skipping 90 matching lines @@
   }
   delete[] blob.data;
 }
 
 TEST(SerializationMemoryStats) {
   FLAG_profile_deserialization = true;
   FLAG_always_opt = false;
   v8::StartupData blob = v8::V8::CreateSnapshotDataBlob();
   delete[] blob.data;
 }