[rename] Rename internal field to embedder field.

include/v8.h

 // Copyright 2012 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.
 
 /** \mainpage V8 API Reference Guide
  *
  * V8 is Google's open source JavaScript engine.
  *
  * This set of documents provides reference material generated from the
  * V8 header file, include/v8.h.
@@ skipping 361 matching lines @@
   // Can only be safely called if already set.
   V8_INLINE Local<T> Get(Isolate* isolate);
   V8_INLINE bool IsEmpty() { return index_ == kInitialValue; }
   template<class S> V8_INLINE void Set(Isolate* isolate, Local<S> handle);
 
  private:
   static const int kInitialValue = -1;
   int index_;
 };
 
-
+// TODO(internal): deprecate this constant soon.
 static const int kInternalFieldsInWeakCallback = 2;
-
+static const int kEmbedderFieldsInWeakCallback = 2;
 
 template <typename T>
 class WeakCallbackInfo {
  public:
   typedef void (*Callback)(const WeakCallbackInfo<T>& data);
 
   WeakCallbackInfo(Isolate* isolate, T* parameter,
-                   void* internal_fields[kInternalFieldsInWeakCallback],
+                   void* embedder_fields[kEmbedderFieldsInWeakCallback],
                    Callback* callback)
       : isolate_(isolate), parameter_(parameter), callback_(callback) {
-    for (int i = 0; i < kInternalFieldsInWeakCallback; ++i) {
-      internal_fields_[i] = internal_fields[i];
+    for (int i = 0; i < kEmbedderFieldsInWeakCallback; ++i) {
+      embedder_fields_[i] = embedder_fields[i];
     }
   }
 
   V8_INLINE Isolate* GetIsolate() const { return isolate_; }
   V8_INLINE T* GetParameter() const { return parameter_; }
-  V8_INLINE void* GetInternalField(int index) const;
+  V8_INLINE V8_DEPRECATE_SOON("use GetEmbedderField(int index)",
+                              void* GetInternalField(int index) const);
+  V8_INLINE void* GetEmbedderField(int index) const;
 
-  V8_INLINE V8_DEPRECATED("use indexed version",
+  V8_INLINE V8_DEPRECATED("use GetEmbedderField(int index)",
                           void* GetInternalField1() const) {
-    return internal_fields_[0];
+    return embedder_fields_[0];
   }
-  V8_INLINE V8_DEPRECATED("use indexed version",
+  V8_INLINE V8_DEPRECATED("use GetEmbedderField(int index)",
                           void* GetInternalField2() const) {
-    return internal_fields_[1];
+    return embedder_fields_[1];
   }
 
   V8_DEPRECATED("Not realiable once SetSecondPassCallback() was used.",
                 bool IsFirstPass() const) {
     return callback_ != nullptr;
   }
 
   // When first called, the embedder MUST Reset() the Global which triggered the
   // callback. The Global itself is unusable for anything else. No v8 other api
   // calls may be called in the first callback. Should additional work be
   // required, the embedder must set a second pass callback, which will be
   // called after all the initial callbacks are processed.
   // Calling SetSecondPassCallback on the second pass will immediately crash.
   void SetSecondPassCallback(Callback callback) const { *callback_ = callback; }
 
  private:
   Isolate* isolate_;
   T* parameter_;
   Callback* callback_;
-  void* internal_fields_[kInternalFieldsInWeakCallback];
+  void* embedder_fields_[kEmbedderFieldsInWeakCallback];
 };
 
-
-// kParameter will pass a void* parameter back to the callback, kInternalFields
-// will pass the first two internal fields back to the callback, kFinalizer
+// kParameter will pass a void* parameter back to the callback, kEmbedderFields
+// will pass the first two embedder fields back to the callback, kFinalizer
 // will pass a void* parameter back, but is invoked before the object is
 // actually collected, so it can be resurrected. In the last case, it is not
 // possible to request a second pass callback.
-enum class WeakCallbackType { kParameter, kInternalFields, kFinalizer };
+enum class WeakCallbackType {
+  kParameter,
+  kEmbedderFields,
+  kInternalFields = kEmbedderFields,  // TODO(v8): deprecate
+  kFinalizer
+};
 
 /**
  * An object reference that is independent of any handle scope.  Where
  * a Local handle only lives as long as the HandleScope in which it was
  * allocated, a PersistentBase handle remains valid until it is explicitly
  * disposed.
  *
  * A persistent handle contains a reference to a storage cell within
  * the v8 engine which holds an object value and which is updated by
  * the garbage collector whenever the object is moved.  A new storage
@@ skipping 409 matching lines @@
   static internal::Object** CreateHandle(internal::HeapObject* heap_object,
                                          internal::Object* value);
 
   internal::Isolate* isolate_;
   internal::Object** prev_next_;
   internal::Object** prev_limit_;
 
   // Local::New uses CreateHandle with an Isolate* parameter.
   template<class F> friend class Local;
 
-  // Object::GetInternalField and Context::GetEmbedderData use CreateHandle with
+  // Object::GetExternalField and Context::GetEmbedderData use CreateHandle with
   // a HeapObject* in their shortcuts.
   friend class Object;
   friend class Context;
 };
 
 
 /**
  * A HandleScope which first allocates a handle in the current scope
  * which will be later filled with the escape value.
  */
