Add missing includes (spotted while splitting cpp derived sources).

client/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 41 matching lines @@
         self._emitters.FileEmitter(cpp_impl_path),
         self._BaseDefines(interface),
         self._templates)
 
   def ProcessCallback(self, interface, info):
     self._interface = interface
 
     dart_interface_path = self._FilePathForDartInterface(self._interface.id)
     self._dom_public_files.append(dart_interface_path)
 
+    cpp_impl_includes = set()
     cpp_header_handlers_emitter = emitter.Emitter()
     cpp_impl_handlers_emitter = emitter.Emitter()
     class_name = 'Dart%s' % self._interface.id
     for operation in interface.operations:
       if operation.type.id == 'void':
         return_type = 'void'
         return_prefix = ''
       else:
         return_type = 'bool'
         return_prefix = 'return '
 
       parameters = []
       arguments = []
       for argument in operation.arguments:
         argument_type_info = GetIDLTypeInfo(argument.type)
         parameters.append('%s %s' % (argument_type_info.parameter_type(),
                                      argument.id))
         arguments.append(argument.id)
+        cpp_impl_includes |= set(argument_type_info.conversion_includes())

[antonm, 2012/03/01 15:44:50]

or cpp_impl_includes.update(argument_type_info.conversion_includes())

 
       cpp_header_handlers_emitter.Emit(
           '\n'
           '    virtual $TYPE handleEvent($PARAMETERS);\n',
           TYPE=return_type, PARAMETERS=', '.join(parameters))
 
       cpp_impl_handlers_emitter.Emit(
           '\n'
           '$TYPE $CLASS_NAME::handleEvent($PARAMETERS)\n'
           '{\n'
@@ skipping 10 matching lines @@
     cpp_header_emitter.Emit(
         self._templates.Load('cpp_callback_header.template'),
         INTERFACE=self._interface.id,
         HANDLERS=cpp_header_handlers_emitter.Fragments())
 
     cpp_impl_path = self._FilePathForCppImplementation(self._interface.id)
     self._cpp_impl_files.append(cpp_impl_path)
     cpp_impl_emitter = self._emitters.FileEmitter(cpp_impl_path)
     cpp_impl_emitter.Emit(
         self._templates.Load('cpp_callback_implementation.template'),
+        INCLUDES=_GenerateCPPIncludes(cpp_impl_includes),
         INTERFACE=self._interface.id,
         HANDLERS=cpp_impl_handlers_emitter.Fragments())
 
   def GenerateLibraries(self, lib_dir):
     auxiliary_dir = os.path.relpath(self._auxiliary_dir, self._output_dir)
 
     # Generate dom_public.dart.
     self._GenerateLibFile(
         'dom_public.darttemplate',
         os.path.join(self._output_dir, 'dom_public.dart'),
@@ skipping 33 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])
 
     cpp_resolver_emitter = self._emitters.FileEmitter(cpp_resolver_path)
     cpp_resolver_emitter.Emit(
         self._templates.Load('cpp_resolver.template'),
         INCLUDES=includes_emitter.Fragments(),
         RESOLVER_BODY=resolver_body_emitter.Fragments())
 
-    # Generate DartDerivedSourcesAll.cpp
-    cpp_all_in_one_path = os.path.join(self._output_dir,
-        'DartDerivedSourcesAll.cpp')
+    # Generate DartDerivedSourcesXX.cpp.
+    partitions = 20 # FIXME: this should be configurable.
+    sources_count = len(self._cpp_impl_files)
+    for i in range(0, partitions):
+      derived_sources_path = os.path.join(self._output_dir,
+          'DartDerivedSources%02i.cpp' % (i + 1))
 
-    includes_emitter = emitter.Emitter()
-    for file in self._cpp_impl_files:
-        path = os.path.relpath(file, os.path.dirname(cpp_all_in_one_path))
-        includes_emitter.Emit('#include "$PATH"\n', PATH=path)
+      includes_emitter = emitter.Emitter()
+      for impl_file in self._cpp_impl_files[i::partitions]:
+          path = os.path.relpath(impl_file, os.path.dirname(cpp_all_in_one_path))
+          includes_emitter.Emit('#include "$PATH"\n', PATH=path)
 
