Add more functions to the list of leaf functions which do not need an

tools/dom/scripts/systemnative.py

 #!/usr/bin/python
 # Copyright (c) 2012, the Dart project authors.  Please see the AUTHORS file
 # for details. All rights reserved. Use of this source code is governed by a
 # BSD-style license that can be found in the LICENSE file.
 
 """This module provides shared functionality for the systems to generate
 native binding from the IDL database."""
 
 import emitter
 import os
@@ skipping 75 matching lines @@
   ('DOMURL', 'createObjectUrlFromStreamCallback'): 'URLMediaStream',
   ('DOMURL', '_createObjectUrlFromWebKitSourceCallback'): 'URLMediaSource',
   ('DOMURL', '_createObjectURL_2Callback'): 'URLMediaSource',
   ('DOMURL', '_createObjectURL_3Callback'): 'URLMediaSource',
   ('DOMURL', '_createObjectURL_4Callback'): 'URLMediaStream',
 }
 
 _cpp_partial_map = {}
 
 _cpp_no_auto_scope_list = set([
+  ('Document', 'body', 'Getter'),
+  ('Document', 'getElementById', 'Callback'),
+  ('Document', 'getElementsByName', 'Callback'),
+  ('Document', 'getElementsByTagName', 'Callback'),
+  ('Element', 'getAttribute', 'Callback'),
+  ('Element', 'getAttributeNS', 'Callback'),
+  ('Element', 'id', 'Getter'),
+  ('Element', 'id', 'Setter'),
+  ('Element', 'setAttribute', 'Callback'),
+  ('Element', 'setAttributeNS', 'Callback'),
   ('Node', 'firstChild', 'Getter'),
   ('Node', 'lastChild', 'Getter'),
   ('Node', 'nextSibling', 'Getter'),
   ('Node', 'previousSibling', 'Getter'),
   ('Node', 'childNodes', 'Getter'),
+  ('Node', 'nodeType', 'Getter'),
   ('NodeList', 'length', 'Getter'),
   ('NodeList', 'item', 'Callback'),
-  ('Document', 'body', 'Getter'),
 ])
 
 # TODO(vsm): This should be recoverable from IDL, but we appear to not
 # track the necessary info.
 _url_utils = ['hash', 'host', 'hostname', 'origin',
               'password', 'pathname', 'port', 'protocol',
               'search', 'username']
 _cpp_static_call_map = {
   'DOMURL': _url_utils + ['href', 'toString'],
   'HTMLAnchorElement': _url_utils,
@@ skipping 262 matching lines @@
       create_function = 'createForJSConstructor'
     function_expression = '%s::%s' % (self._interface_type_info.native_type(), create_function)
     self._GenerateNativeCallback(
         constructor_callback_cpp_name,
         False,
         function_expression,
         self._interface,
         arguments,
         self._interface.id,
         False,
-        'ConstructorRaisesException' in ext_attrs or 'RaisesException' in ext_attrs)
+        'ConstructorRaisesException' in ext_attrs or 'RaisesException' in ext_attrs,
+        True)
 
   def HasSupportCheck(self):
     # Need to omit a support check if it is conditional in JS.
     return self._interface.doc_js_name in js_support_checks
 
   def GetSupportCheck(self):
     # Assume that everything is supported on Dartium.
     value = js_support_checks.get(self._interface.doc_js_name)
     if type(value) == tuple:
       return (value[0], 'true')
@@ skipping 67 matching lines @@
         '        if (!value)\n'
         '            return Dart_Null();\n'
         '        DartDOMData* domData = DartDOMData::current();\n'
         '        Dart_WeakPersistentHandle result =\n'
         '            DartDOMWrapper::lookupWrapper<Dart$(INTERFACE)>(domData, value);\n'
         '        if (result)\n'
         '            return Dart_HandleFromWeakPersistent(result);\n'
         '        return createWrapper(domData, value);\n'
         '    }\n'
         '    static void returnToDart(Dart_NativeArguments args,\n'
-        '                             NativeType* value)\n'
+        '                             NativeType* value,\n'
+        '                             bool autoDartScope = true)\n'
         '    {\n'
         '        if (value) {\n'
         '            DartDOMData* domData = static_cast<DartDOMData*>(\n'
         '                Dart_GetNativeIsolateData(args));\n'
         '            Dart_WeakPersistentHandle result =\n'
         '                DartDOMWrapper::lookupWrapper<Dart$(INTERFACE)>(domData, value);\n'
         '            if (result)\n'
         '                Dart_SetWeakHandleReturnValue(args, result);\n'
         '            else {\n'
