Stop generating dart:blink from dart scripts

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 118 matching lines @@
 }
 
 _cpp_overloaded_callback_map = {
   ('DOMURL', 'createObjectUrlFromSourceCallback'): 'URLMediaSource',
   ('DOMURL', 'createObjectUrlFromStreamCallback'): 'URLMediaStream',
   ('DOMURL', '_createObjectUrlFromWebKitSourceCallback'): 'URLMediaSource',
   ('DOMURL', '_createObjectURL_2Callback'): 'URLMediaSource',
   ('DOMURL', '_createObjectURL_3Callback'): 'URLMediaStream',
 }
 
-_blink_1916_rename_map = {
-  'NavigatorID': 'Navigator',
-  'CanvasRenderingContext' : 'CanvasRenderingContext2D',
-  'Clipboard': 'DataTransfer',
-  'Player': 'AnimationPlayer',
-  'Algorithm': 'KeyAlgorithm',
-  'any': 'ScriptValue',
-  'URLUtils': 'URL',
-  'URLUtilsReadOnly': 'WorkerLocation',
-  'Path': 'Path2D'
-}
-
 _cpp_partial_map = {}
 
 _cpp_no_auto_scope_list = set([
   ('Document', 'body', 'Getter'),
   ('Document', 'getElementById', 'Callback'),
   ('Document', 'getElementsByName', 'Callback'),
   ('Document', 'getElementsByTagName', 'Callback'),
   ('Element', 'getAttribute', 'Callback'),
   ('Element', 'getAttributeNS', 'Callback'),
   ('Element', 'id', 'Getter'),
@@ skipping 162 matching lines @@
   seq_match = _sequence_matcher.match(interface_id)
   if seq_match is not None:
     t = TypeIdToBlinkName(seq_match.group(1), database)
     return "sequence<%s>" % t
 
   arr_match = array_type(interface_id)
   if arr_match is not None:
     t = TypeIdToBlinkName(arr_match, database)
     return "%s[]" % t
 
-  if interface_id in _blink_1916_rename_map:
-    interface_id = _blink_1916_rename_map[interface_id]
   return interface_id
 
 def _GetCPPTypeName(interface_name, callback_name, cpp_name):
   # TODO(vsm): We need to track the original IDL file name in order to recover
   # the proper CPP name.
 
   cpp_tuple = (interface_name, callback_name)
   if cpp_tuple in _cpp_callback_map:
     cpp_type_name = _cpp_callback_map[cpp_tuple]
   elif (interface_name, cpp_name) in _cpp_overloaded_callback_map:
@@ skipping 23 matching lines @@
     t = "SEQ_%s_SEQ" % t2
     return t
 
   arr_match = array_type(t)
   if arr_match is not None:
     t = EncodeType(arr_match)
     return "A_%s_A" % t
 
   return _type_encoding_map.get(t) or t
 
-# FIXME(leafp) This should really go elsewhere.  I think the right thing
-# to do is to add support in the DartLibraries objects in systemhtml
-# for emitting top level code in libraries.  This can then just be a
-# normal use of that kind of object
-def GetNativeLibraryEmitter(emitters, template_loader, 
-                            dartium_output_dir, dart_output_dir,
-                            auxiliary_dir):
-    def massage_path(path):
-        # The most robust way to emit path separators is to use / always.
-        return path.replace('\\', '/')
-    template = template_loader.Load('_blink_dartium.darttemplate')
-    dart_path = os.path.join(dartium_output_dir, '_blink_dartium.dart')
-    library_emitter = emitters.FileEmitter(dart_path)
-    auxiliary_dir = os.path.relpath(auxiliary_dir, dartium_output_dir)
-    emitter = \
-        library_emitter.Emit(template,
-                             AUXILIARY_DIR=massage_path(auxiliary_dir))
-    return emitter
-
 class DartiumBackend(HtmlDartGenerator):
   """Generates Dart implementation for one DOM IDL interface."""
 
-  def __init__(self, interface, native_library_emitter,
+  def __init__(self, interface, 
                cpp_library_emitter, options):
     super(DartiumBackend, self).__init__(interface, options, True)
 
     self._interface = interface
     self._cpp_library_emitter = cpp_library_emitter
-    self._native_library_emitter = native_library_emitter
     self._database = options.database
     self._template_loader = options.templates
     self._type_registry = options.type_registry
     self._interface_type_info = self._type_registry.TypeInfo(self._interface.id)
     self._metadata = options.metadata
     # These get initialized by StartInterface
-    self._blink_entries = None
     self._cpp_header_emitter = None
     self._cpp_impl_emitter = None
     self._members_emitter = None
     self._cpp_declarations_emitter = None
     self._cpp_impl_includes = None
     self._cpp_definitions_emitter = None
     self._cpp_resolver_emitter = None
-    self._native_class_emitter = None
 
   def ImplementsMergedMembers(self):
     # We could not add merged functions to implementation class because
     # underlying c++ object doesn't implement them. Merged functions are
     # generated on merged interface implementation instead.
     return False
 
   def CustomJSMembers(self):
     return {}
 
@@ skipping 208 matching lines @@
           INTERFACE_NAME=self._interface.id)
 
       self._cpp_impl_includes.add('"DartArrayBufferViewCustom.h"');
       self._cpp_definitions_emitter.Emit(
         '\n'
         'static void constructorCallback(Dart_NativeArguments args)\n'
         '{\n'
         '    WebCore::DartArrayBufferViewInternal::constructWebGLArray<Dart$(INTERFACE_NAME)>(args);\n'
         '}\n',
         INTERFACE_NAME=self._interface.id);
-    self._native_class_emitter = self._native_library_emitter.Emit(
-      '\n'
-      'class $INTERFACE_NAME {'
-      '$!METHODS'
-      '}\n',
-      INTERFACE_NAME=DeriveBlinkClassName(self._interface.id))
-    # TODO(vsm): Should we check for collisions between EventConstructors and others?
-    # Should we unify at some point?
-    if 'EventConstructor' in self._interface.ext_attrs:
-        self._native_class_emitter.Emit(
-            '\n'
-            '  static constructorCallback_2(type, options) native "$(INTERFACE_NAME)_constructorCallback";\n',
-            INTERFACE_NAME=self._interface.id
-            )
-    self._blink_entries = {}
 
   def _EmitConstructorInfrastructure(self,
       constructor_info, cpp_prefix, cpp_suffix, factory_method_name,
       arguments=None, emit_to_native=False, is_custom=False):
 
     constructor_callback_cpp_name = cpp_prefix + cpp_suffix
 
     if arguments is None:
         arguments = constructor_info.idl_args[0]
         argument_count = len(arguments)
     else:
         argument_count = len(arguments)
 
     typed_formals = constructor_info.ParametersAsArgumentList(argument_count)
     parameters = constructor_info.ParametersAsStringOfVariables(argument_count)
     interface_name =  self._interface_type_info.interface_name()
 
     dart_native_name, constructor_callback_id = \
         self.DeriveNativeEntry(cpp_suffix, 'Constructor', argument_count)
-    if dart_native_name not in self._blink_entries:
-      entry = '  static %s(%s) native "%s";' % \
-              (dart_native_name, parameters, constructor_callback_id)
-      self._blink_entries[dart_native_name] = entry
 
     # Then we emit the impedance matching wrapper to call out to the
     # toplevel wrapper
     if not emit_to_native:
         toplevel_name = \
             self.DeriveQualifiedBlinkName(self._interface.id,
                                           dart_native_name)
         self._members_emitter.Emit(
             '\n  @DocsEditable()\n'
             '  static $INTERFACE_NAME $FACTORY_METHOD_NAME($PARAMETERS) => '
@@ skipping 79 matching lines @@
 
   def FinishInterface(self):
     interface = self._interface
     if interface.parents:
       supertype = '%sClassId' % interface.parents[0].type.id
     else:
       supertype = '-1'
 
     self._GenerateCPPHeader()
 
-    for entry in sorted(self._blink_entries):
-      self._native_class_emitter.Emit(
-        '\n' + self._blink_entries[entry] + '\n')
-
-    self._native_class_emitter.Emit('\n')
-
     self._cpp_impl_emitter.Emit(
         self._template_loader.Load('cpp_implementation.template'),
         INTERFACE=self._interface.id,
         SUPER_INTERFACE=supertype,
         INCLUDES=self._GenerateCPPIncludes(self._cpp_impl_includes),
         CALLBACKS=self._cpp_definitions_emitter.Fragments(),
         RESOLVER=self._cpp_resolver_emitter.Fragments(),
         WEBCORE_CLASS_NAME=self._interface_type_info.native_type(),
         WEBCORE_CLASS_NAME_ESCAPED=
         self._interface_type_info.native_type().replace('<', '_').replace('>', '_'),
@@ skipping 866 matching lines @@
         native_binding_id = TypeIdToBlinkName(native_binding_id, self._database)
         native_binding = \
             '%s_%s_%s' % (native_binding_id, idl_name, native_suffix)
 
     if not static:
         formals = ", ".join(['mthis'] + parameters)
         actuals = ", ".join(['this'] + parameters)
     else:
         formals = ", ".join(parameters)
         actuals = ", ".join(parameters)
-    if dart_native_name not in self._blink_entries:
-      entry = '  static %s(%s) native "%s";' % \
-              (dart_native_name, formals, native_binding)
-      self._blink_entries[dart_native_name] = entry
 
     if not emit_to_native:
         caller_emitter = self._members_emitter
         full_dart_name = \
             self.DeriveQualifiedBlinkName(self._interface.id,
                                           dart_native_name)
         if IsPureInterface(self._interface.id):
             caller_emitter.Emit(
                 '\n'
                 '  $METADATA$DART_DECLARATION;\n',
@@ skipping 278 matching lines @@
 
 def _IsCustom(op_or_attr):
   assert(isinstance(op_or_attr, IDLMember))
   return 'Custom' in op_or_attr.ext_attrs or 'DartCustom' in op_or_attr.ext_attrs
 
 def _IsCustomValue(op_or_attr, value):
   if _IsCustom(op_or_attr):
     return op_or_attr.ext_attrs.get('Custom') == value \
            or op_or_attr.ext_attrs.get('DartCustom') == value
   return False