Remove V8Call and replace with v8::Maybe<T>::To and v8::MaybeLocal<T>::ToLocal.

third_party/WebKit/Source/modules/csspaint/PaintWorkletGlobalScope.cpp

 // Copyright 2016 The Chromium 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 "modules/csspaint/PaintWorkletGlobalScope.h"
 
 #include "bindings/core/v8/IDLTypes.h"
 #include "bindings/core/v8/NativeValueTraitsImpl.h"
 #include "bindings/core/v8/V8BindingMacros.h"
 #include "bindings/core/v8/WorkerOrWorkletScriptController.h"
@@ skipping 68 matching lines @@
   }
 
   v8::Isolate* isolate = ScriptController()->GetScriptState()->GetIsolate();
   v8::Local<v8::Context> context = ScriptController()->GetContext();
 
   ASSERT(ctor_value.V8Value()->IsFunction());
   v8::Local<v8::Function> constructor =
       v8::Local<v8::Function>::Cast(ctor_value.V8Value());
 
   v8::Local<v8::Value> input_properties_value;
-  if (!V8Call(constructor->Get(context, V8String(isolate, "inputProperties")),
-              input_properties_value))
+  if (!constructor->Get(context, V8String(isolate, "inputProperties"))
+           .ToLocal(&input_properties_value))
     return;
 
   Vector<CSSPropertyID> native_invalidation_properties;
   Vector<AtomicString> custom_invalidation_properties;
 
   if (!IsUndefinedOrNull(input_properties_value)) {
     Vector<String> properties =
         NativeValueTraits<IDLSequence<IDLString>>::NativeValue(
             isolate, input_properties_value, exception_state);
 
     if (exception_state.HadException())
       return;
 
     for (const auto& property : properties) {
       CSSPropertyID property_id = cssPropertyID(property);
       if (property_id == CSSPropertyVariable) {
         custom_invalidation_properties.push_back(property);
       } else if (property_id != CSSPropertyInvalid) {
         native_invalidation_properties.push_back(property_id);
       }
     }
   }
 
   // Get input argument types. Parse the argument type values only when
   // cssPaintAPIArguments is enabled.
   Vector<CSSSyntaxDescriptor> input_argument_types;
   if (RuntimeEnabledFeatures::cssPaintAPIArgumentsEnabled()) {
     v8::Local<v8::Value> input_argument_type_values;
-    if (!V8Call(constructor->Get(context, V8String(isolate, "inputArguments")),
-                input_argument_type_values))
+    if (!constructor->Get(context, V8String(isolate, "inputArguments"))
+             .ToLocal(&input_argument_type_values))
       return;
 
     if (!IsUndefinedOrNull(input_argument_type_values)) {
       Vector<String> argument_types =
           NativeValueTraits<IDLSequence<IDLString>>::NativeValue(
               isolate, input_argument_type_values, exception_state);
 
       if (exception_state.HadException())
         return;
 
       for (const auto& type : argument_types) {
         CSSSyntaxDescriptor syntax_descriptor(type);
         if (!syntax_descriptor.IsValid()) {
           exception_state.ThrowTypeError("Invalid argument types.");
           return;
         }
         input_argument_types.push_back(syntax_descriptor);
       }
     }
   }
 
   // Parse 'alpha' AKA hasAlpha property.
   v8::Local<v8::Value> alpha_value;
-  if (!V8Call(constructor->Get(context, V8String(isolate, "alpha")),
-              alpha_value))
+  if (!constructor->Get(context, V8String(isolate, "alpha"))
+           .ToLocal(&alpha_value))
     return;
   if (!IsUndefinedOrNull(alpha_value) && !alpha_value->IsBoolean()) {
     exception_state.ThrowTypeError(
         "The 'alpha' property on the class is not a boolean.");
     return;
   }
   bool has_alpha = alpha_value->IsBoolean()
                        ? v8::Local<v8::Boolean>::Cast(alpha_value)->Value()
                        : true;
 
   v8::Local<v8::Value> prototype_value;
-  if (!V8Call(constructor->Get(context, V8String(isolate, "prototype")),
-              prototype_value))
+  if (!constructor->Get(context, V8String(isolate, "prototype"))
+           .ToLocal(&prototype_value))
     return;
 
   if (IsUndefinedOrNull(prototype_value)) {
     exception_state.ThrowTypeError(
         "The 'prototype' object on the class does not exist.");
     return;
   }
 
   if (!prototype_value->IsObject()) {
     exception_state.ThrowTypeError(
         "The 'prototype' property on the class is not an object.");
     return;
   }
 
   v8::Local<v8::Object> prototype =
       v8::Local<v8::Object>::Cast(prototype_value);
 
   v8::Local<v8::Value> paint_value;
-  if (!V8Call(prototype->Get(context, V8String(isolate, "paint")), paint_value))
+  if (!prototype->Get(context, V8String(isolate, "paint"))
+           .ToLocal(&paint_value))
     return;
 
   if (IsUndefinedOrNull(paint_value)) {
     exception_state.ThrowTypeError(
         "The 'paint' function on the prototype does not exist.");
     return;
   }
 
   if (!paint_value->IsFunction()) {
     exception_state.ThrowTypeError(
@@ skipping 36 matching lines @@
   set->insert(generator);
 }
 
 DEFINE_TRACE(PaintWorkletGlobalScope) {
   visitor->Trace(paint_definitions_);
   visitor->Trace(pending_generators_);
   MainThreadWorkletGlobalScope::Trace(visitor);
 }
 
 }  // namespace blink