-        '                DartApiScope apiScope;\n'
-        '                Dart_SetReturnValue(args, createWrapper(domData, value));\n'
+        '                if (autoDartScope) {\n'
+        '                    Dart_SetReturnValue(args, createWrapper(domData, value));\n'
+        '                } else {\n'
+        '                    DartApiScope apiScope;\n'
+        '                    Dart_SetReturnValue(args, createWrapper(domData, value));\n'
+        '               }\n'
         '            }\n'
         '        }\n'
         '    }\n',
         INTERFACE=self._interface.id)
 
     if ('CustomToV8' in ext_attrs or
         'PureInterface' in ext_attrs or
         'CPPPureInterface' in ext_attrs or
         'SpecialWrapFor' in ext_attrs or
         self._interface_type_info.custom_to_dart()):
@@ skipping 28 matching lines @@
         IS_ACTIVE=TypeCheckHelper(is_active_test),
         IS_EVENT_TARGET=TypeCheckHelper(is_event_target_test),
         TO_NATIVE=to_native_emitter.Fragments(),
         TO_DART=to_dart_emitter.Fragments())
 
   def EmitAttribute(self, attribute, html_name, read_only):
     self._AddGetter(attribute, html_name, read_only)
     if not read_only:
       self._AddSetter(attribute, html_name)
 
+  def _GenerateAutoSetupScope(self, idl_name, native_suffix):
+    return (self._interface.id, idl_name, native_suffix) not in _cpp_no_auto_scope_list
+
   def _AddGetter(self, attr, html_name, read_only):
     # Temporary hack to force dart:scalarlist clamped array for ImageData.data.
     # TODO(antonm): solve in principled way.
     if self._interface.id == 'ImageData' and html_name == 'data':
       html_name = '_data'
     type_info = self._TypeInfo(attr.type.id)
     dart_declaration = '%s get %s' % (
         self.SecureOutputType(attr.type.id, False, read_only), html_name)
     is_custom = 'Custom' in attr.ext_attrs or 'CustomGetter' in attr.ext_attrs
+    native_suffix = 'Getter'
+    auto_scope_setup = self._GenerateAutoSetupScope(attr.id, native_suffix)
     cpp_callback_name = self._GenerateNativeBinding(attr.id, 1,
-        dart_declaration, 'Getter', is_custom)
+        dart_declaration, native_suffix, is_custom, auto_scope_setup)
     if is_custom:
       return
 
     if 'Reflect' in attr.ext_attrs:
       webcore_function_name = self._TypeInfo(attr.type.id).webcore_getter_name()
       if 'URL' in attr.ext_attrs:
         if 'NonEmpty' in attr.ext_attrs:
           webcore_function_name = 'getNonEmptyURLAttribute'
         else:
           webcore_function_name = 'getURLAttribute'
@@ skipping 11 matching lines @@
 
     function_expression = self._GenerateWebCoreFunctionExpression(webcore_function_name, attr)
     self._GenerateNativeCallback(
         cpp_callback_name,
         True,
         function_expression,
         attr,
         [],
         attr.type.id,
         attr.type.nullable,
-        'GetterRaisesException' in attr.ext_attrs or 'RaisesException' in attr.ext_attrs)
+        'GetterRaisesException' in attr.ext_attrs or 'RaisesException' in attr.ext_attrs,
+        auto_scope_setup)
 
   def _AddSetter(self, attr, html_name):
     type_info = self._TypeInfo(attr.type.id)
     dart_declaration = 'void set %s(%s value)' % (html_name, self._DartType(attr.type.id))
     is_custom = set(['Custom', 'CustomSetter', 'V8CustomSetter']) & set(attr.ext_attrs)
