This CL contains all of the changes for splitting off all of the native

tools/dom/scripts/htmldartgenerator.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 system to generate
 dart:html APIs from the IDL database."""
 
 import emitter
 from generator import AnalyzeOperation, ConstantOutputOrder, \
@@ skipping 487 matching lines @@
       # TODO(antonm): use common dispatcher generation for this case as well.
       has_optional = any(param_info.is_optional
           for param_info in constructor_info.param_infos)
 
       if not has_optional:
         self._members_emitter.Emit(
             '\n  $(METADATA)'
             'factory $CTOR($PARAMS) => '
             '$FACTORY.$CTOR_FACTORY_NAME($FACTORY_PARAMS);\n',
             CTOR=constructor_info._ConstructorFullName(self._DartType),
-            PARAMS=constructor_info.ParametersDeclaration(self._DartType),
+            PARAMS=constructor_info.ParametersAsDeclaration(self._DartType),
             FACTORY=factory_name,
             METADATA=metadata,
             CTOR_FACTORY_NAME=factory_constructor_name,
             FACTORY_PARAMS=factory_parameters)
       else:
         inits = self._members_emitter.Emit(
             '\n  $(METADATA)'
             'factory $CONSTRUCTOR($PARAMS) {\n'
             '    var e = $FACTORY.$CTOR_FACTORY_NAME($FACTORY_PARAMS);\n'
             '$!INITS'
             '    return e;\n'
             '  }\n',
             CONSTRUCTOR=constructor_info._ConstructorFullName(self._DartType),
             METADATA=metadata,
             FACTORY=factory_name,
             CTOR_FACTORY_NAME=factory_constructor_name,
-            PARAMS=constructor_info.ParametersDeclaration(self._DartType),
+            PARAMS=constructor_info.ParametersAsDeclaration(self._DartType),
             FACTORY_PARAMS=factory_parameters)
 
         for index, param_info in enumerate(constructor_info.param_infos):
           if param_info.is_optional:
             inits.Emit('    if ($E != null) e.$E = $E;\n', E=param_info.name)
     else:
       def GenerateCall(
           stmts_emitter, call_emitter,
           version, signature_index, argument_count):
         name = emitter.Format('_create_$VERSION', VERSION=version)
@@ skipping 15 matching lines @@
       self._GenerateOverloadDispatcher(
           constructor_info,
           constructor_info.idl_args,
           False,
           emitter.Format('$(METADATA)$FACTORY_KEYWORD $CTOR($PARAMS)',
             FACTORY_KEYWORD=('factory' if not custom_factory_ctr else
                 'static %s' % constructor_full_name),
             CTOR=(('' if not custom_factory_ctr else '_factory')
                 + constructor_full_name),
             METADATA=metadata,
-            PARAMS=constructor_info.ParametersDeclaration(self._DartType)),
+            PARAMS=constructor_info.ParametersAsDeclaration(self._DartType)),
           GenerateCall,
           IsOptional)
 
   def _AddFutureifiedOperation(self, info, html_name):
     """Given a API function that uses callbacks, convert it to using Futures.
 
     This conversion assumes the success callback is always provided before the
     error callback (and so far in the DOM API, this is the case)."""
     callback_info = GetCallbackInfo(
         self._database.GetInterface(info.callback_args[0].type_id))
@@ skipping 10 matching lines @@
         '    $ORIGINAL_FUNCTION($PARAMS_LIST\n'
         '        $NAMED_PARAM($VARIABLE_NAME) { '
         'completer.complete($VARIABLE_NAME); }'
         '$ERROR_CALLBACK);\n'
         '    return completer.future;\n'
         '  }\n',
         METADATA=metadata,
         MODIFIERS='static ' if info.IsStatic() else '',
         TYPE=self.SecureOutputType(info.type_name),
         NAME=html_name[1:],
-        PARAMS=info.ParametersDeclaration(self._NarrowInputType
+        PARAMS=info.ParametersAsDeclaration(self._NarrowInputType
             if '_NarrowInputType' in dir(self) else self._DartType),
         PARAMS_LIST='' if param_list == '' else param_list + ',',
         NAMED_PARAM=('%s : ' % info.callback_args[0].name
             if info.requires_named_arguments and
               info.callback_args[0].is_optional else ''),
         VARIABLE_NAME= '' if len(callback_info.param_infos) == 0 else 'value',
         ERROR_CALLBACK=('' if len(info.callback_args) == 1 else
             (',\n        %s(error) { completer.completeError(error); }' %
             ('%s : ' % info.callback_args[1].name
             if info.requires_named_arguments and
@@ skipping 31 matching lines @@
     Arguments:
       operation - The operation to be declared.
       return_type_name - The name of the return type.
       method_name - The name of the method.
     """
     self._members_emitter.Emit(
              '\n'
              '  $TYPE $NAME($PARAMS);\n',
              TYPE=return_type_name,
              NAME=method_name,
-             PARAMS=operation.ParametersDeclaration(self._DartType))
+             PARAMS=operation.ParametersAsDeclaration(self._DartType))
 
   def EmitListMixin(self, element_name):
     # TODO(sra): Use separate mixins for mutable implementations of List<T>.
     # TODO(sra): Use separate mixins for typed array implementations of List<T>.
     template_file = 'immutable_list_mixin.darttemplate'
     has_length = False
     has_length_setter = False
 
     def _HasExplicitIndexedGetter(self):
       return any(op.id == 'getItem' for op in self._interface.operations)
@@ skipping 51 matching lines @@
 
   def SecureBaseName(self, type_name):
     if type_name in _secure_base_types:
       return _secure_base_types[type_name]
 
   def _DartType(self, type_name):
     return self._type_registry.DartType(type_name)
 
   def _TypeInfo(self, type_name):
     return self._type_registry.TypeInfo(type_name)