Changed to use JSInterop

tools/dom/scripts/dartdomgenerator.py

 #!/usr/bin/python
 # Copyright (c) 2011, 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 is the entry point to create Dart APIs from the IDL database."""
 
 import css_code_generator
 import os
 import sys
@@ skipping 44 matching lines @@
 
 sys.path.append(os.path.join(os.path.dirname(__file__), '..', '..'))
 
 import utils
 
 
 _logger = logging.getLogger('dartdomgenerator')
 
 class GeneratorOptions(object):
   def __init__(self, templates, database, type_registry, renamer,
-      metadata):
+      metadata, dart_js_interop):
     self.templates = templates
     self.database = database
     self.type_registry = type_registry
     self.renamer = renamer
     self.metadata = metadata;
+    self.dart_js_interop = dart_js_interop
 
 def LoadDatabase(database_dir, use_database_cache):
   common_database = database.Database(database_dir)
   if use_database_cache:
     common_database.LoadFromCache()
   else:
     common_database.Load()
   return common_database
 
 def GenerateFromDatabase(common_database, dart2js_output_dir,
                          dartium_output_dir, update_dom_metadata=False,
-                         logging_level=logging.WARNING):
+                         logging_level=logging.WARNING, dart_js_interop=False):
+  print '\n ----- Accessing DOM using %s -----\n' % ('dart:js' if dart_js_interop else 'C++')
+
   start_time = time.time()
 
   current_dir = os.path.dirname(__file__)
   auxiliary_dir = os.path.join(current_dir, '..', 'src')
   template_dir = os.path.join(current_dir, '..', 'templates')
 
   _logger.setLevel(logging_level)
 
   generator = dartgenerator.DartGenerator(logging_level)
   generator.LoadAuxiliary(auxiliary_dir)
@@ skipping 13 matching lines @@
   metadata = DartMetadata(
       os.path.join(current_dir, '..', 'dom.json'),
       os.path.join(current_dir, '..', 'docs', 'docs.json'),
       logging_level)
   renamer = HtmlRenamer(webkit_database, metadata)
   type_registry = TypeRegistry(webkit_database, renamer)
 
   print 'GenerateFromDatabase %s seconds' % round((time.time() - start_time), 2)
 
   def RunGenerator(dart_libraries, dart_output_dir,
-                   template_loader, backend_factory):
+                   template_loader, backend_factory, dart_js_interop):
     options = GeneratorOptions(
         template_loader, webkit_database, type_registry, renamer,
-        metadata)
+        metadata, dart_js_interop)
     dart_library_emitter = DartLibraryEmitter(
         emitters, dart_output_dir, dart_libraries)
     event_generator = HtmlEventGenerator(webkit_database, renamer, metadata,
         template_loader)
 
     def generate_interface(interface):
       backend = backend_factory(interface)
       interface_generator = HtmlDartInterfaceGenerator(
           options, dart_library_emitter, event_generator, interface, backend)
       interface_generator.Generate()
 
     generator.Generate(webkit_database, common_database, generate_interface)
 
-    dart_library_emitter.EmitLibraries(auxiliary_dir)
+    dart_library_emitter.EmitLibraries(auxiliary_dir, dart_js_interop)
 
   if dart2js_output_dir:
     template_paths = ['html/dart2js', 'html/impl', 'html/interface', '']
     template_loader = TemplateLoader(template_dir,
                                      template_paths,
-                                     {'DARTIUM': False, 'DART2JS': True})
+                                     {'DARTIUM': False,
+                                      'DART2JS': True,
+                                      'JSINTEROP': False})
     backend_options = GeneratorOptions(
         template_loader, webkit_database, type_registry, renamer,
-        metadata)
+        metadata, dart_js_interop)
     backend_factory = lambda interface:\
         Dart2JSBackend(interface, backend_options, logging_level)
 
     dart_output_dir = os.path.join(dart2js_output_dir, 'dart')
     dart_libraries = DartLibraries(
-        HTML_LIBRARY_NAMES, template_loader, 'dart2js', dart2js_output_dir)
+        HTML_LIBRARY_NAMES, template_loader, 'dart2js', dart2js_output_dir, dart_js_interop)
 
     print '\nGenerating dart2js:\n'
     start_time = time.time()
 
     RunGenerator(dart_libraries, dart_output_dir, template_loader,
-                 backend_factory)
+                 backend_factory, dart_js_interop)
 
     print 'Generated dart2js in %s seconds' % round(time.time() - start_time, 2)
 
   if dartium_output_dir:
     template_paths = ['html/dartium', 'html/impl', 'html/interface', '']
     template_loader = TemplateLoader(template_dir,
                                      template_paths,
-                                     {'DARTIUM': True, 'DART2JS': False})
+                                     {'DARTIUM': True,
+                                      'DART2JS': False,
+                                      'JSINTEROP': dart_js_interop})
     backend_options = GeneratorOptions(
         template_loader, webkit_database, type_registry, renamer,
-        metadata)
+        metadata, dart_js_interop)
     cpp_output_dir = os.path.join(dartium_output_dir, 'cpp')
     cpp_library_emitter = CPPLibraryEmitter(emitters, cpp_output_dir)
     dart_output_dir = os.path.join(dartium_output_dir, 'dart')
     backend_factory = lambda interface:\
         DartiumBackend(interface, cpp_library_emitter, backend_options)
     dart_libraries = DartLibraries(
-        HTML_LIBRARY_NAMES, template_loader, 'dartium', dartium_output_dir)
+        HTML_LIBRARY_NAMES, template_loader, 'dartium', dartium_output_dir, dart_js_interop)
 
     print '\nGenerating dartium:\n'
     start_time = time.time()
 
