src: avoid deprecated FixedArray::Get

Use the method without context parameter; the old API is deprecated.

Refs: https://crrev.com/c/7141498

Author: backes

src/module_wrap.cc

@@ -96,8 +96,7 @@ std::string ModuleCacheKey::ToString() const {
 }
 
 template <int elements_per_attribute>
-ModuleCacheKey ModuleCacheKey::From(Local<Context> context,
-                                    Local<String> specifier,
+ModuleCacheKey ModuleCacheKey::From(Local<String> specifier,
                                     Local<FixedArray> import_attributes) {
   CHECK_EQ(import_attributes->Length() % elements_per_attribute, 0);
   Isolate* isolate = Isolate::GetCurrent();
@@ -110,12 +109,11 @@ ModuleCacheKey ModuleCacheKey::From(Local<Context> context,
 
   for (int i = 0; i < import_attributes->Length();
        i += elements_per_attribute) {
-    DCHECK(DataIsString(import_attributes->Get(context, i)));
-    DCHECK(DataIsString(import_attributes->Get(context, i + 1)));
+    DCHECK(DataIsString(import_attributes->Get(i)));
+    DCHECK(DataIsString(import_attributes->Get(i + 1)));
 
-    Local<String> v8_key = import_attributes->Get(context, i).As<String>();
-    Local<String> v8_value =
-        import_attributes->Get(context, i + 1).As<String>();
+    Local<String> v8_key = import_attributes->Get(i).As<String>();
+    Local<String> v8_value = import_attributes->Get(i + 1).As<String>();
     Utf8Value key_utf8(isolate, v8_key);
     Utf8Value value_utf8(isolate, v8_value);
 
@@ -132,10 +130,8 @@ ModuleCacheKey ModuleCacheKey::From(Local<Context> context,
   return ModuleCacheKey{utf8_specifier.ToString(), attributes, hash};
 }
 
-ModuleCacheKey ModuleCacheKey::From(Local<Context> context,
-                                    Local<ModuleRequest> v8_request) {
-  return From(
-      context, v8_request->GetSpecifier(), v8_request->GetImportAttributes());
+ModuleCacheKey ModuleCacheKey::From(Local<ModuleRequest> v8_request) {
+  return From(v8_request->GetSpecifier(), v8_request->GetImportAttributes());
 }
 
 ModuleWrap::ModuleWrap(Realm* realm,
@@ -547,8 +543,8 @@ static Local<Object> createImportAttributesContainer(
   LocalVector<Value> values(isolate, num_attributes);
 
   for (int i = 0; i < raw_attributes->Length(); i += elements_per_attribute) {
-    Local<Data> key = raw_attributes->Get(realm->context(), i);
-    Local<Data> value = raw_attributes->Get(realm->context(), i + 1);
+    Local<Data> key = raw_attributes->Get(i);
+    Local<Data> value = raw_attributes->Get(i + 1);
     DCHECK(DataIsString(key));
     DCHECK(DataIsString(value));
 
@@ -571,9 +567,9 @@ static Local<Array> createModuleRequestsContainer(
   LocalVector<Value> requests(isolate, raw_requests->Length());
 
   for (int i = 0; i < raw_requests->Length(); i++) {
-    DCHECK(raw_requests->Get(context, i)->IsModuleRequest());
+    DCHECK(raw_requests->Get(i)->IsModuleRequest());
     Local<ModuleRequest> module_request =
-        raw_requests->Get(realm->context(), i).As<ModuleRequest>();
+        raw_requests->Get(i).As<ModuleRequest>();
 
     Local<String> specifier = module_request->GetSpecifier();
 
@@ -661,8 +657,8 @@ void ModuleWrap::Link(const FunctionCallbackInfo<Value>& args) {
     // TODO(joyeecheung): merge this with the serializeKey() in module_map.js.
     // This currently doesn't sort the import attributes.
     Local<Value> module_value = modules_vector[i].Get(isolate);
-    ModuleCacheKey module_cache_key = ModuleCacheKey::From(
-        context, requests->Get(context, i).As<ModuleRequest>());
+    ModuleCacheKey module_cache_key =
+        ModuleCacheKey::From(requests->Get(i).As<ModuleRequest>());
     auto it = module_request_map.find(module_cache_key);
     if (it == module_request_map.end()) {
       // This is the first request with this identity, record it - any mismatch
@@ -1055,12 +1051,11 @@ MaybeLocal<Object> ModuleWrap::ResolveSourceCallback(
   return module_source_object.As<Object>();
 }
 
-static std::string GetSpecifierFromModuleRequest(Local<Context> context,
-                                                 Local<Module> referrer,
+static std::string GetSpecifierFromModuleRequest(Local<Module> referrer,
                                                  size_t module_request_index) {
   Local<ModuleRequest> raw_request =
       referrer->GetModuleRequests()
-          ->Get(context, static_cast<int>(module_request_index))
+          ->Get(static_cast<int>(module_request_index))
           .As<ModuleRequest>();
   Local<String> specifier = raw_request->GetSpecifier();
   Utf8Value specifier_utf8(Isolate::GetCurrent(), specifier);
@@ -1083,14 +1078,14 @@ Maybe<ModuleWrap*> ModuleWrap::ResolveModule(Local<Context> context,
   ModuleWrap* dependent = ModuleWrap::GetFromModule(env, referrer);
   if (dependent == nullptr) {
     std::string specifier =
-        GetSpecifierFromModuleRequest(context, referrer, module_request_index);
+        GetSpecifierFromModuleRequest(referrer, module_request_index);
     THROW_ERR_VM_MODULE_LINK_FAILURE(
         env, "request for '%s' is from invalid module", specifier);
     return Nothing<ModuleWrap*>();
   }
   if (!dependent->IsLinked()) {
     std::string specifier =
-        GetSpecifierFromModuleRequest(context, referrer, module_request_index);
+        GetSpecifierFromModuleRequest(referrer, module_request_index);
     THROW_ERR_VM_MODULE_LINK_FAILURE(env,
                                      "request for '%s' can not be resolved on "
                                      "module '%s' that is not linked",
@@ -1140,7 +1135,7 @@ static MaybeLocal<Promise> ImportModuleDynamicallyWithPhase(
   // If the host-defined options are empty, get the referrer id symbol
   // from the realm global object.
   if (options->Length() == HostDefinedOptions::kLength) {
-    id = options->Get(context, HostDefinedOptions::kID).As<Symbol>();
+    id = options->Get(HostDefinedOptions::kID).As<Symbol>();
   } else if (!context->Global()
                   ->GetPrivate(context, env->host_defined_option_symbol())
                   .ToLocal(&id)) {

src/module_wrap.h

@@ -63,11 +63,9 @@ struct ModuleCacheKey : public MemoryRetainer {
   std::string ToString() const;
 
   template <int elements_per_attribute = 3>
-  static ModuleCacheKey From(v8::Local<v8::Context> context,
-                             v8::Local<v8::String> specifier,
+  static ModuleCacheKey From(v8::Local<v8::String> specifier,
                              v8::Local<v8::FixedArray> import_attributes);
-  static ModuleCacheKey From(v8::Local<v8::Context> context,
-                             v8::Local<v8::ModuleRequest> v8_request);
+  static ModuleCacheKey From(v8::Local<v8::ModuleRequest> v8_request);
 
   struct Hash {
     std::size_t operator()(const ModuleCacheKey& request) const {

src/node_builtins.cc

@@ -741,7 +741,7 @@ MaybeLocal<Module> BuiltinLoader::LoadBuiltinSourceTextModule(Realm* realm,
   // Pre-fetch all dependencies.
   if (requests->Length() > 0) {
     for (int i = 0; i < requests->Length(); i++) {
-      Local<ModuleRequest> req = requests->Get(context, i).As<ModuleRequest>();
+      Local<ModuleRequest> req = requests->Get(i).As<ModuleRequest>();
       std::string specifier =
           Utf8Value(isolate, req->GetSpecifier()).ToString();
       std::string resolved_id = ResolveRequestForBuiltin(specifier);