[serializer] pass internal fields deserializer callback as argument.

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 303 matching lines @@
 
     Isolate* isolate = reinterpret_cast<Isolate*>(v8_isolate);
     HandleScope handle_scope(isolate);
     Handle<Object> root;
     // Intentionally empty handle. The deserializer should not come across
     // any references to the global proxy in this test.
     Handle<JSGlobalProxy> global_proxy = Handle<JSGlobalProxy>::null();
     {
       SnapshotData snapshot_data(partial_blob);
       Deserializer deserializer(&snapshot_data);
-      root = deserializer.DeserializePartial(isolate, global_proxy)
+      root = deserializer.DeserializePartial(isolate, global_proxy, nullptr)
                  .ToHandleChecked();
       CHECK(root->IsString());
     }
 
     Handle<Object> root2;
     {
       SnapshotData snapshot_data(partial_blob);
       Deserializer deserializer(&snapshot_data);
-      root2 = deserializer.DeserializePartial(isolate, global_proxy)
+      root2 = deserializer.DeserializePartial(isolate, global_proxy, nullptr)
                   .ToHandleChecked();
       CHECK(root2->IsString());
       CHECK(root.is_identical_to(root2));
     }
     partial_blob.Dispose();
   }
   v8_isolate->Dispose();
 }
 
 static void PartiallySerializeContext(Vector<const byte>* startup_blob_out,
@@ skipping 68 matching lines @@
 
     Isolate* isolate = reinterpret_cast<Isolate*>(v8_isolate);
     HandleScope handle_scope(isolate);
     Handle<Object> root;
     Handle<JSGlobalProxy> global_proxy =
         isolate->factory()->NewUninitializedJSGlobalProxy(
             JSGlobalProxy::SizeWithInternalFields(0));
     {
       SnapshotData snapshot_data(partial_blob);
       Deserializer deserializer(&snapshot_data);
-      root = deserializer.DeserializePartial(isolate, global_proxy)
+      root = deserializer.DeserializePartial(isolate, global_proxy, nullptr)
                  .ToHandleChecked();
       CHECK(root->IsContext());
       CHECK(Handle<Context>::cast(root)->global_proxy() == *global_proxy);
     }
 
     Handle<Object> root2;
     {
       SnapshotData snapshot_data(partial_blob);
       Deserializer deserializer(&snapshot_data);
-      root2 = deserializer.DeserializePartial(isolate, global_proxy)
+      root2 = deserializer.DeserializePartial(isolate, global_proxy, nullptr)
                   .ToHandleChecked();
       CHECK(root2->IsContext());
       CHECK(!root.is_identical_to(root2));
     }
     partial_blob.Dispose();
   }
   v8_isolate->Dispose();
 }
 
 static void PartiallySerializeCustomContext(
@@ skipping 89 matching lines @@
 
     Isolate* isolate = reinterpret_cast<Isolate*>(v8_isolate);
     HandleScope handle_scope(isolate);
     Handle<Object> root;
     Handle<JSGlobalProxy> global_proxy =
         isolate->factory()->NewUninitializedJSGlobalProxy(
             JSGlobalProxy::SizeWithInternalFields(0));
     {
       SnapshotData snapshot_data(partial_blob);
       Deserializer deserializer(&snapshot_data);
-      root = deserializer.DeserializePartial(isolate, global_proxy)
+      root = deserializer.DeserializePartial(isolate, global_proxy, nullptr)
                  .ToHandleChecked();
       CHECK(root->IsContext());
       Handle<Context> context = Handle<Context>::cast(root);
 
       // Add context to the weak native context list
       context->set(Context::NEXT_CONTEXT_LINK,
                    isolate->heap()->native_contexts_list(),
                    UPDATE_WEAK_WRITE_BARRIER);
       isolate->heap()->set_native_contexts_list(*context);
 
@@ skipping 1643 matching lines @@
     {
       v8::HandleScope handle_scope(isolate);
       v8::ExtensionConfiguration* no_extension = nullptr;
       v8::Local<v8::ObjectTemplate> global_template =
           v8::ObjectTemplate::New(isolate);
       v8::Local<v8::FunctionTemplate> callback =
           v8::FunctionTemplate::New(isolate, SerializedCallback);
       global_template->Set(v8_str("f"), callback);
       v8::Local<v8::Context> context =
           v8::Context::New(isolate, no_extension, global_template);
+      creator.SetDefaultContext(context);
+      context = v8::Context::New(isolate, no_extension, global_template);
       v8::Local<v8::ObjectTemplate> object_template =
           v8::ObjectTemplate::New(isolate);
       object_template->SetInternalFieldCount(3);
 
       v8::Context::Scope context_scope(context);
       ExpectInt32("f()", 42);
 
       v8::Local<v8::Object> a =
           object_template->NewInstance(context).ToLocalChecked();
       v8::Local<v8::Object> b =
           object_template->NewInstance(context).ToLocalChecked();
       v8::Local<v8::Object> c =
           object_template->NewInstance(context).ToLocalChecked();
       v8::Local<v8::External> null_external =
           v8::External::New(isolate, nullptr);
       v8::Local<v8::External> field_external =
           v8::External::New(isolate, &serialized_static_field);
       a->SetInternalField(0, b);
       a->SetAlignedPointerInInternalField(1, a1);
       b->SetAlignedPointerInInternalField(0, b0);
       b->SetInternalField(1, c);
       c->SetAlignedPointerInInternalField(0, c0);
       c->SetInternalField(1, null_external);
       c->SetInternalField(2, field_external);
       CHECK(context->Global()->Set(context, v8_str("a"), a).FromJust());
 
-      creator.SetDefaultContext(context);
+      CHECK_EQ(0u, creator.AddContext(context, SerializeInternalFields));
       CHECK_EQ(0u, creator.AddTemplate(callback));
       CHECK_EQ(1u, creator.AddTemplate(global_template));
     }
-    blob = creator.CreateBlob(v8::SnapshotCreator::FunctionCodeHandling::kClear,
-                              SerializeInternalFields);
+    blob =
+        creator.CreateBlob(v8::SnapshotCreator::FunctionCodeHandling::kClear);
 
     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;
-    params.deserialize_internal_fields_callback = DeserializeInternalFields;
     v8::Isolate* isolate = v8::Isolate::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::New(isolate);
+        v8::Local<v8::Context> context =
+            v8::Context::FromSnapshot(isolate, 0, DeserializeInternalFields)
+                .ToLocalChecked();
         v8::Context::Scope context_scope(context);
         ExpectInt32("f()", 42);
 
         // Retrieve the snapshotted object template.
         v8::Local<v8::ObjectTemplate> obj_template =
             v8::ObjectTemplate::FromSnapshot(isolate, 1).ToLocalChecked();
         CHECK(!obj_template.IsEmpty());
         v8::Local<v8::Object> object =
             obj_template->NewInstance(context).ToLocalChecked();
         CHECK(context->Global()->Set(context, v8_str("o"), object).FromJust());
@@ skipping 46 matching lines @@
                  v8::Local<v8::External>::Cast(c2)->Value());
 
         // Accessing out of bound returns empty MaybeHandle.
         CHECK(v8::ObjectTemplate::FromSnapshot(isolate, 2).IsEmpty());
         CHECK(v8::FunctionTemplate::FromSnapshot(isolate, 2).IsEmpty());
         CHECK(v8::Context::FromSnapshot(isolate, 1).IsEmpty());
 
         for (auto data : deserialized_data) delete data;
         deserialized_data.clear();
       }