-    RunGenerator(dart_libraries, dart_output_dir,
-                 template_loader, backend_factory)
+    RunGenerator(dart_libraries, dart_output_dir, template_loader,
+                 backend_factory, dart_js_interop)
     print 'Generated dartium in %s seconds' % round(time.time() - start_time, 2)
 
     cpp_library_emitter.EmitDerivedSources(
         template_loader.Load('cpp_derived_sources.template'),
         dartium_output_dir)
     cpp_library_emitter.EmitResolver(
         template_loader.Load('cpp_resolver.template'), dartium_output_dir)
     cpp_library_emitter.EmitClassIdTable(
         webkit_database, dartium_output_dir, type_registry, renamer)
     emitters.Flush()
@@ skipping 43 matching lines @@
                     help='''Update the metadata list of DOM APIs''')
   parser.add_option('--verbose', dest='logging_level',
                     action='store_false', default=logging.WARNING,
                     help='Output all informational messages')
   parser.add_option('--examine', dest='examine_idls',
                     action='store_true', default=None,
                     help='Analyze IDL files')
   parser.add_option('--logging', dest='logging', type='int',
                     action='store', default=logging.NOTSET,
                     help='Level of logging 20 is Info, 30 is Warnings, 40 is Errors')
+  parser.add_option('--gen-interop', dest='dart_js_interop',
+                    action='store_true', default=False,
+                    help='Use Javascript objects (dart:js) accessing the DOM in _blink')
 
   (options, args) = parser.parse_args()
 
   current_dir = os.path.dirname(__file__)
   database_dir = os.path.join(current_dir, '..', 'database')
   logging.config.fileConfig(os.path.join(current_dir, 'logging.conf'))
   systems = options.systems.split(',')
 
   output_dir = options.output_dir or os.path.join(
       current_dir, '..', '..', utils.GetBuildDir(utils.GuessOS()),
@@ skipping 10 matching lines @@
     if options.logging == logging.NOTSET else options.logging
 
   start_time = time.time()
 
   UpdateCssProperties()
 
   # Parse the IDL and create the database.
   database = fremontcutbuilder.main(options.parallel, logging_level=logging_level, examine_idls=options.examine_idls)
 
   GenerateFromDatabase(database, dart2js_output_dir, dartium_output_dir,
-      options.update_dom_metadata, logging_level)
+      options.update_dom_metadata, logging_level, options.dart_js_interop)
 
   file_generation_start_time = time.time()
 
   if 'htmldart2js' in systems:
     _logger.info('Generating dart2js single files.')
 
     for library_name in HTML_LIBRARY_NAMES:
       GenerateSingleFile(
           os.path.join(dart2js_output_dir, '%s_dart2js.dart' % library_name),
           os.path.join('..', '..', '..', 'sdk', 'lib', library_name, 'dart2js'))
 
   if 'htmldartium' in systems:
     _logger.info('Generating dartium single files.')
     file_generation_start_time = time.time()
 
     for library_name in HTML_LIBRARY_NAMES:
       GenerateSingleFile(
           os.path.join(dartium_output_dir, '%s_dartium.dart' % library_name),
           os.path.join('..', '..', '..', 'sdk', 'lib', library_name, 'dartium'))
 
   print '\nGenerating single file %s seconds' % round(time.time() - file_generation_start_time, 2)
 
   end_time = time.time()
 
   print '\nDone (dartdomgenerator) %s seconds' % round(end_time - start_time, 2)
 
 if __name__ == '__main__':
   sys.exit(main())