[rename] Rename internal field to embedder field.

test/unittests/value-serializer-unittest.cc

 // Copyright 2016 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "src/value-serializer.h"
 
 #include <algorithm>
 #include <string>
 
 #include "include/v8.h"
@@ skipping 13 matching lines @@
 
 class ValueSerializerTest : public TestWithIsolate {
  protected:
   ValueSerializerTest()
       : serialization_context_(Context::New(isolate())),
         deserialization_context_(Context::New(isolate())) {
     // Create a host object type that can be tested through
     // serialization/deserialization delegates below.
     Local<FunctionTemplate> function_template = v8::FunctionTemplate::New(
         isolate(), [](const FunctionCallbackInfo<Value>& args) {
-          args.Holder()->SetInternalField(0, args[0]);
-          args.Holder()->SetInternalField(1, args[1]);
+          args.Holder()->SetEmbedderField(0, args[0]);
+          args.Holder()->SetEmbedderField(1, args[1]);
         });
-    function_template->InstanceTemplate()->SetInternalFieldCount(2);
+    function_template->InstanceTemplate()->SetEmbedderFieldCount(2);
     function_template->InstanceTemplate()->SetAccessor(
         StringFromUtf8("value"),
         [](Local<String> property, const PropertyCallbackInfo<Value>& args) {
-          args.GetReturnValue().Set(args.Holder()->GetInternalField(0));
+          args.GetReturnValue().Set(args.Holder()->GetEmbedderField(0));
         });
     function_template->InstanceTemplate()->SetAccessor(
         StringFromUtf8("value2"),
         [](Local<String> property, const PropertyCallbackInfo<Value>& args) {
-          args.GetReturnValue().Set(args.Holder()->GetInternalField(1));
+          args.GetReturnValue().Set(args.Holder()->GetEmbedderField(1));
         });
     for (Local<Context> context :
          {serialization_context_, deserialization_context_}) {
       context->Global()
           ->CreateDataProperty(
               context, StringFromUtf8("ExampleHostObject"),
               function_template->GetFunction(context).ToLocalChecked())
           .ToChecked();
     }
     host_object_constructor_template_ = function_template;
@@ skipping 2315 matching lines @@
 
 // This is a tag that is used in V8. Using this ensures that we have separate
 // tag namespaces.
 const uint8_t ValueSerializerTestWithHostObject::kExampleHostObjectTag = 'T';
 
 TEST_F(ValueSerializerTestWithHostObject, RoundTripUint32) {
   // The host can serialize data as uint32_t.
   EXPECT_CALL(serializer_delegate_, WriteHostObject(isolate(), _))
       .WillRepeatedly(Invoke([this](Isolate*, Local<Object> object) {
         uint32_t value = 0;
-        EXPECT_TRUE(object->GetInternalField(0)
+        EXPECT_TRUE(object->GetEmbedderField(0)
                         ->Uint32Value(serialization_context())
                         .To(&value));
         WriteExampleHostObjectTag();
         serializer_->WriteUint32(value);
         return Just(true);
       }));
   EXPECT_CALL(deserializer_delegate_, ReadHostObject(isolate()))
       .WillRepeatedly(Invoke([this](Isolate*) {
         EXPECT_TRUE(ReadExampleHostObjectTag());
         uint32_t value = 0;
         EXPECT_TRUE(deserializer_->ReadUint32(&value));
         Local<Value> argv[] = {Integer::NewFromUnsigned(isolate(), value)};
         return NewHostObject(deserialization_context(), arraysize(argv), argv);
       }));
   RoundTripTest("new ExampleHostObject(42)", [this](Local<Value> value) {
     ASSERT_TRUE(value->IsObject());
-    ASSERT_TRUE(Object::Cast(*value)->InternalFieldCount());
+    ASSERT_TRUE(Object::Cast(*value)->EmbedderFieldCount());
     EXPECT_TRUE(EvaluateScriptForResultBool(
         "Object.getPrototypeOf(result) === ExampleHostObject.prototype"));
     EXPECT_TRUE(EvaluateScriptForResultBool("result.value === 42"));
   });
   RoundTripTest(
       "new ExampleHostObject(0xCAFECAFE)", [this](Local<Value> value) {
         EXPECT_TRUE(EvaluateScriptForResultBool("result.value === 0xCAFECAFE"));
       });
 }
 
 TEST_F(ValueSerializerTestWithHostObject, RoundTripUint64) {
   // The host can serialize data as uint64_t.
   EXPECT_CALL(serializer_delegate_, WriteHostObject(isolate(), _))
       .WillRepeatedly(Invoke([this](Isolate*, Local<Object> object) {
         uint32_t value = 0, value2 = 0;
-        EXPECT_TRUE(object->GetInternalField(0)
+        EXPECT_TRUE(object->GetEmbedderField(0)
                         ->Uint32Value(serialization_context())
                         .To(&value));
-        EXPECT_TRUE(object->GetInternalField(1)
+        EXPECT_TRUE(object->GetEmbedderField(1)
                         ->Uint32Value(serialization_context())
                         .To(&value2));
         WriteExampleHostObjectTag();
         serializer_->WriteUint64((static_cast<uint64_t>(value) << 32) | value2);
         return Just(true);
       }));
   EXPECT_CALL(deserializer_delegate_, ReadHostObject(isolate()))
       .WillRepeatedly(Invoke([this](Isolate*) {
         EXPECT_TRUE(ReadExampleHostObjectTag());
         uint64_t value_packed;
         EXPECT_TRUE(deserializer_->ReadUint64(&value_packed));
         Local<Value> argv[] = {
             Integer::NewFromUnsigned(isolate(),
                                      static_cast<uint32_t>(value_packed >> 32)),
             Integer::NewFromUnsigned(isolate(),
                                      static_cast<uint32_t>(value_packed))};
         return NewHostObject(deserialization_context(), arraysize(argv), argv);
       }));
   RoundTripTest("new ExampleHostObject(42, 0)", [this](Local<Value> value) {
     ASSERT_TRUE(value->IsObject());
-    ASSERT_TRUE(Object::Cast(*value)->InternalFieldCount());
+    ASSERT_TRUE(Object::Cast(*value)->EmbedderFieldCount());
     EXPECT_TRUE(EvaluateScriptForResultBool(
         "Object.getPrototypeOf(result) === ExampleHostObject.prototype"));
     EXPECT_TRUE(EvaluateScriptForResultBool("result.value === 42"));
     EXPECT_TRUE(EvaluateScriptForResultBool("result.value2 === 0"));
   });
   RoundTripTest(
       "new ExampleHostObject(0xFFFFFFFF, 0x12345678)",
       [this](Local<Value> value) {
         EXPECT_TRUE(EvaluateScriptForResultBool("result.value === 0xFFFFFFFF"));
         EXPECT_TRUE(
             EvaluateScriptForResultBool("result.value2 === 0x12345678"));
       });
 }
 
 TEST_F(ValueSerializerTestWithHostObject, RoundTripDouble) {
   // The host can serialize data as double.
   EXPECT_CALL(serializer_delegate_, WriteHostObject(isolate(), _))
       .WillRepeatedly(Invoke([this](Isolate*, Local<Object> object) {
         double value = 0;
-        EXPECT_TRUE(object->GetInternalField(0)
+        EXPECT_TRUE(object->GetEmbedderField(0)
                         ->NumberValue(serialization_context())
                         .To(&value));
         WriteExampleHostObjectTag();
         serializer_->WriteDouble(value);
         return Just(true);
       }));
   EXPECT_CALL(deserializer_delegate_, ReadHostObject(isolate()))
       .WillRepeatedly(Invoke([this](Isolate*) {
         EXPECT_TRUE(ReadExampleHostObjectTag());
         double value = 0;
         EXPECT_TRUE(deserializer_->ReadDouble(&value));
         Local<Value> argv[] = {Number::New(isolate(), value)};
         return NewHostObject(deserialization_context(), arraysize(argv), argv);
       }));
   RoundTripTest("new ExampleHostObject(-3.5)", [this](Local<Value> value) {
     ASSERT_TRUE(value->IsObject());
-    ASSERT_TRUE(Object::Cast(*value)->InternalFieldCount());
+    ASSERT_TRUE(Object::Cast(*value)->EmbedderFieldCount());
     EXPECT_TRUE(EvaluateScriptForResultBool(
         "Object.getPrototypeOf(result) === ExampleHostObject.prototype"));
     EXPECT_TRUE(EvaluateScriptForResultBool("result.value === -3.5"));
   });
   RoundTripTest("new ExampleHostObject(NaN)", [this](Local<Value> value) {
     EXPECT_TRUE(EvaluateScriptForResultBool("Number.isNaN(result.value)"));
   });
   RoundTripTest("new ExampleHostObject(Infinity)", [this](Local<Value> value) {
     EXPECT_TRUE(EvaluateScriptForResultBool("result.value === Infinity"));
   });
@@ skipping 22 matching lines @@
         const void* copied_data = nullptr;
         EXPECT_TRUE(
             deserializer_->ReadRawBytes(sizeof(sample_data), &copied_data));
         if (copied_data) {
           EXPECT_EQ(0, memcmp(&sample_data, copied_data, sizeof(sample_data)));
         }
         return NewHostObject(deserialization_context(), 0, nullptr);
       }));
   RoundTripTest("new ExampleHostObject()", [this](Local<Value> value) {
     ASSERT_TRUE(value->IsObject());
-    ASSERT_TRUE(Object::Cast(*value)->InternalFieldCount());
+    ASSERT_TRUE(Object::Cast(*value)->EmbedderFieldCount());
     EXPECT_TRUE(EvaluateScriptForResultBool(
         "Object.getPrototypeOf(result) === ExampleHostObject.prototype"));
   });
 }
 
 TEST_F(ValueSerializerTestWithHostObject, RoundTripSameObject) {
   // If the same object exists in two places, the delegate should be invoked
   // only once, and the objects should be the same (by reference equality) on
   // the other side.
   EXPECT_CALL(serializer_delegate_, WriteHostObject(isolate(), _))
@@ skipping 214 matching lines @@
   InvalidDecodeTest(raw);
 }
 
 TEST_F(ValueSerializerTestWithWasm, DecodeWasmModuleWithInvalidDataLength) {
   InvalidDecodeTest({0xff, 0x09, 0x3f, 0x00, 0x57, 0x79, 0x7f, 0x00});
   InvalidDecodeTest({0xff, 0x09, 0x3f, 0x00, 0x57, 0x79, 0x00, 0x7f});
 }
 
 }  // namespace
 }  // namespace v8