@@ skipping 2228 matching lines @@
   /**
    * Returns the name of the function invoked as a constructor for this object.
    */
   Local<String> GetConstructorName();
 
   /**
    * Sets the integrity level of the object.
    */
   Maybe<bool> SetIntegrityLevel(Local<Context> context, IntegrityLevel level);
 
-  /** Gets the number of internal fields for this Object. */
-  int InternalFieldCount();
+  /** Gets the number of embedder fields for this Object. */
+  // TODO(internal): deprecate soon
+  int V8_DEPRECATE_SOON("use EmbedderFieldCount()", InternalFieldCount());
+  int EmbedderFieldCount();
 
   /** Same as above, but works for Persistents */
-  V8_INLINE static int InternalFieldCount(
-      const PersistentBase<Object>& object) {
+  // TODO(internal): deprecate soon
+  V8_INLINE static int V8_DEPRECATE_SOON(
+      "use EmbedderFieldCount()",
+      InternalFieldCount(const PersistentBase<Object>& object)) {
     return object.val_->InternalFieldCount();
   }
 
-  /** Gets the value from an internal field. */
-  V8_INLINE Local<Value> GetInternalField(int index);
+  /** Same as above, but works for Persistents */
+  V8_INLINE static int EmbedderFieldCount(
+      const PersistentBase<Object>& object) {
+    return object.val_->EmbedderFieldCount();
+  }
 
-  /** Sets the value in an internal field. */
-  void SetInternalField(int index, Local<Value> value);
+  /** Gets the value from an embedder field. */
+  V8_INLINE Local<Value> V8_DEPRECATE_SOON("use GetEmbedderField",
+                                           GetInternalField(int index));
+
+  /** Gets the value from an embedder field. */
+  V8_INLINE Local<Value> GetEmbedderField(int index);
+
+  /** Sets the value in an embedder field. */
+  void V8_DEPRECATE_SOON("use SetEmbedderField",
+                         SetInternalField(int index, Local<Value> value));
+
+  /** Sets the value in an embedder field. */
+  void SetEmbedderField(int index, Local<Value> value);
 
   /**
-   * Gets a 2-byte-aligned native pointer from an internal field. This field
-   * must have been set by SetAlignedPointerInInternalField, everything else
+   * Gets a 2-byte-aligned native pointer from an embedder field. This field
+   * must have been set by SetAlignedPointerInExternalField, everything else
    * leads to undefined behavior.
    */
-  V8_INLINE void* GetAlignedPointerFromInternalField(int index);
+  V8_INLINE void* V8_DEPRECATE_SOON(
+      "use GetAlignedPointerFromEmbedderField()",
+      GetAlignedPointerFromInternalField(int index));
+  V8_INLINE void* GetAlignedPointerFromEmbedderField(int index);
 
   /** Same as above, but works for Persistents */
-  V8_INLINE static void* GetAlignedPointerFromInternalField(
+  V8_INLINE static void* GetAlignedPointerFromEmbedderField(
       const PersistentBase<Object>& object, int index) {
-    return object.val_->GetAlignedPointerFromInternalField(index);
+    return object.val_->GetAlignedPointerFromEmbedderField(index);
   }
 
+  V8_INLINE static void* V8_DEPRECATE_SOON(
+      "use GetAlignedPointerFromEmbedderField",
+      GetAlignedPointerFromInternalField(const PersistentBase<Object>& object,
+                                         int index)) {
+    return object.val_->GetAlignedPointerFromEmbedderField(index);
+  }
   /**
-   * Sets a 2-byte-aligned native pointer in an internal field. To retrieve such
+   * Sets a 2-byte-aligned native pointer in an embedder field. To retrieve such
    * a field, GetAlignedPointerFromInternalField must be used, everything else
    * leads to undefined behavior.
    */
-  void SetAlignedPointerInInternalField(int index, void* value);
-  void SetAlignedPointerInInternalFields(int argc, int indices[],
+  void V8_DEPRECATE_SOON("use SetAlignedPointerInEmbedderField",
+                         SetAlignedPointerInInternalField(int index,
+                                                          void* value));
+  void V8_DEPRECATE_SOON("use SetAlignedPointerInInternalFields",
+                         SetAlignedPointerInInternalFields(int argc,
+                                                           int indices[],
+                                                           void* values[]));
+  void SetAlignedPointerInEmbedderField(int index, void* value);
+  void SetAlignedPointerInEmbedderFields(int argc, int indices[],
                                          void* values[]);
 
   // Testers for local properties.
   V8_DEPRECATED("Use maybe version", bool HasOwnProperty(Local<String> key));
 
   /**
    * HasOwnProperty() is like JavaScript's Object.prototype.hasOwnProperty().
    *
    * See also v8::Object::Has() and v8::Object::HasRealNamedProperty().
    */
@@ skipping 143 matching lines @@
    */
   V8_DEPRECATE_SOON("Keep track of isolate correctly", Isolate* GetIsolate());
 
   static Local<Object> New(Isolate* isolate);
 
   V8_INLINE static Object* Cast(Value* obj);
 
  private:
   Object();
   static void CheckCast(Value* obj);
-  Local<Value> SlowGetInternalField(int index);
-  void* SlowGetAlignedPointerFromInternalField(int index);
+  Local<Value> SlowGetEmbedderField(int index);
+  void* SlowGetAlignedPointerFromEmbedderField(int index);
 };
 
 
 /**
  * An instance of the built-in array constructor (ECMA-262, 15.4.2).
  */
 class V8_EXPORT Array : public Object {
  public:
   uint32_t Length() const;
 
@@ skipping 598 matching lines @@
   static MaybeLocal<WasmCompiledModule> Deserialize(
       Isolate* isolate, const CallerOwnedBuffer& serialized_module,
       const CallerOwnedBuffer& wire_bytes);
   static MaybeLocal<WasmCompiledModule> Compile(Isolate* isolate,
                                                 const uint8_t* start,
                                                 size_t length);
   WasmCompiledModule();
   static void CheckCast(Value* obj);
 };
 
-#ifndef V8_ARRAY_BUFFER_INTERNAL_FIELD_COUNT
-// The number of required internal fields can be defined by embedder.
-#define V8_ARRAY_BUFFER_INTERNAL_FIELD_COUNT 2
+#ifndef V8_ARRAY_BUFFER_EMBEDDER_FIELD_COUNT
+// The number of required embedder fields for array buffers.
+#define V8_ARRAY_BUFFER_EMBEDDER_FIELD_COUNT 2
 #endif
 
+// TODO(v8): deprecate this constant in favor of {..._EMBEDDER_FIELD_COUNT}
+#ifndef V8_ARRAY_BUFFER_INTERNAL_FIELD_COUNT
+// The number of required embedder fields for array buffers.
+#define V8_ARRAY_BUFFER_INTERNAL_FIELD_COUNT 2
+#else
+#undef V8_ARRAY_BUFFER_EMBEDDER_FIELD_COUNT
+#define V8_ARRAY_BUFFER_EMBEDDER_FIELD_COUNT \
+  V8_ARRAY_BUFFER_INTERNAL_FIELD_COUNT
+#endif
 
 enum class ArrayBufferCreationMode { kInternalized, kExternalized };
 
 
 /**
  * An instance of the built-in ArrayBuffer constructor (ES6 draft 15.13.5).
  */
 class V8_EXPORT ArrayBuffer : public Object {
  public:
   /**
@@ skipping 124 matching lines @@
    *
    * The embedder should make sure to hold a strong reference to the
    * ArrayBuffer while accessing this pointer.
    *
    * The memory block is guaranteed to be allocated with |Allocator::Allocate|.
    */
   Contents GetContents();
 
   V8_INLINE static ArrayBuffer* Cast(Value* obj);
 
-  static const int kInternalFieldCount = V8_ARRAY_BUFFER_INTERNAL_FIELD_COUNT;
+  // TODO(internal)
+  static const int kInternalFieldCount = V8_ARRAY_BUFFER_EMBEDDER_FIELD_COUNT;
+  static const int kEmbedderFieldCount = V8_ARRAY_BUFFER_EMBEDDER_FIELD_COUNT;
 
  private:
   ArrayBuffer();
   static void CheckCast(Value* obj);
 };
 
 
 #ifndef V8_ARRAY_BUFFER_VIEW_INTERNAL_FIELD_COUNT
-// The number of required internal fields can be defined by embedder.
+// The number of required embedder fields can be defined by embedder.
 #define V8_ARRAY_BUFFER_VIEW_INTERNAL_FIELD_COUNT 2
 #endif
 
+// TODO(internal): deprecate this constant in favor of
+// {..._EMBEDDER_FIELD_COUNT}
+#ifndef V8_ARRAY_BUFFER_VIEW_INTERNAL_FIELD_COUNT
+// The number of required embedder fields can be defined by embedder.
+#define V8_ARRAY_BUFFER_VIEW_INTERNAL_FIELD_COUNT 2
+#else
+#undef V8_ARRAY_BUFFER_VIEW_EMBEDDER_FIELD_COUNT
+#define V8_ARRAY_BUFFER_VIEW_EMBEDDER_FIELD_COUNT \
+  V8_ARRAY_BUFFER_VIEW_INTERNAL_FIELD_COUNT
+#endif
 
 /**
  * A base class for an instance of one of "views" over ArrayBuffer,
  * including TypedArrays and DataView (ES6 draft 15.13).
  */
 class V8_EXPORT ArrayBufferView : public Object {
  public:
   /**
    * Returns underlying ArrayBuffer.
    */
@@ skipping 20 matching lines @@
 
   /**
    * Returns true if ArrayBufferView's backing ArrayBuffer has already been
    * allocated.
    */
   bool HasBuffer() const;
 
   V8_INLINE static ArrayBufferView* Cast(Value* obj);
 
   static const int kInternalFieldCount =
-      V8_ARRAY_BUFFER_VIEW_INTERNAL_FIELD_COUNT;
+      V8_ARRAY_BUFFER_VIEW_EMBEDDER_FIELD_COUNT;
+  static const int kEmbedderFieldCount =
+      V8_ARRAY_BUFFER_VIEW_EMBEDDER_FIELD_COUNT;
 
  private:
   ArrayBufferView();
   static void CheckCast(Value* obj);
 };
 
 
 /**
  * A base class for an instance of TypedArray series of constructors
  * (ES6 draft 15.13.6).
@@ skipping 268 matching lines @@
    * ArrayBuffer while accessing this pointer.
    *
    * The memory block is guaranteed to be allocated with |Allocator::Allocate|
    * by the allocator specified in
    * v8::Isolate::CreateParams::array_buffer_allocator.
    */
   Contents GetContents();
 
   V8_INLINE static SharedArrayBuffer* Cast(Value* obj);
 
-  static const int kInternalFieldCount = V8_ARRAY_BUFFER_INTERNAL_FIELD_COUNT;
+  // TODO(internal): deprecate
+  static const int kInternalFieldCount = V8_ARRAY_BUFFER_EMBEDDER_FIELD_COUNT;
+  static const int kEmbedderFieldCount = V8_ARRAY_BUFFER_EMBEDDER_FIELD_COUNT;
 
  private:
   SharedArrayBuffer();
   static void CheckCast(Value* obj);
 };
 
 
 /**
  * An instance of the built-in Date constructor (ECMA-262, 15.9).
  */
@@ skipping 1093 matching lines @@
    * either this method or SetAccessCheckCallback, but not both at the same
    * time.
    */
   void SetAccessCheckCallbackAndHandler(
       AccessCheckCallback callback,
       const NamedPropertyHandlerConfiguration& named_handler,
       const IndexedPropertyHandlerConfiguration& indexed_handler,
       Local<Value> data = Local<Value>());
 
   /**
-   * Gets the number of internal fields for objects generated from
+   * Gets the number of embedder fields for objects generated from
    * this template.
    */
   int InternalFieldCount();
+  int EmbedderFieldCount();
 
   /**
-   * Sets the number of internal fields for objects generated from
+   * Sets the number of embedder fields for objects generated from
    * this template.
    */
   void SetInternalFieldCount(int value);
+  void SetEmbedderFieldCount(int value);
 
   /**
    * Returns true if the object will be an immutable prototype exotic object.
    */
   bool IsImmutableProto();
 
   /**
    * Makes the ObjectTempate for an immutable prototype exotic object, with an
    * immutable __proto__.
    */
@@ skipping 675 matching lines @@
   enum ForceCompletionAction { FORCE_COMPLETION, DO_NOT_FORCE_COMPLETION };
 
   struct AdvanceTracingActions {
     explicit AdvanceTracingActions(ForceCompletionAction force_completion_)
         : force_completion(force_completion_) {}
 
     ForceCompletionAction force_completion;
   };
 
   /**
-   * Called by v8 to register internal fields of found wrappers.
+   * Called by v8 to register embedder fields of found wrappers.
    *
    * The embedder is expected to store them somewhere and trace reachable
    * wrappers from them when called through |AdvanceTracing|.
    */
   virtual void RegisterV8References(
-      const std::vector<std::pair<void*, void*> >& internal_fields) = 0;
+      const std::vector<std::pair<void*, void*> >& embedder_fields) = 0;
 
   /**
    * Called at the beginning of a GC cycle.
    */
   virtual void TracePrologue() = 0;
 
   /**
    * Called to to make a tracing step in the embedder.
    *
    * The embedder is expected to trace its heap starting from wrappers reported
@@ skipping 31 matching lines @@
    * Returns the number of wrappers that are still to be traced by the embedder.
    */
   virtual size_t NumberOfWrappersToTrace() { return 0; }
 
  protected:
   virtual ~EmbedderHeapTracer() = default;
 };
 
 /**
  * Callback and supporting data used in SnapshotCreator to implement embedder
- * logic to serialize internal fields.
+ * logic to serialize embedder fields.
  */
