Get rid of webkit renames.

lib/html/scripts/databasebuilder.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.
 
 import copy
 import database
 import idlparser
 import logging
 import multiprocessing
@@ skipping 15 matching lines @@
 _MODULE_ANNOTATION_ATTR_NAME = 'module'
 
 
 class DatabaseBuilderOptions(object):
   """Used in specifying options when importing new interfaces"""
 
   def __init__(self,
       idl_syntax=idlparser.WEBIDL_SYNTAX,
       idl_defines=[],
       source=None, source_attributes={},
-      type_rename_map={},
       rename_operation_arguments_on_merge=False,
       add_new_interfaces=True,
       obsolete_old_declarations=False):
     """Constructor.
     Args:
       idl_syntax -- the syntax of the IDL file that is imported.
       idl_defines -- list of definitions for the idl gcc pre-processor
       source -- the origin of the IDL file, used for annotating the
         database.
       source_attributes -- this map of attributes is used as
         annotation attributes.
       rename_operation_arguments_on_merge -- if True, will rename
         operation arguments when merging using the new name rather
         than the old.
       add_new_interfaces -- when False, if an interface is a new
         addition, it will be ignored.
       obsolete_old_declarations -- when True, if a declaration
         from a certain source is not re-declared, it will be removed.
     """
     self.source = source
     self.source_attributes = source_attributes
     self.idl_syntax = idl_syntax
     self.idl_defines = idl_defines
-    self.type_rename_map = type_rename_map
     self.rename_operation_arguments_on_merge = \
         rename_operation_arguments_on_merge
     self.add_new_interfaces = add_new_interfaces
     self.obsolete_old_declarations = obsolete_old_declarations
 
 
 def _load_idl_file(file_name, import_options, result_queue):
   """Loads an IDL file into memory"""
   idl_parser = idlparser.IDLParser(import_options.idl_syntax)
 
@@ skipping 39 matching lines @@
   def _strip_ext_attributes(self, idl_file):
     """Strips unuseful extended attributes."""
     for ext_attrs in idl_file.all(IDLExtAttrs):
       # TODO: Decide which attributes are uninteresting.
       pass
 
   def _rename_types(self, idl_file, import_options):
     """Rename interface and type names with names provided in the
     options. Also clears scopes from scoped names"""
 
-    def rename(name):
-      name_parts = name.split('::')
-      name = name_parts[-1]
-      if name in import_options.type_rename_map:
-        name = import_options.type_rename_map[name]
-      return name
+    strip_modules = lambda name: name.split('::')[-1]
 
     def rename_node(idl_node):
-      idl_node.reset_id(rename(idl_node.id))
+      idl_node.reset_id(strip_modules(idl_node.id))
 
     def rename_ext_attrs(ext_attrs_node):
       for type_valued_attribute_name in ['Supplemental']:
         if type_valued_attribute_name in ext_attrs_node:
           value = ext_attrs_node[type_valued_attribute_name]
           if isinstance(value, str):
-            ext_attrs_node[type_valued_attribute_name] = rename(value)
+            ext_attrs_node[type_valued_attribute_name] = strip_modules(value)
 
     map(rename_node, idl_file.all(IDLInterface))
     map(rename_node, idl_file.all(IDLType))
     map(rename_ext_attrs, idl_file.all(IDLExtAttrs))
 
   def _annotate(self, interface, module_name, import_options):
     """Adds @ annotations based on the source and source_attributes
     members of import_options."""
 
     source = import_options.source
@@ skipping 417 matching lines @@
               if (name in top_level_annotation
                   and value == top_level_annotation[name]):
                 del annotation[name]
 
         map(normalize, interface.parents)
         map(normalize, interface.constants)
         map(normalize, interface.attributes)
         map(normalize, interface.operations)
 
   def fetch_constructor_data(self, options):
-    window_interface = self._database.GetInterface('Window')
+    window_interface = self._database.GetInterface('DOMWindow')
     for attr in window_interface.attributes:
       type = attr.type.id
       if not type.endswith('Constructor'):
         continue
       type = re.sub('(Constructor)+$', '', type)
       # TODO(antonm): Ideally we'd like to have pristine copy of WebKit IDLs and fetch
       # this information directly from it.  Unfortunately right now database is massaged
       # a lot so it's difficult to maintain necessary information on DOMWindow itself.
-      interface = self._database.GetInterface(options.type_rename_map.get(type, type))
+      interface = self._database.GetInterface(type)
       if 'V8EnabledPerContext' in attr.ext_attrs:
         interface.ext_attrs['synthesizedV8EnabledPerContext'] = \
             attr.ext_attrs['V8EnabledPerContext']
       if 'V8EnabledAtRuntime' in attr.ext_attrs:
         interface.ext_attrs['synthesizedV8EnabledAtRuntime'] = \
             attr.ext_attrs['V8EnabledAtRuntime'] or attr.id