src: elevate v8 namespaces referenced

PR-URL: nodejs#24657
Reviewed-By: Colin Ihrig <cjihrig@gmail.com>
Reviewed-By: Luigi Pinca <luigipinca@gmail.com>
Reviewed-By: Gireesh Punathil <gpunathi@in.ibm.com>
Reviewed-By: Minwoo Jung <minwoo@nodesource.com>
Reviewed-By: Franziska Hinkelmann <franziska.hinkelmann@gmail.com>

Author: juanarbol

src/async_wrap.cc

@@ -30,6 +30,8 @@
 #include "v8-profiler.h"
 
 using v8::Context;
+using v8::DontDelete;
+using v8::EscapableHandleScope;
 using v8::Function;
 using v8::FunctionCallbackInfo;
 using v8::FunctionTemplate;
@@ -38,16 +40,22 @@ using v8::Integer;
 using v8::Isolate;
 using v8::Local;
 using v8::MaybeLocal;
+using v8::NewStringType;
 using v8::Number;
 using v8::Object;
 using v8::ObjectTemplate;
 using v8::Promise;
 using v8::PromiseHookType;
+using v8::PropertyAttribute;
 using v8::PropertyCallbackInfo;
+using v8::ReadOnly;
 using v8::String;
+using v8::TryCatch;
 using v8::Uint32;
 using v8::Undefined;
 using v8::Value;
+using v8::WeakCallbackInfo;
+using v8::WeakCallbackType;
 
 using AsyncHooks = node::Environment::AsyncHooks;
 
@@ -117,7 +125,7 @@ void Emit(Environment* env, double async_id, AsyncHooks::Fields type,
   if (async_hooks->fields()[type] == 0 || !env->can_call_into_js())
     return;
 
-  v8::HandleScope handle_scope(env->isolate());
+  HandleScope handle_scope(env->isolate());
   Local<Value> async_id_value = Number::New(env->isolate(), async_id);
   FatalTryCatch try_catch(env);
   USE(fn->Call(env->context(), Undefined(env->isolate()), 1, &async_id_value));
@@ -341,8 +349,7 @@ class DestroyParam {
   Persistent<Object> propBag;
 };
 
-
-void AsyncWrap::WeakCallback(const v8::WeakCallbackInfo<DestroyParam>& info) {
+void AsyncWrap::WeakCallback(const WeakCallbackInfo<DestroyParam>& info) {
   HandleScope scope(info.GetIsolate());
 
   std::unique_ptr<DestroyParam> p{info.GetParameter()};
@@ -373,8 +380,7 @@ static void RegisterDestroyHook(const FunctionCallbackInfo<Value>& args) {
   p->env = Environment::GetCurrent(args);
   p->target.Reset(isolate, args[0].As<Object>());
   p->propBag.Reset(isolate, args[2].As<Object>());
-  p->target.SetWeak(
-    p, AsyncWrap::WeakCallback, v8::WeakCallbackType::kParameter);
+  p->target.SetWeak(p, AsyncWrap::WeakCallback, WeakCallbackType::kParameter);
 }
 
 
@@ -448,8 +454,8 @@ void AsyncWrap::Initialize(Local<Object> target,
   env->SetMethod(target, "disablePromiseHook", DisablePromiseHook);
   env->SetMethod(target, "registerDestroyHook", RegisterDestroyHook);
 
-  v8::PropertyAttribute ReadOnlyDontDelete =
-      static_cast<v8::PropertyAttribute>(v8::ReadOnly | v8::DontDelete);
+  PropertyAttribute ReadOnlyDontDelete =
+      static_cast<PropertyAttribute>(ReadOnly | DontDelete);
 
 #define FORCE_SET_TARGET_FIELD(obj, str, field)                               \
   (obj)->DefineOwnProperty(context,                                           \
@@ -695,7 +701,7 @@ MaybeLocal<Value> AsyncWrap::MakeCallback(const Local<Function> cb,
 
 async_id AsyncHooksGetExecutionAsyncId(Isolate* isolate) {
   // Environment::GetCurrent() allocates a Local<> handle.
-  v8::HandleScope handle_scope(isolate);
+  HandleScope handle_scope(isolate);
   Environment* env = Environment::GetCurrent(isolate);
   if (env == nullptr) return -1;
   return env->execution_async_id();
@@ -704,7 +710,7 @@ async_id AsyncHooksGetExecutionAsyncId(Isolate* isolate) {
 
 async_id AsyncHooksGetTriggerAsyncId(Isolate* isolate) {
   // Environment::GetCurrent() allocates a Local<> handle.
-  v8::HandleScope handle_scope(isolate);
+  HandleScope handle_scope(isolate);
   Environment* env = Environment::GetCurrent(isolate);
   if (env == nullptr) return -1;
   return env->trigger_async_id();
@@ -715,18 +721,18 @@ async_context EmitAsyncInit(Isolate* isolate,
                             Local<Object> resource,
                             const char* name,
                             async_id trigger_async_id) {
-  v8::HandleScope handle_scope(isolate);
+  HandleScope handle_scope(isolate);
   Local<String> type =
-      String::NewFromUtf8(isolate, name, v8::NewStringType::kInternalized)
+      String::NewFromUtf8(isolate, name, NewStringType::kInternalized)
           .ToLocalChecked();
   return EmitAsyncInit(isolate, resource, type, trigger_async_id);
 }
 
 async_context EmitAsyncInit(Isolate* isolate,
                             Local<Object> resource,
-                            v8::Local<v8::String> name,
+                            Local<String> name,
                             async_id trigger_async_id) {
-  v8::HandleScope handle_scope(isolate);
+  HandleScope handle_scope(isolate);
   Environment* env = Environment::GetCurrent(isolate);
   CHECK_NOT_NULL(env);
 
@@ -748,7 +754,7 @@ async_context EmitAsyncInit(Isolate* isolate,
 
 void EmitAsyncDestroy(Isolate* isolate, async_context asyncContext) {
   // Environment::GetCurrent() allocates a Local<> handle.
-  v8::HandleScope handle_scope(isolate);
+  HandleScope handle_scope(isolate);
   AsyncWrap::EmitDestroy(
       Environment::GetCurrent(isolate), asyncContext.async_id);
 }
@@ -767,10 +773,10 @@ Local<Object> AsyncWrap::GetOwner() {
 }
 
 Local<Object> AsyncWrap::GetOwner(Environment* env, Local<Object> obj) {
-  v8::EscapableHandleScope handle_scope(env->isolate());
+  EscapableHandleScope handle_scope(env->isolate());
   CHECK(!obj.IsEmpty());
 
-  v8::TryCatch ignore_exceptions(env->isolate());
+  TryCatch ignore_exceptions(env->isolate());
   while (true) {
     Local<Value> owner;
     if (!obj->Get(env->context(),