-struct SerializeInternalFieldsCallback {
+class SerializeEmbedderFieldsCallback {
+ public:
   typedef StartupData (*CallbackFunction)(Local<Object> holder, int index,
                                           void* data);
-  SerializeInternalFieldsCallback(CallbackFunction function = nullptr,
+  SerializeEmbedderFieldsCallback(CallbackFunction function = nullptr,
                                   void* data_arg = nullptr)
       : callback(function), data(data_arg) {}
   CallbackFunction callback;
   void* data;
 };
+class SerializeInternalFieldsCallback : public SerializeEmbedderFieldsCallback {
+ public:
+  SerializeInternalFieldsCallback(CallbackFunction function = nullptr,
+                                  void* data_arg = nullptr)
+      : SerializeEmbedderFieldsCallback(function, data_arg) {}
+};
 
 /**
  * Callback and supporting data used to implement embedder logic to deserialize
- * internal fields.
+ * embedder fields.
  */
-struct DeserializeInternalFieldsCallback {
+class DeserializeEmbedderFieldsCallback {
+ public:
   typedef void (*CallbackFunction)(Local<Object> holder, int index,
                                    StartupData payload, void* data);
-  DeserializeInternalFieldsCallback(CallbackFunction function = nullptr,
+  DeserializeEmbedderFieldsCallback(CallbackFunction function = nullptr,
                                     void* data_arg = nullptr)
       : callback(function), data(data_arg) {}
   void (*callback)(Local<Object> holder, int index, StartupData payload,
                    void* data);
   void* data;
 };
+class DeserializeInternalFieldsCallback
+    : public DeserializeEmbedderFieldsCallback {
+ public:
+  DeserializeInternalFieldsCallback(CallbackFunction function = nullptr,
+                                    void* data_arg = nullptr)
+      : DeserializeEmbedderFieldsCallback(function, data_arg) {}
+};
 
 /**
  * Isolate represents an isolated instance of the V8 engine.  V8 isolates have
  * completely separate states.  Objects from one isolate must not be used in
  * other isolates.  The embedder can create multiple isolates and use them in
  * parallel in multiple threads.  An isolate can be entered by at most one
  * thread at any given time.  The Locker/Unlocker API must be used to
  * synchronize.
  */
 class V8_EXPORT Isolate {
@@ skipping 1298 matching lines @@
 
   static internal::Object** GlobalizeReference(internal::Isolate* isolate,
                                                internal::Object** handle);
   static internal::Object** CopyPersistent(internal::Object** handle);
   static void DisposeGlobal(internal::Object** global_handle);
   static void MakeWeak(internal::Object** location, void* data,
                        WeakCallbackInfo<void>::Callback weak_callback,
                        WeakCallbackType type);
   static void MakeWeak(internal::Object** location, void* data,
                        // Must be 0 or -1.
-                       int internal_field_index1,
+                       int embedder_field_index1,
                        // Must be 1 or -1.
-                       int internal_field_index2,
+                       int embedder_field_index2,
                        WeakCallbackInfo<void>::Callback weak_callback);
   static void MakeWeak(internal::Object*** location_addr);
   static void* ClearWeak(internal::Object** location);
   static void Eternalize(Isolate* isolate,
                          Value* handle,
                          int* index);
   static Local<Value> GetEternal(Isolate* isolate, int index);
 
   static void RegisterExternallyReferencedObject(internal::Object** object,
                                                  internal::Isolate* isolate);
 
   template <class K, class V, class T>
   friend class PersistentValueMapBase;
 
   static void FromJustIsNothing();
   static void ToLocalEmpty();
-  static void InternalFieldOutOfBounds(int index);
+  static void EmbedderFieldOutOfBounds(int index);
   template <class T> friend class Local;
   template <class T>
   friend class MaybeLocal;
   template <class T>
   friend class Maybe;
   template <class T>
   friend class WeakCallbackInfo;
   template <class T> friend class Eternal;
   template <class T> friend class PersistentBase;
   template <class T, class M> friend class Persistent;
@@ skipping 29 matching lines @@
    * Set the default context to be included in the snapshot blob.
    * The snapshot will not contain the global proxy, and we expect one or a
    * global object template to create one, to be provided upon deserialization.
    */
   void SetDefaultContext(Local<Context> context);
 
   /**
    * Add additional context to be included in the snapshot blob.
    * The snapshot will include the global proxy.
    *
-   * \param callback optional callback to serialize internal fields.
+   * \param callback optional callback to serialize embedder fields.
    *
    * \returns the index of the context in the snapshot blob.
    */
   size_t AddContext(Local<Context> context,
-                    SerializeInternalFieldsCallback callback =
-                        SerializeInternalFieldsCallback());
+                    SerializeEmbedderFieldsCallback callback =
+                        SerializeEmbedderFieldsCallback());
 
   /**
    * Add a template to be included in the snapshot blob.
    * \returns the index of the template in the snapshot blob.
    */
   size_t AddTemplate(Local<Template> template_obj);
 
   /**
    * Created a snapshot data blob.
    * This must not be called from within a handle scope.
@@ skipping 308 matching lines @@
   /**
    * Create a new context from a (non-default) context snapshot. There
    * is no way to provide a global object template since we do not create
    * a new global object from template, but we can reuse a global object.
    *
    * \param isolate See v8::Context::New.
    *
    * \param context_snapshot_index The index of the context snapshot to
    * deserialize from. Use v8::Context::New for the default snapshot.
    *
-   * \param internal_fields_deserializer Optional callback to deserialize
-   * internal fields. It should match the SerializeInternalFieldCallback used
+   * \param embedder_fields_deserializer Optional callback to deserialize
+   * embedder fields. It should match the SerializeInternalFieldCallback used
    * to serialize.
    *
    * \param extensions See v8::Context::New.
    *
    * \param global_object See v8::Context::New.
    */
 
   static MaybeLocal<Context> FromSnapshot(
       Isolate* isolate, size_t context_snapshot_index,
-      DeserializeInternalFieldsCallback internal_fields_deserializer =
-          DeserializeInternalFieldsCallback(),
+      DeserializeEmbedderFieldsCallback embedder_fields_deserializer =
+          DeserializeEmbedderFieldsCallback(),
       ExtensionConfiguration* extensions = nullptr,
       MaybeLocal<Value> global_object = MaybeLocal<Value>());
 
   /**
    * Returns an global object that isn't backed by an actual context.
    *
    * The global template needs to have access checks with handlers installed.
    * If an existing global object is passed in, the global object is detached
    * from its context.
    *
@@ skipping 553 matching lines @@
   return Local<T>(reinterpret_cast<T*>(*V8::GetEternal(isolate, index_)));
 }
 
 
 template <class T>
 Local<T> MaybeLocal<T>::ToLocalChecked() {
   if (V8_UNLIKELY(val_ == nullptr)) V8::ToLocalEmpty();
   return Local<T>(val_);
 }
 
-
+template <class T>
+void* WeakCallbackInfo<T>::GetEmbedderField(int index) const {
+#ifdef V8_ENABLE_CHECKS
+  if (index < 0 || index >= kEmbedderFieldsInWeakCallback) {
+    V8::EmbedderFieldOutOfBounds(index);
+  }
+#endif
+  return embedder_fields_[index];
+}
 template <class T>
 void* WeakCallbackInfo<T>::GetInternalField(int index) const {
-#ifdef V8_ENABLE_CHECKS
-  if (index < 0 || index >= kInternalFieldsInWeakCallback) {
-    V8::InternalFieldOutOfBounds(index);
-  }
-#endif
-  return internal_fields_[index];
+  return WeakCallbackInfo<T>::GetEmbedderField(index);
 }
 
 
 template <class T>
 T* PersistentBase<T>::New(Isolate* isolate, T* that) {
   if (that == NULL) return NULL;
   internal::Object** p = reinterpret_cast<internal::Object**>(that);
   return reinterpret_cast<T*>(
       V8::GlobalizeReference(reinterpret_cast<internal::Isolate*>(isolate),
                              p));
@@ skipping 402 matching lines @@
 Local<Boolean> Boolean::New(Isolate* isolate, bool value) {
   return value ? True(isolate) : False(isolate);
 }
 
 void Template::Set(Isolate* isolate, const char* name, Local<Data> value) {
   Set(String::NewFromUtf8(isolate, name, NewStringType::kInternalized)
           .ToLocalChecked(),
       value);
 }
 
-
-Local<Value> Object::GetInternalField(int index) {
+Local<Value> Object::GetEmbedderField(int index) {
 #ifndef V8_ENABLE_CHECKS
   typedef internal::Object O;
   typedef internal::HeapObject HO;
   typedef internal::Internals I;
   O* obj = *reinterpret_cast<O**>(this);
   // Fast path: If the object is a plain JSObject, which is the common case, we
-  // know where to find the internal fields and can return the value directly.
+  // know where to find the embedder fields and can return the value directly.
   auto instance_type = I::GetInstanceType(obj);
   if (instance_type == I::kJSObjectType ||
       instance_type == I::kJSApiObjectType) {
     int offset = I::kJSObjectHeaderSize + (internal::kApiPointerSize * index);
     O* value = I::ReadField<O*>(obj, offset);
     O** result = HandleScope::CreateHandle(reinterpret_cast<HO*>(obj), value);
     return Local<Value>(reinterpret_cast<Value*>(result));
   }
 #endif
-  return SlowGetInternalField(index);
+  return SlowGetEmbedderField(index);
 }
 
+Local<Value> Object::GetInternalField(int index) {
+  return GetEmbedderField(index);  // non-deprecated method.
+}
 
-void* Object::GetAlignedPointerFromInternalField(int index) {
+void* Object::GetAlignedPointerFromEmbedderField(int index) {
 #ifndef V8_ENABLE_CHECKS
   typedef internal::Object O;
   typedef internal::Internals I;
   O* obj = *reinterpret_cast<O**>(this);
   // Fast path: If the object is a plain JSObject, which is the common case, we
-  // know where to find the internal fields and can return the value directly.
+  // know where to find the embedder fields and can return the value directly.
   auto instance_type = I::GetInstanceType(obj);
   if (V8_LIKELY(instance_type == I::kJSObjectType ||
                 instance_type == I::kJSApiObjectType)) {
     int offset = I::kJSObjectHeaderSize + (internal::kApiPointerSize * index);
     return I::ReadField<void*>(obj, offset);
   }
 #endif
-  return SlowGetAlignedPointerFromInternalField(index);
+  return SlowGetAlignedPointerFromEmbedderField(index);
+}
+
+void* Object::GetAlignedPointerFromInternalField(int index) {
+  return GetAlignedPointerFromEmbedderField(index);  // non-deprecated method.
 }
 
 String* String::Cast(v8::Value* value) {
 #ifdef V8_ENABLE_CHECKS
   CheckCast(value);
 #endif
   return static_cast<String*>(value);
 }
 
 
@@ skipping 700 matching lines @@
  */
 
 
 }  // namespace v8
 
 
 #undef TYPE_CHECK
 
 
 #endif  // INCLUDE_V8_H_