Refactor dart:_blink into classes to improve startup time

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 357 matching lines @@
     cpp_type_name = _cpp_callback_map[cpp_tuple]
   elif (interface_name, cpp_name) in _cpp_overloaded_callback_map:
     cpp_type_name = _cpp_overloaded_callback_map[(interface_name, cpp_name)]
   else:
     cpp_type_name = interface_name
   return cpp_type_name
 
 def DeriveQualifiedName(library_name, name):
     return library_name + "." + name
 
-def DeriveNativeName(interface_name, name, suffix):
-    fields = ["Native", interface_name, name]
-    if suffix != "":
-        fields.append(suffix)
-    return "_".join(fields)
+def DeriveBlinkClassName(name):
+    return "Blink" + name
 
 def DeriveResolverString(interface_id, operation_id, native_suffix, type_ids, database, is_custom):
     type_string = \
         "_".join(map(lambda type_id : TypeIdToBlinkName(type_id, database), type_ids))
     if native_suffix:
         operation_id = "%s_%s" % (operation_id, native_suffix)
     if is_custom:
         components = \
             [TypeIdToBlinkName(interface_id, database), operation_id]
     else:
@@ skipping 29 matching lines @@
     super(DartiumBackend, self).__init__(interface, options, dart_use_blink)
 
     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
-    self._native_library_name = "_blink"
     # These get initialized by StartInterface
     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 111 matching lines @@
     if interface_name == self._interface.id or not self._database.HasInterface(interface_name):
       template_file = 'impl_%s.darttemplate' % interface_name
       template = self._template_loader.TryLoad(template_file)
     if not template:
       template = self._template_loader.Load('dart_implementation.darttemplate')
     return template
 
   def RootClassName(self):
     return 'NativeFieldWrapperClass2'
 
+  def DeriveNativeName(self, name, suffix=""):
+      fields = ['$' + name]
+      if suffix != "":
+          fields.append(suffix)
+      return "_".join(fields)
+
+  def DeriveQualifiedBlinkName(self, interface_name, name):
+      return DeriveQualifiedName(
+          "_blink", DeriveQualifiedName(DeriveBlinkClassName(interface_name),
+                                        name))
+
   def NativeSpec(self):
     return ''
 
   def StartInterface(self, members_emitter):
     # Create emitters for c++ implementation.
     if not IsPureInterface(self._interface.id) and \
         not IsCustomType(self._interface.id):
       self._cpp_header_emitter = self._cpp_library_emitter.CreateHeaderEmitter(
         self._interface.id,
         self._renamer.GetLibraryName(self._interface))
@@ skipping 29 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);
+    if self._dart_use_blink:
+        self._native_class_emitter = self._native_library_emitter.Emit(
+          '\n'
+          'class $INTERFACE_NAME {'
+          '$!METHODS'
+          '}\n',
+          INTERFACE_NAME=DeriveBlinkClassName(self._interface.id))
 
   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:
         if self._dart_use_blink:
             arguments = constructor_info.idl_args[0]
@@ skipping 10 matching lines @@
     if self._dart_use_blink:
         type_ids = [p.type.id for p in arguments[:argument_count]]
         constructor_callback_id = \
             DeriveResolverString(self._interface.id, cpp_suffix, None, type_ids, self._database, is_custom)
     else:
         constructor_callback_id = self._interface.id + '_' + constructor_callback_cpp_name
 
     if self._dart_use_blink:
         # First we emit the toplevel function
         dart_native_name = \
-            DeriveNativeName(self._interface.id, constructor_callback_cpp_name, "")
+            self.DeriveNativeName(constructor_callback_cpp_name)
         if constructor_callback_id in _cpp_resolver_string_map:
             constructor_callback_id = \
                 _cpp_resolver_string_map[constructor_callback_id]