+    native_suffix = 'Setter'
+    auto_scope_setup = self._GenerateAutoSetupScope(attr.id, native_suffix)
     cpp_callback_name = self._GenerateNativeBinding(attr.id, 2,
-        dart_declaration, 'Setter', is_custom)
+        dart_declaration, native_suffix, is_custom, auto_scope_setup)
     if is_custom:
       return
 
     if 'Reflect' in attr.ext_attrs:
       webcore_function_name = self._TypeInfo(attr.type.id).webcore_setter_name()
     else:
       webcore_function_name = re.sub(r'^(xml|css|(?=[A-Z])|\w)',
                                      lambda s: s.group(1).upper(),
                                      attr.id)
       webcore_function_name = 'set%s' % webcore_function_name
 
     function_expression = self._GenerateWebCoreFunctionExpression(webcore_function_name, attr)
     self._GenerateNativeCallback(
         cpp_callback_name,
         True,
         function_expression,
         attr,
         [attr],
         'void',
         False,
         'SetterRaisesException' in attr.ext_attrs,
+        auto_scope_setup,
         generate_custom_element_scope_if_needed=True)
 
   def AddIndexer(self, element_type):
     """Adds all the methods required to complete implementation of List."""
     # We would like to simply inherit the implementation of everything except
     # length, [], and maybe []=.  It is possible to extend from a base
     # array implementation class only when there is no other implementation
     # inheritance.  There might be no implementation inheritance other than
     # DOMBaseWrapper for many classes, but there might be some where the
     # array-ness is introduced by a non-root interface:
@@ skipping 52 matching lines @@
     if self._HasNativeIndexSetter():
       self._EmitNativeIndexSetter(dart_element_type)
 
   def _HasNativeIndexGetter(self):
     return 'CustomIndexedGetter' in self._interface.ext_attrs
 
   def _EmitNativeIndexGetter(self, element_type):
     dart_declaration = '%s operator[](int index)' % \
         self.SecureOutputType(element_type, True)
     self._GenerateNativeBinding('numericIndexGetter', 2, dart_declaration,
-        'Callback', True)
+        'Callback', True, False)
 
   def _HasExplicitIndexedGetter(self):
     return any(op.id == 'getItem' for op in self._interface.operations)
 
   def _EmitExplicitIndexedGetter(self, dart_element_type):
     if any(op.id == 'getItem' for op in self._interface.operations):
       indexed_getter = 'getItem'
 
     self._members_emitter.Emit(
         '\n'
         '  $TYPE operator[](int index) {\n'
         '    if (index < 0 || index >= length)\n'
         '      throw new RangeError.range(index, 0, length);\n'
         '    return $INDEXED_GETTER(index);\n'
         '  }\n',
         TYPE=dart_element_type,
         INDEXED_GETTER=indexed_getter)
 
   def _HasNativeIndexSetter(self):
     return 'CustomIndexedSetter' in self._interface.ext_attrs
 
   def _EmitNativeIndexSetter(self, element_type):
     dart_declaration = 'void operator[]=(int index, %s value)' % element_type
     self._GenerateNativeBinding('numericIndexSetter', 3, dart_declaration,
-        'Callback', True)
+        'Callback', True, False)
 
   def EmitOperation(self, info, html_name):
     """
     Arguments:
       info: An OperationInfo object.
     """
 
     dart_declaration = '%s%s %s(%s)' % (
         'static ' if info.IsStatic() else '',
         self.SecureOutputType(info.type_name, False, True),
         html_name,
         info.ParametersDeclaration(self._DartType))
 
     operation = info.operations[0]
     is_custom = 'Custom' in operation.ext_attrs
     has_optional_arguments = any(self._IsArgumentOptionalInWebCore(operation, argument) for argument in operation.arguments)
     needs_dispatcher = not is_custom and (len(info.operations) > 1 or has_optional_arguments)
 
     if info.callback_args:
       self._AddFutureifiedOperation(info, html_name)
     elif not needs_dispatcher:
       # Bind directly to native implementation
       argument_count = (0 if info.IsStatic() else 1) + len(info.param_infos)
+      native_suffix = 'Callback'
+      auto_scope_setup = self._GenerateAutoSetupScope(info.name, native_suffix)
       cpp_callback_name = self._GenerateNativeBinding(
-          info.name, argument_count, dart_declaration, 'Callback', is_custom)
+          info.name, argument_count, dart_declaration, native_suffix, is_custom,
+          auto_scope_setup)
       if not is_custom:
