[rename] Rename internal field to embedder field.

src/d8.cc

 // 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.
 
 #include <errno.h>
 #include <stdlib.h>
 #include <string.h>
 #include <sys/stat.h>
 
 #include <algorithm>
@@ skipping 208 matching lines @@
 
 
 v8::Platform* g_platform = NULL;
 
 static Local<Value> Throw(Isolate* isolate, const char* message) {
   return isolate->ThrowException(
       String::NewFromUtf8(isolate, message, NewStringType::kNormal)
           .ToLocalChecked());
 }
 
-
-Worker* GetWorkerFromInternalField(Isolate* isolate, Local<Object> object) {
-  if (object->InternalFieldCount() != 1) {
+Worker* GetWorkerFromEmbedderField(Isolate* isolate, Local<Object> object) {
+  if (object->EmbedderFieldCount() != 1) {
     Throw(isolate, "this is not a Worker");
     return NULL;
   }
 
   Worker* worker =
-      static_cast<Worker*>(object->GetAlignedPointerFromInternalField(0));
+      static_cast<Worker*>(object->GetAlignedPointerFromEmbedderField(0));
   if (worker == NULL) {
     Throw(isolate, "Worker is defunct because main thread is terminating");
     return NULL;
   }
 
   return worker;
 }
 
 
 }  // namespace
@@ skipping 892 matching lines @@
     return;
   }
 
   {
     base::LockGuard<base::Mutex> lock_guard(workers_mutex_.Pointer());
     if (workers_.length() >= kMaxWorkers) {
       Throw(args.GetIsolate(), "Too many workers, I won't let you create more");
       return;
     }
 
-    // Initialize the internal field to NULL; if we return early without
+    // Initialize the embedder field to NULL; if we return early without
     // creating a new Worker (because the main thread is terminating) we can
     // early-out from the instance calls.
-    args.Holder()->SetAlignedPointerInInternalField(0, NULL);
+    args.Holder()->SetAlignedPointerInEmbedderField(0, NULL);
 
     if (!allow_new_workers_) return;
 
     Worker* worker = new Worker;
-    args.Holder()->SetAlignedPointerInInternalField(0, worker);
+    args.Holder()->SetAlignedPointerInEmbedderField(0, worker);
     workers_.Add(worker);
 
     String::Utf8Value script(args[0]);
     if (!*script) {
       Throw(args.GetIsolate(), "Can't get worker script");
       return;
     }
     worker->StartExecuteInThread(*script);
   }
 }
 
 
 void Shell::WorkerPostMessage(const v8::FunctionCallbackInfo<v8::Value>& args) {
   Isolate* isolate = args.GetIsolate();
   HandleScope handle_scope(isolate);
 
   if (args.Length() < 1) {
     Throw(isolate, "Invalid argument");
     return;
   }
 
-  Worker* worker = GetWorkerFromInternalField(isolate, args.Holder());
+  Worker* worker = GetWorkerFromEmbedderField(isolate, args.Holder());
   if (!worker) {
     return;
   }
 
   Local<Value> message = args[0];
   Local<Value> transfer =
       args.Length() >= 2 ? args[1] : Local<Value>::Cast(Undefined(isolate));
   std::unique_ptr<SerializationData> data =
       Shell::SerializeValue(isolate, message, transfer);
   if (data) {
     worker->PostMessage(std::move(data));
   }
 }
 
 
 void Shell::WorkerGetMessage(const v8::FunctionCallbackInfo<v8::Value>& args) {
   Isolate* isolate = args.GetIsolate();
   HandleScope handle_scope(isolate);
-  Worker* worker = GetWorkerFromInternalField(isolate, args.Holder());
+  Worker* worker = GetWorkerFromEmbedderField(isolate, args.Holder());
   if (!worker) {
     return;
   }
 
   std::unique_ptr<SerializationData> data = worker->GetMessage();
   if (data) {
     Local<Value> value;
     if (Shell::DeserializeValue(isolate, std::move(data)).ToLocal(&value)) {
       args.GetReturnValue().Set(value);
     }
   }
 }
 
 
 void Shell::WorkerTerminate(const v8::FunctionCallbackInfo<v8::Value>& args) {
   Isolate* isolate = args.GetIsolate();
   HandleScope handle_scope(isolate);
-  Worker* worker = GetWorkerFromInternalField(isolate, args.Holder());
+  Worker* worker = GetWorkerFromEmbedderField(isolate, args.Holder());
   if (!worker) {
     return;
   }
 
   worker->Terminate();
 }
 
 
 void Shell::QuitOnce(v8::FunctionCallbackInfo<v8::Value>* args) {
   int exit_code = (*args)[0]
@@ skipping 331 matching lines @@
   worker_fun_template->PrototypeTemplate()->Set(
       String::NewFromUtf8(isolate, "postMessage", NewStringType::kNormal)
           .ToLocalChecked(),
       FunctionTemplate::New(isolate, WorkerPostMessage, Local<Value>(),
                             worker_signature));
   worker_fun_template->PrototypeTemplate()->Set(
       String::NewFromUtf8(isolate, "getMessage", NewStringType::kNormal)
           .ToLocalChecked(),
       FunctionTemplate::New(isolate, WorkerGetMessage, Local<Value>(),
                             worker_signature));
-  worker_fun_template->InstanceTemplate()->SetInternalFieldCount(1);
+  worker_fun_template->InstanceTemplate()->SetEmbedderFieldCount(1);
   global_template->Set(
       String::NewFromUtf8(isolate, "Worker", NewStringType::kNormal)
           .ToLocalChecked(),
       worker_fun_template);
 
   Local<ObjectTemplate> os_templ = ObjectTemplate::New(isolate);
   AddOSMethods(isolate, os_templ);
   global_template->Set(
       String::NewFromUtf8(isolate, "os", NewStringType::kNormal)
           .ToLocalChecked(),
@@ skipping 1455 matching lines @@
 }
 
 }  // namespace v8
 
 
 #ifndef GOOGLE3
 int main(int argc, char* argv[]) {
   return v8::Shell::Main(argc, argv);
 }
 #endif