-        self._native_library_emitter.Emit(
+        self._native_class_emitter.Emit(
             '\n'
-            '$FACTORY_METHOD_NAME($PARAMETERS) native "$ID";\n',
+            '  static $FACTORY_METHOD_NAME($PARAMETERS) native "$ID";\n',
             FACTORY_METHOD_NAME=dart_native_name,
             PARAMETERS=parameters,
             ID=constructor_callback_id)
 
         # 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) => '
                 '$TOPLEVEL_NAME($OUTPARAMETERS);\n',
                 INTERFACE_NAME=self._interface_type_info.interface_name(),
                 FACTORY_METHOD_NAME=factory_method_name,
                 PARAMETERS=typed_formals,
-                TOPLEVEL_NAME=DeriveQualifiedName(self._native_library_name,
-                                                  dart_native_name),
+                TOPLEVEL_NAME=toplevel_name,
                 OUTPARAMETERS=parameters)
     else:
         self._members_emitter.Emit(
             '\n  @DocsEditable()\n'
             '  static $INTERFACE_NAME $FACTORY_METHOD_NAME($PARAMETERS) '
             'native "$ID";\n',
             INTERFACE_NAME=self._interface_type_info.interface_name(),
             FACTORY_METHOD_NAME=factory_method_name,
             PARAMETERS=typed_formals,
             ID=constructor_callback_id)
@@ skipping 377 matching lines @@
     #
     dart_element_type = self._DartType(element_type)
     if self._HasNativeIndexGetter():
       self._EmitNativeIndexGetter(dart_element_type)
     elif self._HasExplicitIndexedGetter():
       self._EmitExplicitIndexedGetter(dart_element_type)
     else:
       if self._dart_use_blink:
           is_custom = any((op.id == 'item' and 'Custom' in op.ext_attrs) for op in self._interface.operations)
           dart_native_name = \
-              DeriveNativeName(self._interface.id, "NativeIndexed", "Getter")
+              self.DeriveNativeName("NativeIndexed", "Getter")
           # First emit a toplevel function to do the native call
           # Calls to this are emitted elsewhere,
           resolver_string = \
               DeriveResolverString(self._interface.id, "item", "Callback",
                                    ["unsigned long"], self._database, is_custom)
           if resolver_string in _cpp_resolver_string_map:
               resolver_string = \
                   _cpp_resolver_string_map[resolver_string]