-        self._GenerateOperationNativeCallback(operation, operation.arguments, cpp_callback_name)
+        self._GenerateOperationNativeCallback(operation, operation.arguments, cpp_callback_name, auto_scope_setup)
     else:
       self._GenerateDispatcher(info, info.operations, dart_declaration)
 
   def _GenerateDispatcher(self, info, operations, dart_declaration):
 
     def GenerateCall(
         stmts_emitter, call_emitter, version, operation, argument_count):
       overload_name = '_%s_%s' % (operation.id, version)
       argument_list = ', '.join(
           [p.name for p in info.param_infos[:argument_count]])
       call_emitter.Emit('$NAME($ARGS)', NAME=overload_name, ARGS=argument_list)
 
       dart_declaration = '%s%s %s(%s)' % (
           'static ' if operation.is_static else '',
           self.SecureOutputType(operation.type.id),
           overload_name, argument_list)
       is_custom = 'Custom' in operation.ext_attrs
+      native_suffix = 'Callback'
+      auto_scope_setup = self._GenerateAutoSetupScope(overload_name, native_suffix)
       cpp_callback_name = self._GenerateNativeBinding(
           overload_name, (0 if operation.is_static else 1) + argument_count,
-          dart_declaration, 'Callback', is_custom, emit_metadata=False)
+          dart_declaration, 'Callback', is_custom, auto_scope_setup,
+          emit_metadata=False)
       if not is_custom:
-        self._GenerateOperationNativeCallback(operation, operation.arguments[:argument_count], cpp_callback_name)
+        self._GenerateOperationNativeCallback(operation, operation.arguments[:argument_count], cpp_callback_name, auto_scope_setup)
 
     self._GenerateDispatcherBody(
         info,
         operations,
         dart_declaration,
         GenerateCall,
         self._IsArgumentOptionalInWebCore)
 
   def SecondaryContext(self, interface):
     pass
 
-  def _GenerateOperationNativeCallback(self, operation, arguments, cpp_callback_name):
+  def _GenerateOperationNativeCallback(self, operation, arguments, cpp_callback_name, auto_scope_setup=True):
     webcore_function_name = operation.ext_attrs.get('ImplementedAs', operation.id)
     function_expression = self._GenerateWebCoreFunctionExpression(webcore_function_name, operation, cpp_callback_name)
     self._GenerateNativeCallback(
         cpp_callback_name,
         not operation.is_static,
         function_expression,
         operation,
         arguments,
         operation.type.id,
         operation.type.nullable,
         'RaisesException' in operation.ext_attrs,
+        auto_scope_setup,
         generate_custom_element_scope_if_needed=True)
 
   def _GenerateNativeCallback(self,
       callback_name,
       needs_receiver,
       function_expression,
       node,
       arguments,
       return_type,
       return_type_is_nullable,
       raises_dom_exception,
+      auto_scope_setup=True,
       generate_custom_element_scope_if_needed=False):
 
     ext_attrs = node.ext_attrs
     if self._IsStatic(node.id):
       needs_receiver = True
 
     cpp_arguments = []
     runtime_check = None
     raises_exceptions = raises_dom_exception or arguments
     needs_custom_element_callbacks = False
@@ skipping 208 matching lines @@
 
       if AllowsNull():
         function += 'WithNullCheck'
 
       argument_name = DartDomNameOfAttribute(argument)
       if type_info.pass_native_by_ref():
         invocation_template =\
             '        $TYPE $ARGUMENT_NAME;\n'\
             '        $CLS::$FUNCTION(args, $INDEX, $ARGUMENT_NAME, exception);\n'
       else:
-        invocation_template =\
-            '        $TYPE $ARGUMENT_NAME = $CLS::$FUNCTION(args, $INDEX, exception);\n'
+        if not auto_scope_setup and type_info.native_type() == 'String':
+          invocation_template =\
+              '        $TYPE $ARGUMENT_NAME = $CLS::$FUNCTION(args, $INDEX, exception, false);\n'
+        else:
+          invocation_template =\
+              '        $TYPE $ARGUMENT_NAME = $CLS::$FUNCTION(args, $INDEX, exception);\n'
       body_emitter.Emit(
           '\n' +
           invocation_template +
           '        if (exception)\n'
           '            goto fail;\n',
           TYPE=type,
           ARGUMENT_NAME=argument_name,
           CLS=cls,
           FUNCTION=function,
           INDEX=start_index + i)
