[serializer] add test for snapshotting cached accessor property.

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 2371 matching lines @@
       v8::HandleScope handle_scope(isolate);
       v8::Local<v8::ObjectTemplate> global_template =
           v8::ObjectTemplate::New(isolate);
       v8::Local<v8::FunctionTemplate> callback =
           v8::FunctionTemplate::New(isolate, SerializedCallback);
       global_template->SetInternalFieldCount(3);
       global_template->Set(v8_str("f"), callback);
       global_template->SetHandler(v8::NamedPropertyHandlerConfiguration(
           NamedPropertyGetterForSerialization));
       global_template->SetAccessor(v8_str("y"), AccessorForSerialization);
+      v8::Local<v8::Private> priv =
+          v8::Private::ForApi(isolate, v8_str("cached"));
+      global_template->SetAccessorProperty(
+          v8_str("cached"),
+          v8::FunctionTemplate::NewWithCache(isolate, SerializedCallback, priv,
+                                             v8::Local<v8::Value>()));
       v8::Local<v8::Context> context =
           v8::Context::New(isolate, &extensions, global_template);
       v8::Context::Scope context_scope(context);
+
+      CHECK(context->Global()
+                ->SetPrivate(context, priv, v8_str("cached string"))
+                .FromJust());
+      v8::Local<v8::Private> hidden =
+          v8::Private::ForApi(isolate, v8_str("hidden"));
+      CHECK(context->Global()
+                ->SetPrivate(context, hidden, v8_str("hidden string"))
+                .FromJust());
+
       ExpectInt32("f()", 42);
       ExpectInt32("g()", 12);
       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));
     }
     blob = creator.CreateBlob(v8::SnapshotCreator::FunctionCodeHandling::kClear,
                               SerializeInternalFields);
   }
 
   {
     v8::Isolate::CreateParams params;
     params.snapshot_blob = &blob;
     params.array_buffer_allocator = CcTest::array_buffer_allocator();
@@ skipping 35 matching lines @@
             v8::Context::FromSnapshot(isolate, 0).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)
                 .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);
+          v8::Local<v8::Private> hidden =
+              v8::Private::ForApi(isolate, v8_str("hidden"));
+          CHECK(v8_str("hidden string")
+                    ->Equals(context2, context2->Global()
+                                           ->GetPrivate(context2, hidden)
+                                           .ToLocalChecked())
+                    .FromJust());
+
+          // Set cached accessor property again.
+          v8::Local<v8::Private> priv =
+              v8::Private::ForApi(isolate, v8_str("cached"));
+          CHECK(context2->Global()
+                    ->SetPrivate(context2, priv, v8_str("cached string 1"))
+                    .FromJust());
+          ExpectString("cached", "cached string 1");
         }
 
         CHECK(context2->Global()->Equals(context2, global).FromJust());
       }
     }
     isolate->Dispose();
   }
   delete[] blob.data;
 }
 
 TEST(SerializationMemoryStats) {
   FLAG_profile_deserialization = true;
   FLAG_always_opt = false;
   v8::StartupData blob = v8::V8::CreateSnapshotDataBlob();
   delete[] blob.data;
 }