-    cpp_all_in_one_emitter = self._emitters.FileEmitter(cpp_all_in_one_path)
-    cpp_all_in_one_emitter.Emit(
-        self._templates.Load('cpp_all_in_one.template'),
-        INCLUDES=includes_emitter.Fragments())
+      cpp_all_in_one_emitter = self._emitters.FileEmitter(derived_sources_path)

[antonm, 2012/03/01 15:44:50]

cpp_all_in_one, cpp_all_in_one, la-la

+      cpp_all_in_one_emitter.Emit(
+          self._templates.Load('cpp_all_in_one.template'),
+          INCLUDES=includes_emitter.Fragments())
 
-    # Generate DartResolver.cpp
+    # Generate DartResolver.cpp.
     cpp_resolver_path = os.path.join(self._output_dir, 'DartResolver.cpp')
 
     includes_emitter = emitter.Emitter()
     resolver_body_emitter = emitter.Emitter()
     for file in self._cpp_header_files:
         path = os.path.relpath(file, os.path.dirname(cpp_resolver_path))
         includes_emitter.Emit('#include "$PATH"\n', PATH=path)
         resolver_body_emitter.Emit(
             '    if (Dart_NativeFunction func = $CLASS_NAME::resolver(name, argumentCount))\n'
             '        return func;\n',
@@ skipping 53 matching lines @@
     self._cpp_impl_emitter = cpp_impl_emitter
     self._base_members = base_members
     self._templates = templates
     self._current_secondary_parent = None
 
   def StartInterface(self):
     self._class_name = self._ImplClassName(self._interface.id)
     self._interface_type_info = GetIDLTypeInfoByName(self._interface.id)
     self._members_emitter = emitter.Emitter()
     self._cpp_declarations_emitter = emitter.Emitter()
-    self._cpp_impl_includes = {}
+    self._cpp_impl_includes = set()
     self._cpp_definitions_emitter = emitter.Emitter()
     self._cpp_resolver_emitter = emitter.Emitter()
 
     self._GenerateConstructors()
 
   def _GenerateConstructors(self):
     if not self._IsConstructable():
       return
 
     # TODO(antonm): currently we don't have information about number of arguments expected by
@@ skipping 19 matching lines @@
     create_function = 'create'
     if 'NamedConstructor' in self._interface.ext_attrs:
       raises_dart_exceptions = True
       parameter_definitions_emitter.Emit(
             '        DOMWindow* domWindow = DartUtilities::domWindowForCurrentIsolate();\n'
             '        if (!domWindow) {\n'
             '            exception = Dart_NewString("Failed to fetch domWindow");\n'
             '            goto fail;\n'
             '        }\n'
             '        Document* document = domWindow->document();\n')
+      self._cpp_impl_includes.add('DOMWindow')
       arguments.append('document')
       create_function = 'createForJSConstructor'
     if 'CallWith' in self._interface.ext_attrs:
       call_with = self._interface.ext_attrs['CallWith']
       if call_with == 'ScriptExecutionContext':
         raises_dart_exceptions = True
         parameter_definitions_emitter.Emit(
             '        ScriptExecutionContext* context = DartUtilities::scriptExecutionContext();\n'
             '        if (!context) {\n'
             '            exception = Dart_NewString("Failed to create an object");\n'
@@ skipping 28 matching lines @@
     self._dart_impl_emitter.Emit(
         self._templates.Load('dart_implementation.darttemplate'),
         CLASS=self._class_name, BASE=base, INTERFACE=self._interface.id,
         MEMBERS=self._members_emitter.Fragments())
 
     self._GenerateCppHeader()
 
     self._cpp_impl_emitter.Emit(
         self._templates.Load('cpp_implementation.template'),
         INTERFACE=self._interface.id,
-        INCLUDES=''.join(['#include "%s.h"\n' %
-          k for k in self._cpp_impl_includes.keys()]),
+        INCLUDES=_GenerateCPPIncludes(self._cpp_impl_includes),
         CALLBACKS=self._cpp_definitions_emitter.Fragments(),
         RESOLVER=self._cpp_resolver_emitter.Fragments())
 
   def _GenerateCppHeader(self):
-    webcore_include = self._interface_type_info.webcore_include()
-    if webcore_include:
-      webcore_include = '#include "%s.h"\n' % webcore_include
-    else:
-      webcore_include = ''
+    webcore_includes = _GenerateCPPIncludes(self._interface_type_info.webcore_includes())
 
     if ('CustomToJS' in self._interface.ext_attrs or
         'CustomToJSObject' in self._interface.ext_attrs or
         'PureInterface' in self._interface.ext_attrs or
         'CPPPureInterface' in self._interface.ext_attrs or
         self._interface_type_info.custom_to_dart()):
       to_dart_value_template = (
           'Dart_Handle toDartValue($(WEBCORE_CLASS_NAME)* value);\n')
     else:
       to_dart_value_template = (
           'inline Dart_Handle toDartValue($(WEBCORE_CLASS_NAME)* value)\n'
           '{\n'
           '    return DartDOMWrapper::toDart<Dart$(INTERFACE)>(value);\n'
           '}\n')
     to_dart_value_emitter = emitter.Emitter()
     to_dart_value_emitter.Emit(
         to_dart_value_template,
         INTERFACE=self._interface.id,
         WEBCORE_CLASS_NAME=self._interface_type_info.native_type())
 
     self._cpp_header_emitter.Emit(
         self._templates.Load('cpp_header.template'),
         INTERFACE=self._interface.id,
-        WEBCORE_INCLUDE=webcore_include,
-        ADDITIONAL_INCLUDES='',
+        WEBCORE_INCLUDES=webcore_includes,
         WEBCORE_CLASS_NAME=self._interface_type_info.native_type(),
         TO_DART_VALUE=to_dart_value_emitter.Fragments(),
         DECLARATIONS=self._cpp_declarations_emitter.Fragments())
 
   def AddAttribute(self, getter, setter):
     # FIXME: Dartium does not support attribute event listeners. However, JS
     # implementation falls back to them when addEventListener is not available.
     # Make sure addEventListener is available in all EventTargets and remove
     # this check.
     if (getter or setter).type.id == 'EventListener':
@@ skipping 191 matching lines @@
     if 'CallWith' in operation.ext_attrs:
       call_with = operation.ext_attrs['CallWith']
       if call_with == 'ScriptExecutionContext':
         parameter_definitions_emitter.Emit(
             '        ScriptExecutionContext* context = DartUtilities::scriptExecutionContext();\n'
             '        if (!context)\n'
             '            return;\n')
         arguments.append('context')
       elif call_with == 'ScriptArguments|CallStack':
         raises_dart_exceptions = True
-        self._cpp_impl_includes['ScriptArguments'] = 1
-        self._cpp_impl_includes['ScriptCallStack'] = 1
-        self._cpp_impl_includes['V8Proxy'] = 1
-        self._cpp_impl_includes['v8'] = 1
+        self._cpp_impl_includes.add('DOMWindow')
+        self._cpp_impl_includes.add('ScriptArguments')
+        self._cpp_impl_includes.add('ScriptCallStack')
+        self._cpp_impl_includes.add('V8Proxy')
+        self._cpp_impl_includes.add('v8')
         parameter_definitions_emitter.Emit(
             '        v8::HandleScope handleScope;\n'
             '        v8::Context::Scope scope(V8Proxy::mainWorldContext(DartUtilities::domWindowForCurrentIsolate()->frame()));\n'
             '        Dart_Handle customArgument = Dart_GetNativeArgument(args, $INDEX);\n'
             '        RefPtr<ScriptArguments> scriptArguments(DartUtilities::createScriptArguments(customArgument, exception));\n'
             '        if (!scriptArguments)\n'
             '            goto fail;\n'
             '        RefPtr<ScriptCallStack> scriptCallStack(DartUtilities::createScriptCallStack());\n'
             '        if (!scriptCallStack->size())\n'
             '            return;\n',
@@ skipping 68 matching lines @@
         '    DartApiScope dartApiScope;\n'
         '$BODY'
         '}\n',
         CALLBACK_NAME=callback_name,
         BODY=body)
 
   def _GenerateParameterAdapter(self, emitter, idl_argument, index):
     type_info = GetIDLTypeInfo(idl_argument.type)
     (adapter_type, include_name) = type_info.parameter_adapter_info()
     if include_name:
-      self._cpp_impl_includes[include_name] = 1
+      self._cpp_impl_includes.add(include_name)
     flags = ''
     if (idl_argument.ext_attrs.get('Optional') == 'DefaultIsNullString' or
         ('Optional' in idl_argument.ext_attrs and 'Callback' in idl_argument.ext_attrs)):
       flags = ', DartUtilities::ConvertNullToDefaultValue'
     emitter.Emit(
         '\n'
         '        const $ADAPTER_TYPE $NAME(Dart_GetNativeArgument(args, $INDEX)$FLAGS);\n'
         '        if (!$NAME.conversionSuccessful()) {\n'
         '            exception = $NAME.exception();\n'
         '            goto fail;\n'
@@ skipping 28 matching lines @@
 
     return cpp_callback_name
 
   def _GenerateWebCoreReflectionAttributeName(self, attr):
     namespace = 'HTMLNames'
     svg_exceptions = ['class', 'id', 'onabort', 'onclick', 'onerror', 'onload',
                       'onmousedown', 'onmousemove', 'onmouseout', 'onmouseover',
                       'onmouseup', 'onresize', 'onscroll', 'onunload']
     if self._interface.id.startswith('SVG') and not attr.id in svg_exceptions:
       namespace = 'SVGNames'
-    self._cpp_impl_includes[namespace] = 1
+    self._cpp_impl_includes.add(namespace)
 
     attribute_name = attr.ext_attrs['Reflect'] or attr.id.lower()
     return 'WebCore::%s::%sAttr' % (namespace, attribute_name)
 
   def _GenerateWebCoreFunctionExpression(self, function_name, idl_node):
     if 'ImplementedBy' in idl_node.ext_attrs:
       return '%s::%s' % (idl_node.ext_attrs['ImplementedBy'], function_name)
     return '%s%s' % (self._interface_type_info.receiver(), function_name)
 
   def _GenerateWebCoreInvocation(self, function_expression, arguments,
       idl_return_type, attributes, raises_dom_exceptions):
     invocation_template = '        $FUNCTION_CALL;\n'
     if idl_return_type and idl_return_type.id != 'void':
       return_type_info = GetIDLTypeInfo(idl_return_type)
-      if return_type_info.conversion_include():
-        self._cpp_impl_includes[return_type_info.conversion_include()] = 1
+      self._cpp_impl_includes |= set(return_type_info.conversion_includes())

[antonm, 2012/03/01 15:44:50]

ditto

 
       # Generate C++ cast based on idl return type.
       conversion_cast = return_type_info.conversion_cast('$FUNCTION_CALL')
       if isinstance(return_type_info, SVGTearOffIDLTypeInfo):
         svg_primitive_types = ['SVGAngle', 'SVGLength', 'SVGMatrix',
             'SVGNumber', 'SVGPoint', 'SVGRect', 'SVGTransform']
         conversion_cast = '%s::create($FUNCTION_CALL)'
         if self._interface.id.startswith('SVGAnimated'):
           conversion_cast = 'static_cast<%s*>($FUNCTION_CALL)'
         elif return_type_info.idl_type() == 'SVGStringList':
@@ skipping 25 matching lines @@
           '        ExceptionCode ec = 0;\n'
           '$INVOCATION'
           '        if (UNLIKELY(ec)) {\n'
           '            exception = DartDOMWrapper::exceptionCodeToDartException(ec);\n'
           '            goto fail;\n'
           '        }\n',
           INVOCATION=invocation_template)
 
     if 'ImplementedBy' in attributes:
       arguments.insert(0, 'receiver')
-      self._cpp_impl_includes[attributes['ImplementedBy']] = 1
+      self._cpp_impl_includes.add(attributes['ImplementedBy'])
 
     return emitter.Format(invocation_template,
         FUNCTION_CALL='%s(%s)' % (function_expression, ', '.join(arguments)))
+
+def _GenerateCPPIncludes(includes):
+  return ''.join(['#include "%s.h"\n' % include for include in includes])