-
-      {
-        // Create a context with a new object template. It is merged into the
-        // deserialized global object.
-        v8::HandleScope handle_scope(isolate);
-        v8::ExtensionConfiguration* no_extension = nullptr;
-        v8::Local<v8::ObjectTemplate> global_template =
-            v8::ObjectTemplate::New(isolate);
-        global_template->Set(
-            v8_str("g"),
-            v8::FunctionTemplate::New(isolate, SerializedCallbackReplacement));
-        v8::Local<v8::Context> context =
-            v8::Context::New(isolate, no_extension, global_template);
-        v8::Context::Scope context_scope(context);
-        ExpectInt32("g()", 1337);
-        ExpectInt32("f()", 42);
-
-        for (auto data : deserialized_data) delete data;
-        deserialized_data.clear();
-      }
     }
     isolate->Dispose();
   }
   delete[] blob.data;
 }
 
 TEST(SnapshotCreatorIncludeGlobalProxy) {
   DisableAlwaysOpt();
   v8::StartupData blob;
 
@@ skipping 65 matching lines @@
       ExpectInt32("h()", 13);
       ExpectInt32("o.p", 7);
       ExpectInt32("x", 2016);
       ExpectInt32("y", 2017);
       CHECK(v8_str("hidden string")
                 ->Equals(context, context->Global()
                                       ->GetPrivate(context, hidden)
                                       .ToLocalChecked())
                 .FromJust());
 
-      CHECK_EQ(0u, creator.AddContext(context));
+      CHECK_EQ(0u, creator.AddContext(context, SerializeInternalFields));
     }
