Sky: Add a CustomDart attribute to the IDL compiler, and use that with Canvas

sky/engine/bindings/scripts/code_generator_dart.py

 # Copyright (C) 2013 Google Inc. All rights reserved.
 #
 # 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
 # copyright notice, this list of conditions and the following disclaimer
@@ skipping 88 matching lines @@
             for interface_name, interface_info in interfaces_info.iteritems()
             if interface_info['is_callback_interface']))
         IdlType.set_implemented_as_interfaces(dict(
             (interface_name, interface_info['implemented_as'])
             for interface_name, interface_info in interfaces_info.iteritems()
             if interface_info['implemented_as']))
         dart_types.set_component_dirs(dict(
             (interface_name, interface_info['component_dir'])
             for interface_name, interface_info in interfaces_info.iteritems()))
 
-    def generate_code(self, definitions, interface_name, idl_pickle_filename,
-                      only_if_changed):
+    def generate_code(self, definitions, interface_name,
+                      idl_filename, idl_pickle_filename, only_if_changed):
         """Returns .h/.cpp/.dart code as (header_text, cpp_text, dart_text)."""
         try:
             interface = definitions.interfaces[interface_name]
         except KeyError:
             raise Exception('%s not in IDL definitions' % interface_name)
 
         # Store other interfaces for introspection
         interfaces.update(definitions.interfaces)
 
         # Set local type info
@@ skipping 21 matching lines @@
         template_contents['code_generator'] = module_pyname
 
         # Add includes for interface itself and any dependencies
         interface_info = self.interfaces_info[interface_name]
         template_contents['header_includes'].add(interface_info['include_path'])
         template_contents['header_includes'] = sorted(template_contents['header_includes'])
         includes.update(interface_info.get('dependencies_include_paths', []))
 
         template_contents['cpp_includes'] = sorted(includes)
 
+        # If CustomDart is set, read the custom dart file and add it to our
+        # template parameters.
+        if 'CustomDart' in interface.extended_attributes:
+          dart_filename = os.path.join(os.path.dirname(idl_filename),
+                                       interface.name + ".dart")
+          with open(dart_filename) as dart_file:
+              custom_dartcode = dart_file.read()
+              template_contents['custom_dartcode'] = custom_dartcode
+
         idl_world = {'interface': None, 'callback': None}
 
         # Load the pickle file for this IDL.
         if os.path.isfile(idl_pickle_filename):
             with open(idl_pickle_filename) as idl_pickle_file:
                 idl_global_data = pickle.load(idl_pickle_file)
                 idl_pickle_file.close()
             idl_world['interface'] = idl_global_data['interface']
             idl_world['callback'] = idl_global_data['callback']
 
         if 'interface_name' in template_contents:
             interface_global = {'component_dir': interface_info['component_dir'],
                                 'name': template_contents['interface_name'],
                                 'parent_interface': template_contents['parent_interface'],
                                 'is_active_dom_object': template_contents['is_active_dom_object'],
                                 'has_resolver': template_contents['interface_name'],
                                 'native_entries': sorted(template_contents['native_entries'], key=lambda(x): x['blink_entry']),
                                }
             idl_world['interface'] = interface_global
         else:
             callback_global = {'name': template_contents['cpp_class']}
             idl_world['callback'] = callback_global
 
         write_pickle_file(idl_pickle_filename,  idl_world, only_if_changed)
 
         # Render Jinja templates
         header_text = header_template.render(template_contents)
         cpp_text = cpp_template.render(template_contents)
         dart_text = dart_template.render(template_contents)
+
         return header_text, cpp_text, dart_text
 
     def load_global_pickles(self, global_entries):
         # List of all interfaces and callbacks for global code generation.
         world = {'interfaces': [], 'callbacks': []}
 
         # Load all pickled data for each interface.
         for (directory, file_list) in global_entries:
             for idl_filename in file_list:
                 interface_name = idl_filename_to_interface_name(idl_filename)
@@ skipping 80 matching lines @@
 
     # Create a dummy file as output for the build system,
     # since filenames of individual cache files are unpredictable and opaque
     # (they are hashes of the template path, which varies based on environment)
     with open(dummy_filename, 'w') as dummy_file:
         pass  # |open| creates or touches the file
 
 
 if __name__ == '__main__':
     sys.exit(main(sys.argv))