[serializer] small fixes for blink snapshot.

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 2004 matching lines @@
 
 void SerializedCallback(const v8::FunctionCallbackInfo<v8::Value>& args) {
   args.GetReturnValue().Set(v8_num(42));
 }
 
 void SerializedCallbackReplacement(
     const v8::FunctionCallbackInfo<v8::Value>& args) {
   args.GetReturnValue().Set(v8_num(1337));
 }
 
+static int serialized_static_field = 314;
+
 intptr_t original_external_references[] = {
-    reinterpret_cast<intptr_t>(SerializedCallback), 0};
+    reinterpret_cast<intptr_t>(SerializedCallback),
+    reinterpret_cast<intptr_t>(&serialized_static_field), 0};
 
 intptr_t replaced_external_references[] = {
-    reinterpret_cast<intptr_t>(SerializedCallbackReplacement), 0};
+    reinterpret_cast<intptr_t>(SerializedCallbackReplacement),
+    reinterpret_cast<intptr_t>(&serialized_static_field), 0};
 
 TEST(SnapshotCreatorExternalReferences) {
   DisableAlwaysOpt();
   v8::StartupData blob;
   {
     v8::SnapshotCreator creator(original_external_references);
     v8::Isolate* isolate = creator.GetIsolate();
     {
       v8::HandleScope handle_scope(isolate);
       v8::Local<v8::Context> context = v8::Context::New(isolate);
@@ skipping 95 matching lines @@
 }
 
 TEST(SnapshotCreatorTemplates) {
   DisableAlwaysOpt();
   v8::StartupData blob;
 
   {
     InternalFieldData* a1 = new InternalFieldData{11};
     InternalFieldData* b0 = new InternalFieldData{20};
     InternalFieldData* c0 = new InternalFieldData{30};
-    InternalFieldData* c1 = new InternalFieldData{31};
 
     v8::SnapshotCreator creator(original_external_references);
     v8::Isolate* isolate = creator.GetIsolate();
     {
       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);
       v8::Local<v8::ObjectTemplate> object_template =
           v8::ObjectTemplate::New(isolate);
-      object_template->SetInternalFieldCount(2);
+      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->SetAlignedPointerInInternalField(1, c1);
+      c->SetInternalField(1, null_external);
+      c->SetInternalField(2, field_external);
       CHECK(context->Global()->Set(context, v8_str("a"), a).FromJust());
 
       CHECK_EQ(0u, creator.AddContext(context));
       CHECK_EQ(0u, creator.AddTemplate(callback));
       CHECK_EQ(1u, creator.AddTemplate(global_template));
     }
     blob = creator.CreateBlob(v8::SnapshotCreator::FunctionCodeHandling::kClear,
                               SerializeInternalFields);
 
     delete a1;
     delete b0;
-    delete c1;
     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);
@@ skipping 32 matching lines @@
         // Retrieve internal fields.
         v8::Local<v8::Object> a = context->Global()
                                       ->Get(context, v8_str("a"))
                                       .ToLocalChecked()
                                       ->ToObject(context)
                                       .ToLocalChecked();
         v8::Local<v8::Object> b =
             a->GetInternalField(0)->ToObject(context).ToLocalChecked();
         InternalFieldData* a1 = reinterpret_cast<InternalFieldData*>(
             a->GetAlignedPointerFromInternalField(1));
+        v8::Local<v8::Value> a2 = a->GetInternalField(2);
+
         InternalFieldData* b0 = reinterpret_cast<InternalFieldData*>(
             b->GetAlignedPointerFromInternalField(0));
         v8::Local<v8::Object> c =
             b->GetInternalField(1)->ToObject(context).ToLocalChecked();
+        v8::Local<v8::Value> b2 = b->GetInternalField(2);
+
         InternalFieldData* c0 = reinterpret_cast<InternalFieldData*>(
             c->GetAlignedPointerFromInternalField(0));
-        InternalFieldData* c1 = reinterpret_cast<InternalFieldData*>(
-            c->GetAlignedPointerFromInternalField(1));
+        v8::Local<v8::Value> c1 = c->GetInternalField(1);
+        v8::Local<v8::Value> c2 = c->GetInternalField(2);
 
         CHECK_EQ(11u, a1->data);
+        CHECK(a2->IsUndefined());
         CHECK_EQ(20u, b0->data);
+        CHECK(b2->IsUndefined());
         CHECK_EQ(30u, c0->data);
-        CHECK_EQ(31u, c1->data);
+        CHECK(c1->IsExternal());
+        CHECK_NULL(v8::Local<v8::External>::Cast(c1)->Value());
+        CHECK_EQ(static_cast<void*>(&serialized_static_field),
+                 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, 2).IsEmpty());
 
         delete a1;
         delete b0;
-        delete c1;
         delete c0;
       }
 
       {
         // 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);
@@ skipping 12 matching lines @@
   }
   delete[] blob.data;
 }
 
 TEST(SerializationMemoryStats) {
   FLAG_profile_deserialization = true;
   FLAG_always_opt = false;
   v8::StartupData blob = v8::V8::CreateSnapshotDataBlob();
   delete[] blob.data;
 }