@@ skipping 58 matching lines @@
         if return_type_info.native_type() == 'unsigned':
           set_return_value = 'DartUtilities::setDartUnsignedReturnValue(args, %s)' % (value_expression)
         elif return_type_info.native_type() == 'unsigned long long':
           set_return_value = 'DartUtilities::setDartUnsignedLongLongReturnValue(args, %s)' % (value_expression)
         else:
           assert (return_type_info.native_type() == 'int' or return_type_info.native_type() == 'long long')
           set_return_value = 'DartUtilities::setDartIntegerReturnValue(args, %s)' % (value_expression)
       elif return_type_info.dart_type() == 'double':
         set_return_value = 'Dart_SetDoubleReturnValue(args, %s)' % (value_expression)
       elif return_type_info.dart_type() == 'String':
+        auto_dart_scope='true' if auto_scope_setup else 'false'
         if ext_attrs and 'TreatReturnedNullStringAs' in ext_attrs:
-          set_return_value = 'DartUtilities::setDartStringReturnValueWithNullCheck(args, %s)' % (value_expression)
+          set_return_value = 'DartUtilities::setDartStringReturnValueWithNullCheck(args, %s, %s)' % (value_expression, auto_dart_scope)
         else:
-          set_return_value = 'DartUtilities::setDartStringReturnValue(args, %s)' % (value_expression)
+          set_return_value = 'DartUtilities::setDartStringReturnValue(args, %s, %s)' % (value_expression, auto_dart_scope)
       elif return_type_info.dart_type() == 'num' and return_type_info.native_type() == 'double':
         set_return_value = 'Dart_SetDoubleReturnValue(args, %s)' % (value_expression)
       else:
         return_to_dart_conversion = return_type_info.return_to_dart_conversion(
             value_expression,
+            auto_scope_setup,
             self._interface.id,
             ext_attrs)
         set_return_value = '%s' % (return_to_dart_conversion)
       invocation_emitter.Emit(
         '        $RETURN_VALUE;\n',
         RETURN_VALUE=set_return_value)
 
   def _GenerateNativeBinding(self, idl_name, argument_count, dart_declaration,
-      native_suffix, is_custom, emit_metadata=True):
-
-    def _GenerateAutoSetupScope(self, idl_name, native_suffix):
-      if ((self._interface.id, idl_name, native_suffix) not in _cpp_no_auto_scope_list):
-        return 'true'
-      return 'false'
+      native_suffix, is_custom, auto_scope_setup=True, emit_metadata=True):
 
     metadata = []
     if emit_metadata:
       metadata = self._metadata.GetFormattedMetadata(
           self._renamer.GetLibraryName(self._interface),
           self._interface, idl_name, '  ')
 
     native_binding = '%s_%s_%s' % (self._interface.id, idl_name, native_suffix)
     self._members_emitter.Emit(
         '\n'
         '  $METADATA$DART_DECLARATION native "$NATIVE_BINDING";\n',
         DOMINTERFACE=self._interface.id,
         METADATA=metadata,
         DART_DECLARATION=dart_declaration,
         NATIVE_BINDING=native_binding)
 
     cpp_callback_name = '%s%s' % (idl_name, native_suffix)
-    auto_scope_setup = _GenerateAutoSetupScope(self, idl_name, native_suffix)
 
     self._cpp_resolver_emitter.Emit(
         '    if (argumentCount == $ARGC && name == "$NATIVE_BINDING") {\n'
         '        *autoSetupScope = $AUTO_SCOPE_SETUP;\n'
         '        return Dart$(INTERFACE_NAME)Internal::$CPP_CALLBACK_NAME;\n'
         '    }\n',
         ARGC=argument_count,
         NATIVE_BINDING=native_binding,
         INTERFACE_NAME=self._interface.id,
-        AUTO_SCOPE_SETUP=auto_scope_setup,
+        AUTO_SCOPE_SETUP='true' if auto_scope_setup else 'false',
         CPP_CALLBACK_NAME=cpp_callback_name)
 
     if is_custom:
       self._cpp_declarations_emitter.Emit(
           '\n'
           'void $CPP_CALLBACK_NAME(Dart_NativeArguments);\n',
           CPP_CALLBACK_NAME=cpp_callback_name)
 
     return cpp_callback_name
 
@@ skipping 189 matching lines @@
     e.Emit("};\n");
     e.Emit('\n');
     e.Emit('} // namespace WebCore\n');
 
 def _IsOptionalStringArgumentInInitEventMethod(interface, operation, argument):
   return (
       interface.id.endswith('Event') and
       operation.id.startswith('init') and
       argument.ext_attrs.get('Default') == 'Undefined' and
       argument.type.id == 'DOMString')