[rename] Rename internal field to embedder field.

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 269 matching lines @@
       v8::HandleScope handle_scope(v8_isolate);
       v8::Local<v8::Context>::New(v8_isolate, env)->Exit();
     }
     env.Reset();
 
     StartupSerializer startup_serializer(
         isolate, v8::SnapshotCreator::FunctionCodeHandling::kClear);
     startup_serializer.SerializeStrongReferences();
 
     PartialSerializer partial_serializer(isolate, &startup_serializer,
-                                         v8::SerializeInternalFieldsCallback());
+                                         v8::SerializeEmbedderFieldsCallback());
     partial_serializer.Serialize(&raw_foo, false);
 
     startup_serializer.SerializeWeakReferencesAndDeferred();
 
     SnapshotData startup_snapshot(&startup_serializer);
     SnapshotData partial_snapshot(&partial_serializer);
 
     *partial_blob_out = WritePayload(partial_snapshot.RawData());
     *startup_blob_out = WritePayload(startup_snapshot.RawData());
   }
@@ skipping 17 matching lines @@
     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,
-                                     v8::DeserializeInternalFieldsCallback())
+                                     v8::DeserializeEmbedderFieldsCallback())
                  .ToHandleChecked();
       CHECK(root->IsString());
     }
 
     Handle<Object> root2;
     {
       SnapshotData snapshot_data(partial_blob);
       Deserializer deserializer(&snapshot_data);
       root2 = deserializer
                   .DeserializePartial(isolate, global_proxy,
-                                      v8::DeserializeInternalFieldsCallback())
+                                      v8::DeserializeEmbedderFieldsCallback())
                   .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 35 matching lines @@
 
     env.Reset();
 
     SnapshotByteSink startup_sink;
     StartupSerializer startup_serializer(
         isolate, v8::SnapshotCreator::FunctionCodeHandling::kClear);
     startup_serializer.SerializeStrongReferences();
 
     SnapshotByteSink partial_sink;
     PartialSerializer partial_serializer(isolate, &startup_serializer,
-                                         v8::SerializeInternalFieldsCallback());
+                                         v8::SerializeEmbedderFieldsCallback());
     partial_serializer.Serialize(&raw_context, false);
     startup_serializer.SerializeWeakReferencesAndDeferred();
 
     SnapshotData startup_snapshot(&startup_serializer);
     SnapshotData partial_snapshot(&partial_serializer);
 
     *partial_blob_out = WritePayload(partial_snapshot.RawData());
     *startup_blob_out = WritePayload(startup_snapshot.RawData());
   }
   v8_isolate->Dispose();
 }
 
 UNINITIALIZED_TEST(PartialSerializerContext) {
   DisableAlwaysOpt();
   Vector<const byte> startup_blob;
   Vector<const byte> partial_blob;
   PartiallySerializeContext(&startup_blob, &partial_blob);
 
   v8::Isolate* v8_isolate = InitializeFromBlob(startup_blob);
   CHECK(v8_isolate);
   startup_blob.Dispose();
   {
     v8::Isolate::Scope isolate_scope(v8_isolate);
 
     Isolate* isolate = reinterpret_cast<Isolate*>(v8_isolate);
     HandleScope handle_scope(isolate);
     Handle<Object> root;
     Handle<JSGlobalProxy> global_proxy =
         isolate->factory()->NewUninitializedJSGlobalProxy(
-            JSGlobalProxy::SizeWithInternalFields(0));
+            JSGlobalProxy::SizeWithEmbedderFields(0));
     {
       SnapshotData snapshot_data(partial_blob);
       Deserializer deserializer(&snapshot_data);
       root = deserializer
                  .DeserializePartial(isolate, global_proxy,
-                                     v8::DeserializeInternalFieldsCallback())
+                                     v8::DeserializeEmbedderFieldsCallback())
                  .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,
-                                      v8::DeserializeInternalFieldsCallback())
+                                      v8::DeserializeEmbedderFieldsCallback())
                   .ToHandleChecked();
       CHECK(root2->IsContext());
       CHECK(!root.is_identical_to(root2));
     }
     partial_blob.Dispose();
   }
   v8_isolate->Dispose();
 }
 
 static void PartiallySerializeCustomContext(
@@ skipping 56 matching lines @@
 
     env.Reset();
 
     SnapshotByteSink startup_sink;
     StartupSerializer startup_serializer(
         isolate, v8::SnapshotCreator::FunctionCodeHandling::kClear);
     startup_serializer.SerializeStrongReferences();
 
     SnapshotByteSink partial_sink;
     PartialSerializer partial_serializer(isolate, &startup_serializer,
-                                         v8::SerializeInternalFieldsCallback());
+                                         v8::SerializeEmbedderFieldsCallback());
     partial_serializer.Serialize(&raw_context, false);
     startup_serializer.SerializeWeakReferencesAndDeferred();
 
     SnapshotData startup_snapshot(&startup_serializer);
     SnapshotData partial_snapshot(&partial_serializer);
 
     *partial_blob_out = WritePayload(partial_snapshot.RawData());
     *startup_blob_out = WritePayload(startup_snapshot.RawData());
   }
   v8_isolate->Dispose();
 }
 
 UNINITIALIZED_TEST(PartialSerializerCustomContext) {
   DisableAlwaysOpt();
   Vector<const byte> startup_blob;
   Vector<const byte> partial_blob;
   PartiallySerializeCustomContext(&startup_blob, &partial_blob);
 
   v8::Isolate* v8_isolate = InitializeFromBlob(startup_blob);
   CHECK(v8_isolate);
   startup_blob.Dispose();
   {
     v8::Isolate::Scope isolate_scope(v8_isolate);
 
     Isolate* isolate = reinterpret_cast<Isolate*>(v8_isolate);
     HandleScope handle_scope(isolate);
     Handle<Object> root;
     Handle<JSGlobalProxy> global_proxy =
         isolate->factory()->NewUninitializedJSGlobalProxy(
-            JSGlobalProxy::SizeWithInternalFields(0));
+            JSGlobalProxy::SizeWithEmbedderFields(0));
     {
       SnapshotData snapshot_data(partial_blob);
       Deserializer deserializer(&snapshot_data);
       root = deserializer
                  .DeserializePartial(isolate, global_proxy,
-                                     v8::DeserializeInternalFieldsCallback())
+                                     v8::DeserializeEmbedderFieldsCallback())
                  .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 1508 matching lines @@
     ExpectInt32("f()", 42);
 
     creator.SetDefaultContext(context);
   }
   v8::StartupData blob =
       creator.CreateBlob(v8::SnapshotCreator::FunctionCodeHandling::kClear);
 
   delete[] blob.data;
 }
 
