ABANDONED CL: Changes needed to make things compile after running rewrite_to_chrome_style tool.

third_party/WebKit/Source/bindings/scripts/v8_interface.py

 # Copyright (C) 2013 Google Inc. All rights reserved.
 # coding=utf-8
 #
 # 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
@@ skipping 195 matching lines @@
 
     # [PrimaryGlobal] and [Global]
     is_global = ('PrimaryGlobal' in extended_attributes or
                  'Global' in extended_attributes)
 
     # [ImmutablePrototype]
     # TODO(littledan): Is it possible to deduce this based on inheritance,
     # as in the WebIDL spec?
     is_immutable_prototype = is_global or 'ImmutablePrototype' in extended_attributes
 
-    wrapper_class_id = ('NodeClassId' if inherits_interface(interface.name, 'Node') else 'ObjectClassId')
+    wrapper_class_id = ('kNodeClassId' if inherits_interface(interface.name, 'Node') else 'kObjectClassId')
 
     # [ActiveScriptWrappable] must be accompanied with [DependentLifetime].
     if active_scriptwrappable and not is_dependent_lifetime:
         raise Exception('[ActiveScriptWrappable] interface must also specify '
                         '[DependentLifetime]: %s' % interface.name)
 
     v8_class_name = v8_utilities.v8_class_name(interface)
     cpp_class_name = cpp_name(interface)
     cpp_class_name_or_partial = cpp_name_or_partial(interface)
     v8_class_name_or_partial = v8_utilities.v8_class_name_or_partial(interface)
 
     # TODO(peria): Generate the target list from 'Window' and 'HTMLDocument'.
     needs_runtime_enabled_installer = v8_class_name in [
         'V8Window', 'V8HTMLDocument', 'V8Document', 'V8Node', 'V8EventTarget']
 
     context = {
         'cpp_class': cpp_class_name,
         'cpp_class_or_partial': cpp_class_name_or_partial,
-        'event_target_inheritance': 'InheritFromEventTarget' if is_event_target else 'NotInheritFromEventTarget',
+        'event_target_inheritance': 'kInheritFromEventTarget' if is_event_target else 'kNotInheritFromEventTarget',
         'is_gc_type': True,
         # FIXME: Remove 'EventTarget' special handling, http://crbug.com/383699
         'has_access_check_callbacks': (is_check_security and
                                        interface.name != 'EventTarget'),
         'has_custom_legacy_call_as_function': has_extended_attribute_value(interface, 'Custom', 'LegacyCallAsFunction'),  # [Custom=LegacyCallAsFunction]
         'has_partial_interface': len(interface.partial_interfaces) > 0,
         'header_includes': header_includes,
         'interface_name': interface.name,
         'is_array_buffer_or_view': is_array_buffer_or_view,
         'is_check_security': is_check_security,
         'is_event_target': is_event_target,
         'is_exception': interface.is_exception,
         'is_global': is_global,
         'is_immutable_prototype': is_immutable_prototype,
         'is_node': inherits_interface(interface.name, 'Node'),
         'is_partial': interface.is_partial,
         'is_typed_array_type': is_typed_array_type,
-        'lifetime': 'Dependent' if is_dependent_lifetime else 'Independent',
+        'lifetime': 'kDependent' if is_dependent_lifetime else 'kIndependent',
         'measure_as': v8_utilities.measure_as(interface, None),  # [MeasureAs]
         'needs_runtime_enabled_installer': needs_runtime_enabled_installer,
         'origin_trial_enabled_function': v8_utilities.origin_trial_enabled_function_name(interface),
         'parent_interface': parent_interface,
         'pass_cpp_type': cpp_name(interface) + '*',
         'active_scriptwrappable': active_scriptwrappable,
         'runtime_enabled_feature_name': runtime_enabled_feature_name(interface),  # [RuntimeEnabled]
         'v8_class': v8_class_name,
         'v8_class_or_partial': v8_class_name_or_partial,
         'wrapper_class_id': wrapper_class_id,
@@ skipping 268 matching lines @@
         })
 
         def generated_iterator_method(name, implemented_as=None):
             return generated_method(
                 return_type=IdlType('Iterator'),
                 name=name,
                 extended_attributes=used_extended_attributes,
                 implemented_as=implemented_as)
 
         if not interface.has_indexed_elements:
