Support nullable attributes and return types in Dartium.

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 209 matching lines @@
     if 'NamedConstructor' in ext_attrs:
       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)
 
   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:
@@ skipping 105 matching lines @@
         webcore_function_name += 'Animated'
 
     function_expression = self._GenerateWebCoreFunctionExpression(webcore_function_name, attr)
     self._GenerateNativeCallback(
         cpp_callback_name,
         True,
         function_expression,
         attr,
         [],
         attr.type.id,
+        attr.type.nullable,
         attr.get_raises)
 
   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)
     cpp_callback_name = self._GenerateNativeBinding(attr.id, 2,
         dart_declaration, 'Setter', is_custom)
     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(?=[A-Z])|\w)',
                                      lambda s: s.group(1).upper(),
                                      attr.id)
       webcore_function_name = 'set%s' % webcore_function_name
       if attr.type.id.startswith('SVGAnimated'):
         webcore_function_name += 'Animated'
 
     function_expression = self._GenerateWebCoreFunctionExpression(webcore_function_name, attr)
     self._GenerateNativeCallback(
         cpp_callback_name,
         True,
         function_expression,
         attr,
         [attr],
         'void',
+        False,
         attr.set_raises)
 
   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 123 matching lines @@
   def _GenerateOperationNativeCallback(self, operation, arguments, cpp_callback_name):
     webcore_function_name = operation.ext_attrs.get('ImplementedAs', operation.id)
     function_expression = self._GenerateWebCoreFunctionExpression(webcore_function_name, operation)
     self._GenerateNativeCallback(
         cpp_callback_name,
         not operation.is_static,
         function_expression,
         operation,
         arguments,
         operation.type.id,
+        operation.type.nullable,
         operation.raises)
 
   def _GenerateNativeCallback(self,
       callback_name,
       needs_receiver,
       function_expression,
       node,
       arguments,
       return_type,
+      return_type_is_nullable,
       raises_dom_exception):
     ext_attrs = node.ext_attrs
 
     cpp_arguments = []
     runtime_check = None
     raises_exceptions = raises_dom_exception or arguments
 
     # TODO(antonm): unify with ScriptState below.
     requires_stack_info = ext_attrs.get('CallWith') == 'ScriptArguments|ScriptState'
     if requires_stack_info:
@@ skipping 28 matching lines @@
       cpp_arguments = ['document']
 
     if 'ImplementedBy' in ext_attrs:
       assert needs_receiver
       self._cpp_impl_includes.add('"%s.h"' % ext_attrs['ImplementedBy'])
       cpp_arguments.append('receiver')
 
     if 'Reflect' in ext_attrs:
       cpp_arguments = [self._GenerateWebCoreReflectionAttributeName(node)]
 
+    if return_type_is_nullable:
+      cpp_arguments = ['isNull']
+
     v8EnabledPerContext = ext_attrs.get('synthesizedV8EnabledPerContext', ext_attrs.get('V8EnabledPerContext'))
     v8EnabledAtRuntime = ext_attrs.get('synthesizedV8EnabledAtRuntime', ext_attrs.get('V8EnabledAtRuntime'))
     assert(not (v8EnabledPerContext and v8EnabledAtRuntime))
 
     if v8EnabledPerContext:
       raises_exceptions = True
       self._cpp_impl_includes.add('"ContextFeatures.h"')
       self._cpp_impl_includes.add('"DOMWindow.h"')
       runtime_check = emitter.Format(
           '        if (!ContextFeatures::$(FEATURE)Enabled(DartUtilities::domWindowForCurrentIsolate()->document())) {\n'
@@ skipping 157 matching lines @@
 
     function_call = '%s(%s)' % (function_expression, ', '.join(cpp_arguments))
     if return_type == 'void':
       invocation_emitter.Emit(
         '        $FUNCTION_CALL;\n',
         FUNCTION_CALL=function_call)
     else:
       return_type_info = self._TypeInfo(return_type)
       self._cpp_impl_includes |= set(return_type_info.conversion_includes())
 
+      if return_type_is_nullable:
+        invocation_emitter.Emit(
+          '        bool isNull = false;\n'
+          '        $NATIVE_TYPE result = $FUNCTION_CALL;\n'
+          '        if (isNull)\n'
+          '            return;\n',
+          NATIVE_TYPE=return_type_info.native_type(),
+          FUNCTION_CALL=function_call)
+        value_expression = 'result'
+      else:
+        value_expression = function_call
+
       # Generate to Dart conversion of C++ value.
-      to_dart_conversion = return_type_info.to_dart_conversion(function_call, self._interface.id, ext_attrs)
+      to_dart_conversion = return_type_info.to_dart_conversion(value_expression, self._interface.id, ext_attrs)
       invocation_emitter.Emit(
         '        Dart_Handle returnValue = $TO_DART_CONVERSION;\n'
         '        if (returnValue)\n'
         '            Dart_SetReturnValue(args, returnValue);\n',
         TO_DART_CONVERSION=to_dart_conversion)
 
   def _GenerateNativeBinding(self, idl_name, argument_count, dart_declaration,
       native_suffix, is_custom):
     annotations = FormatAnnotationsAndComments(
         GetAnnotationsAndComments(self._renamer.GetLibraryName(self._interface),
@@ skipping 123 matching lines @@
             '    if (Dart_NativeFunction func = $CLASS_NAME::resolver(name, argumentCount))\n'
             '        return func;\n',
             CLASS_NAME=os.path.splitext(os.path.basename(path))[0])
 
 def _IsOptionalStringArgumentInInitEventMethod(interface, operation, argument):
   return (
       interface.id.endswith('Event') and
       operation.id.startswith('init') and
       argument.ext_attrs.get('Optional') == 'DefaultIsUndefined' and
       argument.type.id == 'DOMString')