[rename] Rename internal field to embedder field.

samples/process.cc

 // Copyright 2012 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 327 matching lines @@
 
   // Create an empty map wrapper.
   Local<Object> result =
       templ->NewInstance(GetIsolate()->GetCurrentContext()).ToLocalChecked();
 
   // Wrap the raw C++ pointer in an External so it can be referenced
   // from within JavaScript.
   Local<External> map_ptr = External::New(GetIsolate(), obj);
 
   // Store the map pointer in the JavaScript wrapper.
-  result->SetInternalField(0, map_ptr);
+  result->SetEmbedderField(0, map_ptr);
 
   // Return the result through the current handle scope.  Since each
   // of these handles will go away when the handle scope is deleted
   // we need to call Close to let one, the result, escape into the
   // outer handle scope.
   return handle_scope.Escape(result);
 }
 
 
 // Utility function that extracts the C++ map pointer from a wrapper
 // object.
 map<string, string>* JsHttpRequestProcessor::UnwrapMap(Local<Object> obj) {
-  Local<External> field = Local<External>::Cast(obj->GetInternalField(0));
+  Local<External> field = Local<External>::Cast(obj->GetEmbedderField(0));
   void* ptr = field->Value();
   return static_cast<map<string, string>*>(ptr);
 }
 
 
 // Convert a JavaScript string to a std::string.  To not bother too
 // much with string encodings we just use ascii.
 string ObjectToString(Local<Value> value) {
   String::Utf8Value utf8_value(value);
   return string(*utf8_value);
@@ skipping 42 matching lines @@
   // Return the value; any non-empty handle will work.
   info.GetReturnValue().Set(value_obj);
 }
 
 
 Local<ObjectTemplate> JsHttpRequestProcessor::MakeMapTemplate(
     Isolate* isolate) {
   EscapableHandleScope handle_scope(isolate);
 
   Local<ObjectTemplate> result = ObjectTemplate::New(isolate);
-  result->SetInternalFieldCount(1);
+  result->SetEmbedderFieldCount(1);
   result->SetHandler(NamedPropertyHandlerConfiguration(MapGet, MapSet));
 
   // Again, return the result through the current handle scope.
   return handle_scope.Escape(result);
 }
 
 
 // -------------------------------------------
 // --- A c c e s s i n g   R e q u e s t s ---
 // -------------------------------------------
@@ skipping 17 matching lines @@
 
   // Create an empty http request wrapper.
   Local<Object> result =
       templ->NewInstance(GetIsolate()->GetCurrentContext()).ToLocalChecked();
 
   // Wrap the raw C++ pointer in an External so it can be referenced
   // from within JavaScript.
   Local<External> request_ptr = External::New(GetIsolate(), request);
 
   // Store the request pointer in the JavaScript wrapper.
-  result->SetInternalField(0, request_ptr);
+  result->SetEmbedderField(0, request_ptr);
 
   // Return the result through the current handle scope.  Since each
   // of these handles will go away when the handle scope is deleted
   // we need to call Close to let one, the result, escape into the
   // outer handle scope.
   return handle_scope.Escape(result);
 }
 
 
 /**
  * Utility function that extracts the C++ http request object from a
  * wrapper object.
  */
 HttpRequest* JsHttpRequestProcessor::UnwrapRequest(Local<Object> obj) {
-  Local<External> field = Local<External>::Cast(obj->GetInternalField(0));
+  Local<External> field = Local<External>::Cast(obj->GetEmbedderField(0));
   void* ptr = field->Value();
   return static_cast<HttpRequest*>(ptr);
 }
 
 
 void JsHttpRequestProcessor::GetPath(Local<String> name,
                                      const PropertyCallbackInfo<Value>& info) {
   // Extract the C++ request object from the JavaScript wrapper.
   HttpRequest* request = UnwrapRequest(info.Holder());
 
@@ skipping 41 matching lines @@
                           NewStringType::kNormal,
                           static_cast<int>(path.length())).ToLocalChecked());
 }
 
 
 Local<ObjectTemplate> JsHttpRequestProcessor::MakeRequestTemplate(
     Isolate* isolate) {
   EscapableHandleScope handle_scope(isolate);
 
   Local<ObjectTemplate> result = ObjectTemplate::New(isolate);
-  result->SetInternalFieldCount(1);
+  result->SetEmbedderFieldCount(1);
 
   // Add accessors for each of the fields of the request.
   result->SetAccessor(
       String::NewFromUtf8(isolate, "path", NewStringType::kInternalized)
           .ToLocalChecked(),
       GetPath);
   result->SetAccessor(
       String::NewFromUtf8(isolate, "referrer", NewStringType::kInternalized)
           .ToLocalChecked(),
       GetReferrer);
@@ skipping 152 matching lines @@
   JsHttpRequestProcessor processor(isolate, source);
   map<string, string> output;
   if (!processor.Initialize(&options, &output)) {
     fprintf(stderr, "Error initializing processor.\n");
     return 1;
   }
   if (!ProcessEntries(platform, &processor, kSampleSize, kSampleRequests))
     return 1;
   PrintMap(&output);
 }