ABANDONED CL: Changes to compile and pass tests after Big Blink Rename (excluding functions).

third_party/WebKit/Source/bindings/templates/methods.cpp.tmpl

 {% from 'utilities.cpp.tmpl' import declare_enum_validation_variable, v8_value_to_local_cpp_value %}
 
 {##############################################################################}
 {% macro generate_method(method, world_suffix) %}
 static void {{method.name}}{{method.overload_index}}Method{{world_suffix}}(const v8::FunctionCallbackInfo<v8::Value>& info) {
   {% filter format_remove_duplicates([
       'ExceptionState exceptionState',
       'ScriptState* scriptState = ']) %}
   {% set define_exception_state -%}
-  ExceptionState exceptionState(info.GetIsolate(), ExceptionState::ExecutionContext, "{{interface_name}}", "{{method.name}}");
+  ExceptionState exceptionState(info.GetIsolate(), ExceptionState::kExecutionContext, "{{interface_name}}", "{{method.name}}");
   {%- endset %}
 
   {% set function_call = func_call_with_prep_of_args(method, world_suffix) %}
 
   {% if 'exceptionState' in function_call or
         (method.returns_promise and not method.is_static) %}
   {{define_exception_state}}
   {% if method.returns_promise %}
   ExceptionToRejectPromiseScope rejectPromiseScope(info, exceptionState);
   {% endif %}
   {% endif %}
 
   {% if not method.is_static %}
   {% if method.returns_promise %}
-  // V8DOMConfiguration::DoNotCheckHolder
+  // V8DOMConfiguration::kDoNotCheckHolder
   // Make sure that info.Holder() really points to an instance of the type.
   if (!{{v8_class}}::hasInstance(info.Holder(), info.GetIsolate())) {
     {{throw_type_error(method, '"Illegal invocation"')}}
     return;
   }
   {% endif %}
   {{cpp_class}}* impl = {{v8_class}}::toImpl(info.Holder());
   {% endif %}
 
   {# Security checks #}
@@ skipping 108 matching lines @@
   {% else %}
   {{cpp_method_call(method, argument.v8_set_return_value, argument.cpp_value) | indent(2)}}
   {% endif %}
   return;
 }
 {% endif %}
 {% if argument.is_callback_interface %}
 {# FIXME: remove EventListener special case #}
 {% if argument.idl_type == 'EventListener' %}
 {% if method.name == 'removeEventListener' or method.name == 'removeListener' %}
-{{argument.name}} = V8EventListenerHelper::getEventListener(ScriptState::current(info.GetIsolate()), info[{{argument.index}}], false, ListenerFindOnly);
+{{argument.name}} = V8EventListenerHelper::getEventListener(ScriptState::current(info.GetIsolate()), info[{{argument.index}}], false, kListenerFindOnly);
 {% else %}{# method.name == 'addEventListener' #}
-{{argument.name}} = V8EventListenerHelper::getEventListener(ScriptState::current(info.GetIsolate()), info[{{argument.index}}], false, ListenerFindOrCreate);
+{{argument.name}} = V8EventListenerHelper::getEventListener(ScriptState::current(info.GetIsolate()), info[{{argument.index}}], false, kListenerFindOrCreate);
 {% endif %}{# method.name #}
 {% else %}{# argument.idl_type == 'EventListener' #}
 {# Callback functions must be functions:
    http://www.w3.org/TR/WebIDL/#es-callback-function #}
 {% if argument.is_optional %}
 if (!isUndefinedOrNull(info[{{argument.index}}])) {
   if (!info[{{argument.index}}]->IsFunction()) {
     {{throw_argument_error(method, argument, "The callback provided as parameter %(index)d is not a function.")}}
     return;
   }
@@ skipping 175 matching lines @@
 }
 {% endmacro %}
 
 
 {##############################################################################}
 {% macro overload_resolution_method(overloads, world_suffix) %}
 static void {{overloads.name}}Method{{world_suffix}}(const v8::FunctionCallbackInfo<v8::Value>& info) {
   {% set fall_through_to_partial_overloads = not is_partial and overloads.has_partial_overloads %}
 
   {% if overloads.measure_all_as %}
-  UseCounter::count(currentExecutionContext(info.GetIsolate()), UseCounter::{{overloads.measure_all_as}});
+  UseCounter::count(currentExecutionContext(info.GetIsolate()), UseCounter::k{{overloads.measure_all_as}});
   {% endif %}
   {% if overloads.deprecate_all_as %}
-  Deprecation::countDeprecation(currentExecutionContext(info.GetIsolate()), UseCounter::{{overloads.deprecate_all_as}});
+  Deprecation::countDeprecation(currentExecutionContext(info.GetIsolate()), UseCounter::k{{overloads.deprecate_all_as}});
   {% endif %}
 
   {# First resolve by length #}
   {% if not fall_through_to_partial_overloads %}
   bool isArityError = false;
   {% endif %}
   {# 2. Initialize argcount to be min(maxarg, n). #}
   switch (std::min({{overloads.maxarg}}, info.Length())) {
     {# 3. Remove from S all entries whose type list is not of length argcount. #}
     {% for length, tests_methods in overloads.length_tests_methods %}
     {# 10. If i = d, then: #}
     case {{length}}:
       {# Then resolve by testing argument #}
       {% for test, method in tests_methods %}
       {% if method.visible %}
       {% filter runtime_enabled(not overloads.runtime_enabled_all and method.runtime_enabled_feature_name) %}
       if ({{test}}) {
         {% if method.measure_as and not overloads.measure_all_as %}
-        UseCounter::count(currentExecutionContext(info.GetIsolate()), UseCounter::{{method.measure_as('Method')}});
+        UseCounter::count(currentExecutionContext(info.GetIsolate()), UseCounter::k{{method.measure_as('Method')}});
         {% endif %}
         {% if method.deprecate_as and not overloads.deprecate_all_as %}
-        Deprecation::countDeprecation(currentExecutionContext(info.GetIsolate()), UseCounter::{{method.deprecate_as}});
+        Deprecation::countDeprecation(currentExecutionContext(info.GetIsolate()), UseCounter::k{{method.deprecate_as}});
         {% endif %}
         {{method.name}}{{method.overload_index}}Method{{world_suffix}}(info);
         return;
       }
       {% endfilter %}
       {% endif %}
       {% endfor %}
       break;
     {% endfor %}{# length, tests_methods #}
     {% if not fall_through_to_partial_overloads %}
     default:
       {# 4. If S is empty, then throw a TypeError. #}
       isArityError = true;
     {% endif %}
   }
 
   {% if fall_through_to_partial_overloads %}
 
   DCHECK({{overloads.name}}MethodForPartialInterface);
   ({{overloads.name}}MethodForPartialInterface)(info);
 
   {% else %}{# fall_through_to_partial_overloads #}
 
-  ExceptionState exceptionState(info.GetIsolate(), ExceptionState::ExecutionContext, "{{interface_name}}", "{{overloads.name}}");
+  ExceptionState exceptionState(info.GetIsolate(), ExceptionState::kExecutionContext, "{{interface_name}}", "{{overloads.name}}");
   {% if overloads.returns_promise_all %}
   ExceptionToRejectPromiseScope rejectPromiseScope(info, exceptionState);
   {% endif %}
 
   if (isArityError) {
     {% if overloads.length != 0 %}
     if (info.Length() < {{overloads.length}}) {
       exceptionState.throwTypeError(ExceptionMessages::notEnoughArguments({{overloads.length}}, info.Length()));
       return;
     }
     {% endif %}
     {% if overloads.valid_arities %}
     if (info.Length() >= {{overloads.length}}) {
       exceptionState.throwTypeError(ExceptionMessages::invalidArity("{{overloads.valid_arities}}", info.Length()));
       return;
     }
     {% endif %}
   }
   exceptionState.throwTypeError("No function was found that matched the signature provided.");
 
   {% endif %}{# fall_through_to_partial_overloads #}
 }
 {% endmacro %}
 
 
 {##############################################################################}
 {% macro generate_post_message_impl(method) %}
 static void postMessageImpl(const char* interfaceName, {{cpp_class}}* instance, const v8::FunctionCallbackInfo<v8::Value>& info) {
-  ExceptionState exceptionState(info.GetIsolate(), ExceptionState::ExecutionContext, interfaceName, "postMessage");
+  ExceptionState exceptionState(info.GetIsolate(), ExceptionState::kExecutionContext, interfaceName, "postMessage");
   if (UNLIKELY(info.Length() < {{method.number_of_required_arguments}})) {
     exceptionState.throwTypeError(ExceptionMessages::notEnoughArguments({{method.number_of_required_arguments}}, info.Length()));
     return;
   }
 
   Transferables transferables;
   if (info.Length() > 1) {
     const int transferablesArgIndex = 1;
     if (!SerializedScriptValue::extractTransferables(info.GetIsolate(), info[transferablesArgIndex], transferablesArgIndex, transferables, exceptionState)) {
       return;
     }
   }
 
   RefPtr<SerializedScriptValue> message;
   if (instance->canTransferArrayBuffersAndImageBitmaps()) {
     // This instance supports sending array buffers by move semantics.
     message = SerializedScriptValue::serialize(info.GetIsolate(), info[0], &transferables, nullptr, exceptionState);
     if (exceptionState.hadException())
       return;
   } else {
     // This instance doesn't support sending array buffers and image bitmaps
     // by move semantics. Emulate it by copy-and-neuter semantics that sends
     // array buffers and image bitmaps via structured clone and then neuters
     // the original objects
 
     // Clear references to array buffers and image bitmaps from transferables
     // so that the serializer can consider the array buffers as
     // non-transferable and serialize them into the message.
-    ArrayBufferArray transferableArrayBuffers = transferables.arrayBuffers;
-    transferables.arrayBuffers.clear();
-    ImageBitmapArray transferableImageBitmaps = transferables.imageBitmaps;
-    transferables.imageBitmaps.clear();
+    ArrayBufferArray transferableArrayBuffers = transferables.array_buffers;
+    transferables.array_buffers.clear();
+    ImageBitmapArray transferableImageBitmaps = transferables.image_bitmaps;
+    transferables.image_bitmaps.clear();
     message = SerializedScriptValue::serialize(info.GetIsolate(), info[0], &transferables, nullptr, exceptionState);
     if (exceptionState.hadException())
       return;
 
     // Neuter the original array buffers on the sender context.
     SerializedScriptValue::transferArrayBufferContents(info.GetIsolate(), transferableArrayBuffers, exceptionState);
     if (exceptionState.hadException())
       return;
     // Neuter the original image bitmaps on the sender context.
     SerializedScriptValue::transferImageBitmapContents(info.GetIsolate(), transferableImageBitmaps, exceptionState);
     if (exceptionState.hadException())
       return;
   }
 
   // FIXME: Only pass context/exceptionState if instance really requires it.
   ExecutionContext* context = currentExecutionContext(info.GetIsolate());
-  instance->postMessage(context, message.release(), transferables.messagePorts, exceptionState);
+  instance->postMessage(context, message.release(), transferables.message_ports, exceptionState);
 }
 {% endmacro %}
 
 
 {##############################################################################}
 {% macro method_callback(method, world_suffix) %}
 void {{method.name}}MethodCallback{{world_suffix}}(const v8::FunctionCallbackInfo<v8::Value>& info) {
   {% if not method.overloads %}{# Overloaded methods are measured in overload_resolution_method() #}
   {% if method.measure_as %}
-  UseCounter::count(currentExecutionContext(info.GetIsolate()), UseCounter::{{method.measure_as('Method')}});
+  UseCounter::count(currentExecutionContext(info.GetIsolate()), UseCounter::k{{method.measure_as('Method')}});
   {% endif %}
   {% if method.deprecate_as %}
-  Deprecation::countDeprecation(currentExecutionContext(info.GetIsolate()), UseCounter::{{method.deprecate_as}});
+  Deprecation::countDeprecation(currentExecutionContext(info.GetIsolate()), UseCounter::k{{method.deprecate_as}});
   {% endif %}
   {% endif %}{# not method.overloads #}
   {% if world_suffix in method.activity_logging_world_list %}
   {% if method.is_static %}
   ScriptState* scriptState = ScriptState::forFunctionObject(info);
   {% else %}
   ScriptState* scriptState = ScriptState::forReceiverObject(info);
   {% endif %}
   V8PerContextData* contextData = scriptState->perContextData();
   if (contextData && contextData->activityLogger()) {
-    ExceptionState exceptionState(info.GetIsolate(), ExceptionState::ExecutionContext, "{{interface_name}}", "{{method.name}}");
+    ExceptionState exceptionState(info.GetIsolate(), ExceptionState::kExecutionContext, "{{interface_name}}", "{{method.name}}");
     Vector<v8::Local<v8::Value>> loggerArgs = toImplArguments<Vector<v8::Local<v8::Value>>>(info, 0, exceptionState);
     contextData->activityLogger()->logMethod("{{interface_name}}.{{method.name}}", info.Length(), loggerArgs.data());
   }
   {% endif %}
   {% if method.is_ce_reactions %}
   CEReactionsScope ceReactionsScope;
   {% endif %}
   {% if method.is_custom %}
   {{v8_class}}::{{method.name}}MethodCustom(info);
   {% elif method.is_post_message %}
@@ skipping 15 matching lines @@
   V8PerIsolateData* data = V8PerIsolateData::from(info.GetIsolate());
   const DOMWrapperWorld& world = DOMWrapperWorld::world(info.GetIsolate()->GetCurrentContext());
   v8::Local<v8::FunctionTemplate> interfaceTemplate = data->findInterfaceTemplate(world, &{{v8_class}}::wrapperTypeInfo);
   v8::Local<v8::Signature> signature = v8::Signature::New(info.GetIsolate(), interfaceTemplate);
 
   v8::Local<v8::FunctionTemplate> methodTemplate = data->findOrCreateOperationTemplate(world, &domTemplateKey, {{cpp_class}}V8Internal::{{method.name}}MethodCallback{{world_suffix}}, v8Undefined(), signature, {{method.length}});
   // Return the function by default, unless the user script has overwritten it.
   v8SetReturnValue(info, methodTemplate->GetFunction(info.GetIsolate()->GetCurrentContext()).ToLocalChecked());
 
   {{cpp_class}}* impl = {{v8_class}}::toImpl(info.Holder());
-  if (!BindingSecurity::shouldAllowAccessTo(currentDOMWindow(info.GetIsolate()), impl, BindingSecurity::ErrorReportOption::DoNotReport)) {
+  if (!BindingSecurity::shouldAllowAccessTo(currentDOMWindow(info.GetIsolate()), impl, BindingSecurity::ErrorReportOption::kDoNotReport)) {
     return;
   }
 
   v8::Local<v8::Value> hiddenValue = V8HiddenValue::getHiddenValue(ScriptState::current(info.GetIsolate()), v8::Local<v8::Object>::Cast(info.Holder()), v8AtomicString(info.GetIsolate(), "{{method.name}}"));
   if (!hiddenValue.IsEmpty()) {
     v8SetReturnValue(info, hiddenValue);
   }
 }
 
 void {{method.name}}OriginSafeMethodGetterCallback{{world_suffix}}(v8::Local<v8::Name>, const v8::PropertyCallbackInfo<v8::Value>& info) {
   {{cpp_class}}V8Internal::{{method.name}}OriginSafeMethodGetter{{world_suffix}}(info);
 }
 {% endmacro %}
 
 
 {##############################################################################}
 {% macro generate_constructor(constructor) %}
 {% set name = '%sConstructorCallback' % v8_class
               if constructor.is_named_constructor else
               'constructor%s' % (constructor.overload_index or '') %}
 static void {{name}}(const v8::FunctionCallbackInfo<v8::Value>& info) {
   {% set function_call = func_call_with_prep_of_args(constructor) %}
 
   {% if constructor.is_named_constructor %}
   if (!info.IsConstructCall()) {
     V8ThrowException::throwTypeError(info.GetIsolate(), ExceptionMessages::constructorNotCallableAsFunction("{{constructor.name}}"));
     return;
   }
 
-  if (ConstructorMode::current(info.GetIsolate()) == ConstructorMode::WrapExistingObject) {
+  if (ConstructorMode::current(info.GetIsolate()) == ConstructorMode::kWrapExistingObject) {
     v8SetReturnValue(info, info.Holder());
     return;
   }
   {% endif %}
 
   {% if 'exceptionState' in function_call %}
-  ExceptionState exceptionState(info.GetIsolate(), ExceptionState::ConstructionContext, "{{interface_name}}");
+  ExceptionState exceptionState(info.GetIsolate(), ExceptionState::kConstructionContext, "{{interface_name}}");
   {% endif %}
   {% if 'scriptState' in function_call %}
   ScriptState* scriptState = ScriptState::forReceiverObject(info);
   {% endif %}
 
   {{function_call | indent(2)}}
 }
 {% endmacro %}
 
 
@@ skipping 12 matching lines @@
 {% macro method_configuration(method) %}
 {% from 'utilities.cpp.tmpl' import property_location %}
 {% set method_callback =
        '%sV8Internal::%sMethodCallback' % (cpp_class_or_partial, method.name) %}
 {% set method_callback_for_main_world =
        '%sV8Internal::%sMethodCallbackForMainWorld' % (cpp_class_or_partial, method.name)
        if method.is_per_world_bindings else '0' %}
 {% set property_attribute =
        'static_cast<v8::PropertyAttribute>(%s)' % ' | '.join(method.property_attributes)
        if method.property_attributes else 'v8::None' %}
-{% set holder_check = 'V8DOMConfiguration::DoNotCheckHolder'
-       if method.returns_promise else 'V8DOMConfiguration::CheckHolder' %}
+{% set holder_check = 'V8DOMConfiguration::kDoNotCheckHolder'
+       if method.returns_promise else 'V8DOMConfiguration::kCheckHolder' %}
 {"{{method.name}}", {{method_callback}}, {{method_callback_for_main_world}}, {{method.length}}, {{property_attribute}}, {{property_location(method)}}, {{holder_check}}}
 {%- endmacro %}
 
 
 {######################################}
 {% macro install_custom_signature(method, instance_template, prototype_template, interface_template, signature) %}
 const V8DOMConfiguration::MethodConfiguration {{method.name}}MethodConfiguration = {{method_configuration(method)}};
 V8DOMConfiguration::installMethod(isolate, world, {{instance_template}}, {{prototype_template}}, {{interface_template}}, {{signature}}, {{method.name}}MethodConfiguration);
 {%- endmacro %}
 
@@ skipping 16 matching lines @@
                           if method.overloads else
                           method.runtime_enabled_feature_name) %}
 const V8DOMConfiguration::MethodConfiguration {{method.name}}MethodConfiguration = {{method_configuration(method)}};
 V8DOMConfiguration::installMethod(isolate, world, v8::Local<v8::Object>(), prototypeObject, interfaceObject, signature, {{method.name}}MethodConfiguration);
 {% endfilter %}{# runtime_enabled() #}
 {% endfilter %}{# exposed() #}
 {% endfilter %}{# secure_context() #}
 {% endfor %}
 {% endif %}
 {%- endmacro %}