-          self._native_library_emitter.Emit(
+          self._native_class_emitter.Emit(
               '\n'
-              '$(DART_NATIVE_NAME)(mthis, index) '
+              '  static $(DART_NATIVE_NAME)(mthis, index) '
               'native "$(RESOLVER_STRING)";\n',
               DART_NATIVE_NAME = dart_native_name,
               RESOLVER_STRING=resolver_string)
 
           # Emit the method which calls the toplevel function, along with
           # the [] operator.
+          dart_qualified_name = \
+              self.DeriveQualifiedBlinkName(self._interface.id,
+                                            dart_native_name)
           self._members_emitter.Emit(
               '\n'
               '  $TYPE operator[](int index) {\n'
               '    if (index < 0 || index >= length)\n'
               '      throw new RangeError.range(index, 0, length);\n'
               '    return $(DART_NATIVE_NAME)(this, index);\n'
               '  }\n\n'
               '  $TYPE _nativeIndexedGetter(int index) =>'
               ' $(DART_NATIVE_NAME)(this, index);\n',
-              DART_NATIVE_NAME=DeriveQualifiedName(self._native_library_name,
-                                                   dart_native_name),
+              DART_NATIVE_NAME=dart_qualified_name,
               TYPE=self.SecureOutputType(element_type),
               INTERFACE=self._interface.id)
       else:
           # Emit the method which calls the toplevel function, along with
           # the [] operator.
           self._members_emitter.Emit(
               '\n'
               '  $TYPE operator[](int index) {\n'
               '    if (index < 0 || index >= length)\n'
               '      throw new RangeError.range(index, 0, length);\n'
@@ skipping 120 matching lines @@
     def GenerateCall(
         stmts_emitter, call_emitter, version, operation, argument_count):
       native_suffix = 'Callback'
       actuals = info.ParametersAsListOfVariables(argument_count)
       return_type = self.SecureOutputType(operation.type.id)
       native_suffix = 'Callback'
       is_custom = 'Custom' in operation.ext_attrs
       if self._dart_use_blink:
           base_name = '_%s_%s' % (operation.id, version)
           overload_name = \
-              DeriveNativeName(self._interface.id, base_name, native_suffix)
+              self.DeriveNativeName(base_name, native_suffix)
           static = True
           if not operation.is_static:
             actuals = ['mthis'] + actuals
           actuals_s = ", ".join(actuals)
           dart_declaration = '%s(%s)' % (
             base_name, actuals_s)
           type_ids = [argument.type.id
                       for argument in operation.arguments[:argument_count]]
           resolver_string = \
               DeriveResolverString(self._interface.id, operation.id,
@@ skipping 17 matching lines @@
         dart_declaration, static, return_type, actuals,
         native_suffix, is_custom, auto_scope_setup, emit_metadata=False,
         emit_to_native=self._dart_use_blink, resolver_string=resolver_string)
       if not is_custom:
         self._GenerateOperationNativeCallback(operation,
           operation.arguments[:argument_count], cpp_callback_name,
           auto_scope_setup)
 
 
     if self._dart_use_blink:
-        name = DeriveNativeName(self._interface.id, html_name, "")
-        qual_name = DeriveQualifiedName(self._native_library_name,
-                                        name)
+        name = self.DeriveNativeName(html_name)
+        qual_name = self.DeriveQualifiedBlinkName(self._interface.id,
+                                                  name)
         actuals = info.ParametersAsListOfVariables()
         formals = info.ParametersAsListOfVariables()
         if not info.IsStatic():
             formals = ['mthis'] + formals
             actuals = ['this'] + actuals
         actuals_s = ', '.join(actuals)
         formals_s = ', '.join(formals)
         self._members_emitter.Emit(
         '\n'
         '  $DECLARATION => $NATIVE_NAME($ACTUALS);\n',
         DECLARATION=dart_declaration,
         NATIVE_NAME=qual_name,
         ACTUALS=actuals_s)
 
         dart_declaration = \
             '// Generated overload resolver\n' \
-            '%s(%s)' % (name, formals_s)
+            '  static %s(%s)' % (name, formals_s)
 
     self._GenerateDispatcherBody(
         info,
         operations,
         dart_declaration,
         GenerateCall,
         self._IsArgumentOptionalInWebCore)
 
   def SecondaryContext(self, interface):
     pass
@@ skipping 388 matching lines @@
   def _GenerateNativeBinding(self, idl_name, argument_count, dart_declaration,
       static, return_type, parameters, native_suffix, is_custom,
       auto_scope_setup=True, emit_metadata=True, emit_to_native=False,
       resolver_string=None):
     metadata = []
     if emit_metadata:
       metadata = self._metadata.GetFormattedMetadata(
           self._renamer.GetLibraryName(self._interface),
           self._interface, idl_name, '  ')
     dart_native_name = \
-        DeriveNativeName(self._interface.id, idl_name, native_suffix)
+        self.DeriveNativeName(idl_name, native_suffix)
 
     if (resolver_string):
         native_binding = resolver_string
     else:
         native_binding_id = self._interface.id
         if self._dart_use_blink:
           native_binding_id = TypeIdToBlinkName(native_binding_id, self._database)
         native_binding = \
             '%s_%s_%s' % (native_binding_id, idl_name, native_suffix)
 
     if self._dart_use_blink:
         if not static:
             formals = ", ".join(['mthis'] + parameters)
             actuals = ", ".join(['this'] + parameters)
         else:
             formals = ", ".join(parameters)
             actuals = ", ".join(parameters)
         if native_binding in _cpp_resolver_string_map:
             native_binding = \
                 _cpp_resolver_string_map[native_binding]
-        self._native_library_emitter.Emit(
+        self._native_class_emitter.Emit(
             '\n'
-            '$DART_NAME($FORMALS) native "$NATIVE_BINDING";\n',
+            '  static $DART_NAME($FORMALS) native "$NATIVE_BINDING";\n',
             DART_NAME=dart_native_name,
             FORMALS=formals,
             NATIVE_BINDING=native_binding)
 
         if not emit_to_native:
             caller_emitter = self._members_emitter
-            full_dart_name = DeriveQualifiedName(self._native_library_name,
-                                                 dart_native_name)
+            full_dart_name = \
+                self.DeriveQualifiedBlinkName(self._interface.id,
+                                              dart_native_name)
             caller_emitter.Emit(
                 '\n'
                 '  $METADATA$DART_DECLARATION => $DART_NAME($ACTUALS);\n',
                 METADATA=metadata,
                 DART_DECLARATION=dart_declaration,
                 DART_NAME=full_dart_name,
                 ACTUALS=actuals)
     else:
         self._members_emitter.Emit(
             '\n'
@@ skipping 262 matching lines @@
     e.Emit("};\n");
     e.Emit('\n');
     e.Emit('} // namespace WebCore\n');
 
 def _IsOptionalStringArgumentInInitEventMethod(interface, operation, argument):
   return (
       interface.id.endswith('Event') and
       operation.id.startswith('init') and
       argument.ext_attrs.get('Default') == 'Undefined' and
       argument.type.id == 'DOMString')