[serializer] fix leak in test.

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 2154 matching lines @@
                                         int index) {
   InternalFieldData* data = static_cast<InternalFieldData*>(
       holder->GetAlignedPointerFromInternalField(index));
   int size = sizeof(*data);
   char* payload = new char[size];
   // We simply use memcpy to serialize the content.
   memcpy(payload, data, size);
   return {payload, size};
 }
 
+std::vector<InternalFieldData*> deserialized_data;
+
 void DeserializeInternalFields(v8::Local<v8::Object> holder, int index,
                                v8::StartupData payload) {
   InternalFieldData* data = new InternalFieldData{0};
   memcpy(data, payload.data, payload.raw_size);
   holder->SetAlignedPointerInInternalField(index, data);
+  deserialized_data.push_back(data);
 }
 
 TEST(SnapshotCreatorTemplates) {
   DisableAlwaysOpt();
   v8::StartupData blob;
 
   {
     InternalFieldData* a1 = new InternalFieldData{11};
     InternalFieldData* b0 = new InternalFieldData{20};
     InternalFieldData* c0 = new InternalFieldData{30};
@@ skipping 117 matching lines @@
         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, 1).IsEmpty());
 
-        delete a1;
-        delete b0;
-        delete c0;
+        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 180 matching lines @@
   }
   delete[] blob.data;
 }
 
 TEST(SerializationMemoryStats) {
   FLAG_profile_deserialization = true;
   FLAG_always_opt = false;
   v8::StartupData blob = v8::V8::CreateSnapshotDataBlob();
   delete[] blob.data;
 }