-    blob = creator.CreateBlob(v8::SnapshotCreator::FunctionCodeHandling::kClear,
-                              SerializeInternalFields);
+    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;
-    params.deserialize_internal_fields_callback = DeserializeInternalFields;
     v8::Isolate* isolate = v8::Isolate::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);
@@ skipping 13 matching lines @@
         ExpectInt32("o.p", 8);
         v8::TryCatch try_catch(isolate);
         CHECK(CompileRun("x").IsEmpty());
         CHECK(try_catch.HasCaught());
       }
       {
         // Create a new context from first additional context snapshot. This
         // will use the global object from the snapshot, including interceptor.
         v8::HandleScope handle_scope(isolate);
         v8::Local<v8::Context> context =
-            v8::Context::FromSnapshot(isolate, 0).ToLocalChecked();
+            v8::Context::FromSnapshot(isolate, 0, DeserializeInternalFields)
+                .ToLocalChecked();
         {
           v8::Context::Scope context_scope(context);
           ExpectInt32("f()", 42);
           ExpectInt32("g()", 12);
           ExpectInt32("h()", 13);
           ExpectInt32("i()", 24);
           ExpectInt32("j()", 25);
           ExpectInt32("o.p", 8);
           ExpectInt32("x", 2016);
           v8::Local<v8::Private> hidden =
               v8::Private::ForApi(isolate, v8_str("hidden"));
           CHECK(v8_str("hidden string")
                     ->Equals(context, context->Global()
                                           ->GetPrivate(context, hidden)
                                           .ToLocalChecked())
                     .FromJust());
           ExpectString("cached", "cached string");
         }
 
         v8::Local<v8::Object> global = context->Global();
         CHECK_EQ(3, global->InternalFieldCount());
         context->DetachGlobal();
 
         // New context, but reuse global proxy.
         v8::ExtensionConfiguration* no_extensions = nullptr;
         v8::Local<v8::Context> context2 =
-            v8::Context::FromSnapshot(isolate, 0, no_extensions, global)
+            v8::Context::FromSnapshot(isolate, 0, DeserializeInternalFields,
+                                      no_extensions, global)
                 .ToLocalChecked();
         {
           v8::Context::Scope context_scope(context2);
           ExpectInt32("f()", 42);
           ExpectInt32("g()", 12);
           ExpectInt32("h()", 13);
           ExpectInt32("i()", 24);
           ExpectInt32("j()", 25);
           ExpectInt32("o.p", 8);
           ExpectInt32("x", 2016);
@@ skipping 21 matching lines @@
   }
   delete[] blob.data;
 }
 
 TEST(SerializationMemoryStats) {
   FLAG_profile_deserialization = true;
   FLAG_always_opt = false;
   v8::StartupData blob = v8::V8::CreateSnapshotDataBlob();
   delete[] blob.data;
 }