-            iterator_method = generated_iterator_method('iterator', implemented_as='iterator')
+            iterator_method = generated_iterator_method('iterator', implemented_as='GetIterator')
 
         if interface.iterable or interface.maplike or interface.setlike:
             non_overridable_methods = []
             overridable_methods = []
 
             non_overridable_methods.extend([
-                generated_iterator_method('keys'),
-                generated_iterator_method('values'),
-                generated_iterator_method('entries'),
+                generated_iterator_method('Keys'),
+                generated_iterator_method('Values'),
+                generated_iterator_method('Entries'),
 
                 # void forEach(Function callback, [Default=Undefined] optional any thisArg)
-                generated_method(IdlType('void'), 'forEach',
+                generated_method(IdlType('void'), 'ForEach',
                                  arguments=[generated_argument(IdlType('Function'), 'callback'),
                                             generated_argument(IdlType('any'), 'thisArg',
                                                                is_optional=True,
                                                                extended_attributes={'Default': 'Undefined'})],
                                  extended_attributes=forEach_extended_attributes),
             ])
 
             if interface.maplike:
                 key_argument = generated_argument(interface.maplike.key_type, 'key')
                 value_argument = generated_argument(interface.maplike.value_type, 'value')
 
                 non_overridable_methods.extend([
-                    generated_method(IdlType('boolean'), 'has',
+                    generated_method(IdlType('boolean'), 'Has',
                                      arguments=[key_argument],
                                      extended_attributes=used_extended_attributes),
-                    generated_method(IdlType('any'), 'get',
+                    generated_method(IdlType('any'), 'Get',
                                      arguments=[key_argument],
                                      extended_attributes=used_extended_attributes),
                 ])
 
                 if not interface.maplike.is_read_only:
                     overridable_methods.extend([
-                        generated_method(IdlType('void'), 'clear',
+                        generated_method(IdlType('void'), 'Clear',
                                          extended_attributes=used_extended_attributes),
-                        generated_method(IdlType('boolean'), 'delete',
+                        generated_method(IdlType('boolean'), 'Delete',
                                          arguments=[key_argument],
                                          extended_attributes=used_extended_attributes),
-                        generated_method(IdlType(interface.name), 'set',
+                        generated_method(IdlType(interface.name), 'Set',
                                          arguments=[key_argument, value_argument],
                                          extended_attributes=used_extended_attributes),
                     ])
 
             if interface.setlike:
                 value_argument = generated_argument(interface.setlike.value_type, 'value')
 
                 non_overridable_methods.extend([
-                    generated_method(IdlType('boolean'), 'has',
+                    generated_method(IdlType('boolean'), 'Has',
                                      arguments=[value_argument],
                                      extended_attributes=used_extended_attributes),
                 ])
 
                 if not interface.setlike.is_read_only:
                     overridable_methods.extend([
-                        generated_method(IdlType(interface.name), 'add',
+                        generated_method(IdlType(interface.name), 'Add',
                                          arguments=[value_argument],
                                          extended_attributes=used_extended_attributes),
-                        generated_method(IdlType('void'), 'clear',
+                        generated_method(IdlType('void'), 'Clear',
                                          extended_attributes=used_extended_attributes),
-                        generated_method(IdlType('boolean'), 'delete',
+                        generated_method(IdlType('boolean'), 'Delete',
                                          arguments=[value_argument],
                                          extended_attributes=used_extended_attributes),
                     ])
 
             methods_by_name = {}
             for method in methods:
                 methods_by_name.setdefault(method['name'], []).append(method)
 
             for non_overridable_method in non_overridable_methods:
                 if non_overridable_method['name'] in methods_by_name:
@@ skipping 19 matching lines @@
         if serializer.operation:
             return_type = serializer.operation.idl_type
             implemented_as = serializer.operation.name
         else:
             return_type = IdlType('any')
             implemented_as = None
             if 'CallWith' not in serializer_ext_attrs:
                 serializer_ext_attrs['CallWith'] = 'ScriptState'
         methods.append(generated_method(
             return_type=return_type,
-            name='toJSON',
+            name='ToJSON',
             extended_attributes=serializer_ext_attrs,
             implemented_as=implemented_as))
 
     # Stringifier
     if interface.stringifier:
         stringifier = interface.stringifier
         stringifier_ext_attrs = stringifier.extended_attributes.copy()
         if stringifier.attribute:
             implemented_as = stringifier.attribute.name
         elif stringifier.operation:
             implemented_as = stringifier.operation.name
         else:
-            implemented_as = 'toString'
+            implemented_as = 'ToString'
         methods.append(generated_method(
             return_type=IdlType('DOMString'),
-            name='toString',
+            name='ToString',
             extended_attributes=stringifier_ext_attrs,
             implemented_as=implemented_as))
 
     for method in methods:
         # The value of the Function object’s “length” property is a Number
         # determined as follows:
         # 1. Let S be the effective overload set for regular operations (if the
         # operation is a regular operation) or for static operations (if the
         # operation is a static operation) with identifier id on interface I and
         # with argument count 0.
@@ skipping 453 matching lines @@
         yield test, method
     except StopIteration:
         pass
 
     # 3. Otherwise: if V is null or undefined, and there is an entry in S that
     # has one of the following types at position i of its type list,
     # • a nullable type
     try:
         method = next(method for idl_type, method in idl_types_methods
                       if idl_type.is_nullable)
-        test = 'isUndefinedOrNull(%s)' % cpp_value
+        test = 'IsUndefinedOrNull(%s)' % cpp_value
         yield test, method
     except StopIteration:
         pass
 
     # 4. Otherwise: if V is a platform object – but not a platform array
     # object – and there is an entry in S that has one of the following
     # types at position i of its type list,
     # • an interface type that V implements
     # (Unlike most of these tests, this can return multiple methods, since we
     #  test if it implements an interface. Thus we need a for loop, not a next.)
@@ skipping 241 matching lines @@
     return v8_methods.method_context(interface, caller)
 
 def property_getter(getter, cpp_arguments):
     if not getter:
         return None
 
     def is_null_expression(idl_type):
         if idl_type.use_output_parameter_for_result:
             return 'result.isNull()'
         if idl_type.is_string_type:
-            return 'result.isNull()'
+            return 'result.IsNull()'
         if idl_type.is_interface_type:
             return '!result'
         if idl_type.base_type in ('any', 'object'):
-            return 'result.isEmpty()'
+            return 'result.IsEmpty()'
         return ''
 
     extended_attributes = getter.extended_attributes
     idl_type = getter.idl_type
     idl_type.add_includes_for_type(extended_attributes)
     is_call_with_script_state = v8_utilities.has_extended_attribute_value(getter, 'CallWith', 'ScriptState')
     is_raises_exception = 'RaisesException' in extended_attributes
     use_output_parameter_for_result = idl_type.use_output_parameter_for_result
 
     # FIXME: make more generic, so can use v8_methods.cpp_value
@@ skipping 69 matching lines @@
     extended_attributes = deleter.extended_attributes
     is_call_with_script_state = v8_utilities.has_extended_attribute_value(deleter, 'CallWith', 'ScriptState')
     is_ce_reactions = 'CEReactions' in extended_attributes
     return {
         'is_call_with_script_state': is_call_with_script_state,
         'is_ce_reactions': is_ce_reactions,
         'is_custom': 'Custom' in extended_attributes,
         'is_raises_exception': 'RaisesException' in extended_attributes,
         'name': cpp_name(deleter),
     }