[rename] Rename internal field to embedder field.

src/global-handles.h

 // Copyright 2011 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.
 
 #ifndef V8_GLOBAL_HANDLES_H_
 #define V8_GLOBAL_HANDLES_H_
 
 #include "include/v8.h"
 #include "include/v8-profiler.h"
 
@@ skipping 10 matching lines @@
 // Structure for tracking global handles.
 // A single list keeps all the allocated global handles.
 // Destroyed handles stay in the list but is added to the free list.
 // At GC the destroyed global handles are removed from the free list
 // and deallocated.
 
 enum WeaknessType {
   // Embedder gets a handle to the dying object.
   FINALIZER_WEAK,
   // In the following cases, the embedder gets the parameter they passed in
-  // earlier, and 0 or 2 first internal fields. Note that the internal
+  // earlier, and 0 or 2 first embedder fields. Note that the internal
   // fields must contain aligned non-V8 pointers.  Getting pointers to V8
   // objects through this interface would be GC unsafe so in that case the
   // embedder gets a null pointer instead.
   PHANTOM_WEAK,
-  PHANTOM_WEAK_2_INTERNAL_FIELDS,
+  PHANTOM_WEAK_2_EMBEDDER_FIELDS,
   // The handle is automatically reset by the garbage collector when
   // the object is no longer reachable.
   PHANTOM_WEAK_RESET_HANDLE
 };
 
 class GlobalHandles {
  public:
   enum IterationMode {
     HANDLE_PHANTOM_NODES_VISIT_OTHERS,
     VISIT_OTHERS,
@@ skipping 178 matching lines @@
 
   DISALLOW_COPY_AND_ASSIGN(GlobalHandles);
 };
 
 
 class GlobalHandles::PendingPhantomCallback {
  public:
   typedef v8::WeakCallbackInfo<void> Data;
   PendingPhantomCallback(
       Node* node, Data::Callback callback, void* parameter,
-      void* internal_fields[v8::kInternalFieldsInWeakCallback])
+      void* embedder_fields[v8::kEmbedderFieldsInWeakCallback])
       : node_(node), callback_(callback), parameter_(parameter) {
-    for (int i = 0; i < v8::kInternalFieldsInWeakCallback; ++i) {
-      internal_fields_[i] = internal_fields[i];
+    for (int i = 0; i < v8::kEmbedderFieldsInWeakCallback; ++i) {
+      embedder_fields_[i] = embedder_fields[i];
     }
   }
 
   void Invoke(Isolate* isolate);
 
   Node* node() { return node_; }
   Data::Callback callback() { return callback_; }
 
  private:
   Node* node_;
   Data::Callback callback_;
   void* parameter_;
-  void* internal_fields_[v8::kInternalFieldsInWeakCallback];
+  void* embedder_fields_[v8::kEmbedderFieldsInWeakCallback];
 };
 
 
 class EternalHandles {
  public:
   enum SingletonHandle {
     DATE_CACHE_VERSION,
 
     NUMBER_OF_SINGLETON_HANDLES
   };
@@ skipping 55 matching lines @@
   int singleton_handles_[NUMBER_OF_SINGLETON_HANDLES];
 
   DISALLOW_COPY_AND_ASSIGN(EternalHandles);
 };
 
 
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_GLOBAL_HANDLES_H_