[rename] Rename internal field to embedder field.

src/snapshot/partial-serializer.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/snapshot/partial-serializer.h"
 #include "src/snapshot/startup-serializer.h"
 
 #include "src/objects-inl.h"
 
 namespace v8 {
 namespace internal {
 
 PartialSerializer::PartialSerializer(
     Isolate* isolate, StartupSerializer* startup_serializer,
-    v8::SerializeInternalFieldsCallback callback)
+    v8::SerializeEmbedderFieldsCallback callback)
     : Serializer(isolate),
       startup_serializer_(startup_serializer),
-      serialize_internal_fields_(callback) {
+      serialize_embedder_fields_(callback) {
   InitializeCodeAddressMap();
 }
 
 PartialSerializer::~PartialSerializer() {
   OutputStatistics("PartialSerializer");
 }
 
 void PartialSerializer::Serialize(Object** o, bool include_global_proxy) {
   if ((*o)->IsContext()) {
     Context* context = Context::cast(*o);
     reference_map()->AddAttachedReference(context->global_proxy());
     // The bootstrap snapshot has a code-stub context. When serializing the
     // partial snapshot, it is chained into the weak context list on the isolate
     // and it's next context pointer may point to the code-stub context.  Clear
     // it before serializing, it will get re-added to the context list
     // explicitly when it's loaded.
     if (context->IsNativeContext()) {
       context->set(Context::NEXT_CONTEXT_LINK,
                    isolate_->heap()->undefined_value());
       DCHECK(!context->global_object()->IsUndefined(context->GetIsolate()));
       // Reset math random cache to get fresh random numbers.
       context->set_math_random_index(Smi::kZero);
       context->set_math_random_cache(isolate_->heap()->undefined_value());
     }
   }
   VisitPointer(o);
   SerializeDeferredObjects();
-  SerializeInternalFields();
+  SerializeEmbedderFields();
   Pad();
 }
 
 void PartialSerializer::SerializeObject(HeapObject* obj, HowToCode how_to_code,
                                         WhereToPoint where_to_point, int skip) {
   if (obj->IsMap()) {
     // The code-caches link to context-specific code objects, which
     // the startup and context serializes cannot currently handle.
     DCHECK(Map::cast(obj)->code_cache() == obj->GetHeap()->empty_fixed_array());
   }
@@ skipping 34 matching lines @@
   FlushSkip(skip);
 
   // Clear literal boilerplates.
   if (obj->IsJSFunction()) {
     JSFunction* function = JSFunction::cast(obj);
     function->ClearTypeFeedbackInfo();
   }
 
   if (obj->IsJSObject()) {
     JSObject* jsobj = JSObject::cast(obj);
-    if (jsobj->GetInternalFieldCount() > 0) {
-      DCHECK_NOT_NULL(serialize_internal_fields_.callback);
-      internal_field_holders_.Add(jsobj);
+    if (jsobj->GetEmbedderFieldCount() > 0) {
+      DCHECK_NOT_NULL(serialize_embedder_fields_.callback);
+      embedder_field_holders_.Add(jsobj);
     }
   }
 
   // Object has not yet been serialized.  Serialize it here.
   ObjectSerializer serializer(this, obj, &sink_, how_to_code, where_to_point);
   serializer.Serialize();
 }
 
 bool PartialSerializer::ShouldBeInThePartialSnapshotCache(HeapObject* o) {
   // Scripts should be referred only through shared function infos.  We can't
   // allow them to be part of the partial snapshot because they contain a
   // unique ID, and deserializing several partial snapshots containing script
   // would cause dupes.
   DCHECK(!o->IsScript());
   return o->IsName() || o->IsSharedFunctionInfo() || o->IsHeapNumber() ||
          o->IsCode() || o->IsScopeInfo() || o->IsAccessorInfo() ||
          o->IsTemplateInfo() ||
          o->map() ==
              startup_serializer_->isolate()->heap()->fixed_cow_array_map();
 }
 
-void PartialSerializer::SerializeInternalFields() {
-  int count = internal_field_holders_.length();
+void PartialSerializer::SerializeEmbedderFields() {
+  int count = embedder_field_holders_.length();
   if (count == 0) return;
   DisallowHeapAllocation no_gc;
   DisallowJavascriptExecution no_js(isolate());
   DisallowCompilation no_compile(isolate());
-  DCHECK_NOT_NULL(serialize_internal_fields_.callback);
-  sink_.Put(kInternalFieldsData, "internal fields data");
-  while (internal_field_holders_.length() > 0) {
+  DCHECK_NOT_NULL(serialize_embedder_fields_.callback);
+  sink_.Put(kEmbedderFieldsData, "embedder fields data");
+  while (embedder_field_holders_.length() > 0) {
     HandleScope scope(isolate());
-    Handle<JSObject> obj(internal_field_holders_.RemoveLast(), isolate());
+    Handle<JSObject> obj(embedder_field_holders_.RemoveLast(), isolate());
     SerializerReference reference = reference_map_.Lookup(*obj);
     DCHECK(reference.is_back_reference());
-    int internal_fields_count = obj->GetInternalFieldCount();
-    for (int i = 0; i < internal_fields_count; i++) {
-      if (obj->GetInternalField(i)->IsHeapObject()) continue;
-      StartupData data = serialize_internal_fields_.callback(
-          v8::Utils::ToLocal(obj), i, serialize_internal_fields_.data);
-      sink_.Put(kNewObject + reference.space(), "internal field holder");
+    int embedder_fields_count = obj->GetEmbedderFieldCount();
+    for (int i = 0; i < embedder_fields_count; i++) {
+      if (obj->GetEmbedderField(i)->IsHeapObject()) continue;
+      StartupData data = serialize_embedder_fields_.callback(
+          v8::Utils::ToLocal(obj), i, serialize_embedder_fields_.data);
+      sink_.Put(kNewObject + reference.space(), "embedder field holder");
       PutBackReference(*obj, reference);
-      sink_.PutInt(i, "internal field index");
-      sink_.PutInt(data.raw_size, "internal fields data size");
+      sink_.PutInt(i, "embedder field index");
+      sink_.PutInt(data.raw_size, "embedder fields data size");
       sink_.PutRaw(reinterpret_cast<const byte*>(data.data), data.raw_size,
-                   "internal fields data");
+                   "embedder fields data");
       delete[] data.data;
     }
   }
-  sink_.Put(kSynchronize, "Finished with internal fields data");
+  sink_.Put(kSynchronize, "Finished with embedder fields data");
 }
 
 }  // namespace internal
 }  // namespace v8