-struct InternalFieldData {
+struct EmbedderFieldData {
   uint32_t data;
 };
 
-v8::StartupData SerializeInternalFields(v8::Local<v8::Object> holder, int index,
+v8::StartupData SerializeEmbedderFields(v8::Local<v8::Object> holder, int index,
                                         void* data) {
   CHECK_EQ(reinterpret_cast<void*>(2016), data);
-  InternalFieldData* internal_field = static_cast<InternalFieldData*>(
-      holder->GetAlignedPointerFromInternalField(index));
-  int size = sizeof(*internal_field);
+  EmbedderFieldData* embedder_field = static_cast<EmbedderFieldData*>(
+      holder->GetAlignedPointerFromEmbedderField(index));
+  int size = sizeof(*embedder_field);
   char* payload = new char[size];
   // We simply use memcpy to serialize the content.
-  memcpy(payload, internal_field, size);
+  memcpy(payload, embedder_field, size);
   return {payload, size};
 }
 
-std::vector<InternalFieldData*> deserialized_data;
+std::vector<EmbedderFieldData*> deserialized_data;
 
-void DeserializeInternalFields(v8::Local<v8::Object> holder, int index,
+void DeserializeEmbedderFields(v8::Local<v8::Object> holder, int index,
                                v8::StartupData payload, void* data) {
   CHECK_EQ(reinterpret_cast<void*>(2017), data);
-  InternalFieldData* internal_field = new InternalFieldData{0};
-  memcpy(internal_field, payload.data, payload.raw_size);
-  holder->SetAlignedPointerInInternalField(index, internal_field);
-  deserialized_data.push_back(internal_field);
+  EmbedderFieldData* embedder_field = new EmbedderFieldData{0};
+  memcpy(embedder_field, payload.data, payload.raw_size);
+  holder->SetAlignedPointerInEmbedderField(index, embedder_field);
+  deserialized_data.push_back(embedder_field);
 }
 
 TEST(SnapshotCreatorTemplates) {
   DisableAlwaysOpt();
   v8::StartupData blob;
 
   {
-    InternalFieldData* a1 = new InternalFieldData{11};
-    InternalFieldData* b0 = new InternalFieldData{20};
-    InternalFieldData* c0 = new InternalFieldData{30};
+    EmbedderFieldData* a1 = new EmbedderFieldData{11};
+    EmbedderFieldData* b0 = new EmbedderFieldData{20};
+    EmbedderFieldData* c0 = new EmbedderFieldData{30};
 
     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);
       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);
+      object_template->SetEmbedderFieldCount(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);
+      a->SetEmbedderField(0, b);
+      a->SetAlignedPointerInEmbedderField(1, a1);
+      b->SetAlignedPointerInEmbedderField(0, b0);
+      b->SetEmbedderField(1, c);
+      c->SetAlignedPointerInEmbedderField(0, c0);
+      c->SetEmbedderField(1, null_external);
+      c->SetEmbedderField(2, field_external);
       CHECK(context->Global()->Set(context, v8_str("a"), a).FromJust());
 
       CHECK_EQ(0u,
-               creator.AddContext(context, v8::SerializeInternalFieldsCallback(
-                                               SerializeInternalFields,
+               creator.AddContext(context, v8::SerializeEmbedderFieldsCallback(
+                                               SerializeEmbedderFields,
                                                reinterpret_cast<void*>(2016))));
       CHECK_EQ(0u, creator.AddTemplate(callback));
       CHECK_EQ(1u, creator.AddTemplate(global_template));
     }
     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;
     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::FromSnapshot(
                 isolate, 0,
-                v8::DeserializeInternalFieldsCallback(
-                    DeserializeInternalFields, reinterpret_cast<void*>(2017)))
+                v8::DeserializeEmbedderFieldsCallback(
+                    DeserializeEmbedderFields, reinterpret_cast<void*>(2017)))
                 .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());
         ExpectInt32("o.f()", 42);
         // Check that it instantiates to the same prototype.
         ExpectTrue("o.f.prototype === f.prototype");
 
         // Retrieve the snapshotted function template.
         v8::Local<v8::FunctionTemplate> fun_template =
             v8::FunctionTemplate::FromSnapshot(isolate, 0).ToLocalChecked();
         CHECK(!fun_template.IsEmpty());
         v8::Local<v8::Function> fun =
             fun_template->GetFunction(context).ToLocalChecked();
         CHECK(context->Global()->Set(context, v8_str("g"), fun).FromJust());
         ExpectInt32("g()", 42);
         // Check that it instantiates to the same prototype.
         ExpectTrue("g.prototype === f.prototype");
 
-        // Retrieve internal fields.
+        // Retrieve embedder 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);
+            a->GetEmbedderField(0)->ToObject(context).ToLocalChecked();
+        EmbedderFieldData* a1 = reinterpret_cast<EmbedderFieldData*>(
+            a->GetAlignedPointerFromEmbedderField(1));
+        v8::Local<v8::Value> a2 = a->GetEmbedderField(2);
 
-        InternalFieldData* b0 = reinterpret_cast<InternalFieldData*>(
-            b->GetAlignedPointerFromInternalField(0));
+        EmbedderFieldData* b0 = reinterpret_cast<EmbedderFieldData*>(
+            b->GetAlignedPointerFromEmbedderField(0));
         v8::Local<v8::Object> c =
-            b->GetInternalField(1)->ToObject(context).ToLocalChecked();
-        v8::Local<v8::Value> b2 = b->GetInternalField(2);
+            b->GetEmbedderField(1)->ToObject(context).ToLocalChecked();
+        v8::Local<v8::Value> b2 = b->GetEmbedderField(2);
 
-        InternalFieldData* c0 = reinterpret_cast<InternalFieldData*>(
-            c->GetAlignedPointerFromInternalField(0));
-        v8::Local<v8::Value> c1 = c->GetInternalField(1);
-        v8::Local<v8::Value> c2 = c->GetInternalField(2);
+        EmbedderFieldData* c0 = reinterpret_cast<EmbedderFieldData*>(
+            c->GetAlignedPointerFromEmbedderField(0));
+        v8::Local<v8::Value> c1 = c->GetEmbedderField(1);
+        v8::Local<v8::Value> c2 = c->GetEmbedderField(2);
 
         CHECK_EQ(11u, a1->data);
         CHECK(a2->IsUndefined());
         CHECK_EQ(20u, b0->data);
         CHECK(b2->IsUndefined());
         CHECK_EQ(30u, c0->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());
@@ skipping 48 matching lines @@
     {
       // Add additional context. This context implicitly *does* serialize
       // the global proxy, and upon deserialization one has to be created
       // in the bootstrapper from the global object template.
       // Side effects from extensions are persisted.
       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->SetEmbedderFieldCount(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>()));
@@ skipping 16 matching lines @@
       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, v8::SerializeInternalFieldsCallback(
-                                               SerializeInternalFields,
+               creator.AddContext(context, v8::SerializeEmbedderFieldsCallback(
+                                               SerializeEmbedderFields,
                                                reinterpret_cast<void*>(2016))));
     }
     blob =
         creator.CreateBlob(v8::SnapshotCreator::FunctionCodeHandling::kClear);
   }
 
   {
     v8::Isolate::CreateParams params;
     params.snapshot_blob = &blob;
     params.array_buffer_allocator = CcTest::array_buffer_allocator();
@@ skipping 26 matching lines @@
         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,
-                v8::DeserializeInternalFieldsCallback(
-                    DeserializeInternalFields, reinterpret_cast<void*>(2017)))
+                v8::DeserializeEmbedderFieldsCallback(
+                    DeserializeEmbedderFields, reinterpret_cast<void*>(2017)))
                 .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());
+        CHECK_EQ(3, global->EmbedderFieldCount());
         context->DetachGlobal();
 
         // New context, but reuse global proxy.
         v8::ExtensionConfiguration* no_extensions = nullptr;
         v8::Local<v8::Context> context2 =
             v8::Context::FromSnapshot(
                 isolate, 0,
-                v8::DeserializeInternalFieldsCallback(
-                    DeserializeInternalFields, reinterpret_cast<void*>(2017)),
+                v8::DeserializeEmbedderFieldsCallback(
+                    DeserializeEmbedderFields, reinterpret_cast<void*>(2017)),
                 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);
@@ skipping 22 matching lines @@
   }
   delete[] blob.data;
 }
 
 TEST(SerializationMemoryStats) {
   FLAG_profile_deserialization = true;
   FLAG_always_opt = false;
   v8::StartupData blob = v8::V8::CreateSnapshotDataBlob();
   delete[] blob.data;
 }