[rename] Rename internal field to embedder field.

src/builtins/builtins-typedarray.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/builtins/builtins-utils.h"
 #include "src/builtins/builtins.h"
 #include "src/code-stub-assembler.h"
 #include "src/counters.h"
 #include "src/elements.h"
 #include "src/objects-inl.h"
@@ skipping 128 matching lines @@
   CSA_ASSERT(this, TaggedIsSmi(byte_length));
   Goto(&setup_holder);
 
   Bind(&setup_holder);
   {
     LoadMapAndElementsSize(holder, &fixed_typed_map, &element_size);
     // Setup the holder (JSArrayBufferView).
     //  - Set the length.
     //  - Set the byte_offset.
     //  - Set the byte_length.
-    //  - Set InternalFields to 0.
+    //  - Set EmbedderFields to 0.
     StoreObjectField(holder, JSTypedArray::kLengthOffset, length);
     StoreObjectField(holder, JSArrayBufferView::kByteOffsetOffset, byte_offset);
     StoreObjectField(holder, JSArrayBufferView::kByteLengthOffset, byte_length);
     for (int offset = JSTypedArray::kSize;
-         offset < JSTypedArray::kSizeWithInternalFields;
+         offset < JSTypedArray::kSizeWithEmbedderFields;
          offset += kPointerSize) {
       StoreObjectField(holder, offset, SmiConstant(Smi::kZero));
     }
 
     Branch(IsNull(maybe_buffer), &alloc_array_buffer, &attach_buffer);
   }
 
   Bind(&alloc_array_buffer);
   {
     // Allocate a new ArrayBuffer and initialize it with empty properties and
     // elements.
     Node* const native_context = LoadNativeContext(context);
     Node* const map =
         LoadContextElement(native_context, Context::ARRAY_BUFFER_MAP_INDEX);
     Node* empty_fixed_array = LoadRoot(Heap::kEmptyFixedArrayRootIndex);
 
-    Node* const buffer = Allocate(JSArrayBuffer::kSizeWithInternalFields);
+    Node* const buffer = Allocate(JSArrayBuffer::kSizeWithEmbedderFields);
     StoreMapNoWriteBarrier(buffer, map);
     StoreObjectFieldNoWriteBarrier(buffer, JSArray::kPropertiesOffset,
                                    empty_fixed_array);
     StoreObjectFieldNoWriteBarrier(buffer, JSArray::kElementsOffset,
                                    empty_fixed_array);
     // Setup the ArrayBuffer.
     //  - Set BitField to 0.
     //  - Set IsExternal and IsNeuterable bits of BitFieldSlot.
     //  - Set the byte_length field to byte_length.
     //  - Set backing_store to null/Smi(0).
-    //  - Set all internal fields to Smi(0).
+    //  - Set all embedder fields to Smi(0).
     StoreObjectFieldNoWriteBarrier(buffer, JSArrayBuffer::kBitFieldSlot,
                                    SmiConstant(Smi::kZero));
     int32_t bitfield_value = (1 << JSArrayBuffer::IsExternal::kShift) |
                              (1 << JSArrayBuffer::IsNeuterable::kShift);
     StoreObjectFieldNoWriteBarrier(buffer, JSArrayBuffer::kBitFieldOffset,
                                    Int32Constant(bitfield_value),
                                    MachineRepresentation::kWord32);
 
     StoreObjectFieldNoWriteBarrier(buffer, JSArrayBuffer::kByteLengthOffset,
                                    byte_length);
     StoreObjectFieldNoWriteBarrier(buffer, JSArrayBuffer::kBackingStoreOffset,
                                    SmiConstant(Smi::kZero));
-    for (int i = 0; i < v8::ArrayBuffer::kInternalFieldCount; i++) {
+    for (int i = 0; i < v8::ArrayBuffer::kEmbedderFieldCount; i++) {
       int offset = JSArrayBuffer::kSize + i * kPointerSize;
       StoreObjectFieldNoWriteBarrier(buffer, offset, SmiConstant(Smi::kZero));
     }
 
     StoreObjectField(holder, JSArrayBufferView::kBufferOffset, buffer);
 
     // Check the alignment.
     GotoIf(SmiEqual(SmiMod(element_size.value(), SmiConstant(kObjectAlignment)),
                     SmiConstant(0)),
            &aligned);
@@ skipping 529 matching lines @@
   ElementsAccessor* elements = array->GetElementsAccessor();
   Maybe<int64_t> result = elements->IndexOfValue(isolate, array, search_element,
                                                  static_cast<uint32_t>(index),
                                                  static_cast<uint32_t>(len));
   MAYBE_RETURN(result, isolate->heap()->exception());
   return *isolate->factory()->NewNumberFromInt64(result.FromJust());
 }
 
 }  // namespace internal
 }  // namespace v8