Rename Dartium dart:html implementation classes.

lib/html/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
 from generator import *
 from systemhtml import SecureOutputType
 
 class DartiumBackend(object):
   """Generates Dart implementation for one DOM IDL interface."""
 
   def __init__(self, interface, cpp_library_emitter, options):
     self._interface = interface
     self._cpp_library_emitter = cpp_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)
 
-  def ImplementationClassName(self):
-    return self._ImplClassName(self._interface.id)
-
   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 {}
 
   def GenerateCallback(self, info):
@@ skipping 130 matching lines @@
     function_expression = '%s::%s' % (self._interface_type_info.native_type(), create_function)
     self._GenerateNativeCallback(
         'constructorCallback',
         False,
         function_expression,
         self._interface,
         constructor_info.idl_args,
         self._interface.id,
         'ConstructorRaisesException' in ext_attrs)
 
-  def _ImplClassName(self, interface_name):
-    return '_%sImpl' % interface_name
-
   def BaseClassName(self):
     root_class = 'NativeFieldWrapperClass1'
 
     if not self._interface.parents:
       return root_class
 
     supertype = self._interface.parents[0].type.id
 
     if IsPureInterface(supertype):    # The class is a root.
       return root_class
 
     # FIXME: We're currently injecting List<..> and EventTarget as
     # supertypes in dart.idl. We should annotate/preserve as
     # attributes instead.  For now, this hack lets the self._interfaces
     # inherit, but not the classes.
     # List methods are injected in AddIndexer.
     if IsDartListType(supertype) or IsDartCollectionType(supertype):
       return root_class
 
-    return self._ImplClassName(supertype)
+    return self._type_registry.TypeInfo(supertype).implementation_name()
 
   ATTRIBUTES_OF_CONSTRUCTABLE = set([
     'CustomConstructor',
     'V8CustomConstructor',
     'Constructor',
     'NamedConstructor'])
 
   def _IsConstructable(self):
     ext_attrs = self._interface.ext_attrs
 
@@ skipping 24 matching lines @@
 
   def FinishInterface(self):
     self._GenerateCPPHeader()
 
     self._cpp_impl_emitter.Emit(
         self._template_loader.Load('cpp_implementation.template'),
         INTERFACE=self._interface.id,
         INCLUDES=self._GenerateCPPIncludes(self._cpp_impl_includes),
         CALLBACKS=self._cpp_definitions_emitter.Fragments(),
         RESOLVER=self._cpp_resolver_emitter.Fragments(),
-        DART_IMPLEMENTATION_CLASS=self.ImplementationClassName())
+        DART_IMPLEMENTATION_CLASS=self._interface_type_info.implementation_name())
 
   def _GenerateCPPHeader(self):
     to_native_emitter = emitter.Emitter()
     if self._interface_type_info.custom_to_native():
       to_native_emitter.Emit(
           '    static PassRefPtr<NativeType> toNative(Dart_Handle handle, Dart_Handle& exception);\n')
     else:
       to_native_emitter.Emit(
           '    static NativeType* toNative(Dart_Handle handle, Dart_Handle& exception)\n'
           '    {\n'
@@ skipping 629 matching lines @@
   def EmitResolver(self, template, output_dir):
     file_path = os.path.join(output_dir, 'DartResolver.cpp')
     includes_emitter, body_emitter = self._emitters.FileEmitter(file_path).Emit(template)
     for header_file in self._headers_list:
       path = os.path.relpath(header_file, output_dir)
       includes_emitter.Emit('#include "$PATH"\n', PATH=path)
       body_emitter.Emit(
           '    if (Dart_NativeFunction func = $CLASS_NAME::resolver(name, argumentCount))\n'
           '        return func;\n',
           CLASS_NAME=os.path.splitext(os.path.basename(path))[0])