"Reverting 15020"

sdk/lib/html/scripts/systemhtml.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
 import os
@@ skipping 40 matching lines @@
 # Information for generating element constructors.
 #
 # TODO(sra): maybe remove all the argument complexity and use cascades.
 #
 #   var c = new CanvasElement(width: 100, height: 70);
 #   var c = new CanvasElement()..width = 100..height = 70;
 #
 class ElementConstructorInfo(object):
   def __init__(self, name=None, tag=None,
                params=[], opt_params=[],
-               factory_provider_name='document'):
+               factory_provider_name='_Elements'):
     self.name = name          # The constructor name 'h1' in 'HeadingElement.h1'
-    self.tag = tag or name    # The HTML or SVG tag
+    self.tag = tag or name    # The HTML tag
     self.params = params
     self.opt_params = opt_params
     self.factory_provider_name = factory_provider_name
 
   def ConstructorInfo(self, interface_name):
     info = OperationInfo()
     info.overloads = None
     info.declared_name = interface_name
     info.name = interface_name
     info.constructor_name = self.name
     info.js_name = None
     info.type_name = interface_name
     info.param_infos = map(lambda tXn: ParamInfo(tXn[1], tXn[0], True),
                            self.opt_params)
     info.requires_named_arguments = True
-    info.factory_parameters = ['"%s"' % self.tag]
     return info
 
 _html_element_constructors = {
   'AnchorElement' :
     ElementConstructorInfo(tag='a', opt_params=[('DOMString', 'href')]),
   'AreaElement': 'area',
   'ButtonElement': 'button',
   'BRElement': 'br',
   'BaseElement': 'base',
   'BodyElement': 'body',
@@ skipping 52 matching lines @@
   'TableElement': 'table',
   'TableRowElement': 'tr',
   #'TableSectionElement'  <thead> <tbody> <tfoot>
   'TextAreaElement': 'textarea',
   'TitleElement': 'title',
   'TrackElement': 'track',
   'UListElement': 'ul',
   'VideoElement': 'video'
 }
 
-_svg_element_constructors = {
-  'SVGAElement': 'a',
-  'SVGAnimateColorElement': 'animateColor',
-  'SVGAnimateElement': 'animate',
-  'SVGAnimateMotionElement': 'animateMotion',
-  'SVGAnimateTransformElement': 'animateTransform',
-  'SVGAnimationElement': 'animation',
-  'SVGCircleElement': 'circle',
-  'SVGClipPathElement': 'clipPath',
-  'SVGCursorElement': 'cursor',
-  'SVGDefsElement': 'defs',
-  'SVGDescElement': 'desc',
-  'SVGEllipseElement': 'ellipse',
-  'SVGFilterElement': 'filter',
-  'SVGFontElement': 'font',
-  'SVGFontFaceElement': 'font-face',
-  'SVGFontFaceFormatElement': 'font-face-format',
-  'SVGFontFaceNameElement': 'font-face-name',
-  'SVGFontFaceSrcElement': 'font-face-src',
-  'SVGFontFaceUriElement': 'font-face-uri',
-  'SVGForeignObjectElement': 'foreignObject',
-  'SVGGlyphElement': 'glyph',
-  'SVGGElement': 'g',
-  'SVGHKernElement': 'hkern',
-  'SVGImageElement': 'image',
-  'SVGLinearGradientElement': 'linearGradient',
-  'SVGLineElement': 'line',
-  'SVGMarkerElement': 'marker',
-  'SVGMaskElement': 'mask',
-  'SVGMPathElement': 'mpath',
-  'SVGPathElement': 'path',
-  'SVGPatternElement': 'pattern',
-  'SVGPolygonElement': 'polygon',
-  'SVGPolylineElement': 'polyline',
-  'SVGRadialGradientElement': 'radialGradient',
-  'SVGRectElement': 'rect',
-  'SVGScriptElement': 'script',
-  'SVGSetElement': 'set',
-  'SVGStopElement': 'stop',
-  'SVGStyleElement': 'style',
-  'SVGSwitchElement': 'switch',
-  'SVGSymbolElement': 'symbol',
-  'SVGTextElement': 'text',
-  'SVGTitleElement': 'title',
-  'SVGTRefElement': 'tref',
-  'SVGTSpanElement': 'tspan',
-  'SVGUseElement': 'use',
-  'SVGViewElement': 'view',
-  'SVGVKernElement': 'vkern',
-}
-
-_element_constructors = {
-  'html': _html_element_constructors,
-  'svg': _svg_element_constructors
-}
-
-_factory_ctr_strings = {
-  'html': {
-      'provider_name': 'document',
-      'constructor_name': '$dom_createElement'
-  },
-  'svg': {
-    'provider_name': '_SvgElementFactoryProvider',
-    'constructor_name': 'createSVGElement_tag',
-  },
-}
-
-def ElementConstructorInfos(typename, element_constructors,
-                            factory_provider_name='_Elements'):
+def HtmlElementConstructorInfos(typename):
   """Returns list of ElementConstructorInfos about the convenience constructors
-  for an Element or SvgElement."""
+  for an Element."""
   # TODO(sra): Handle multiple and named constructors.
-  if typename not in element_constructors:
+  if typename not in _html_element_constructors:
     return []
-  infos = element_constructors[typename]
+  infos = _html_element_constructors[typename]
   if isinstance(infos, str):
-    infos = ElementConstructorInfo(tag=infos,
-        factory_provider_name=factory_provider_name)
+    infos = ElementConstructorInfo(tag=infos)
   if not isinstance(infos, list):
     infos = [infos]
   return infos
 
+def EmitHtmlElementFactoryConstructors(emitter, infos, typename, class_name,
+                                       rename_type):
+  for info in infos:
+    constructor_info = info.ConstructorInfo(typename)
+
+    inits = emitter.Emit(
+        '\n'
+        '  static $RETURN_TYPE $CONSTRUCTOR($PARAMS) {\n'
+        '    $CLASS _e = document.$dom_createElement("$TAG");\n'
+        '$!INITS'
+        '    return _e;\n'
+        '  }\n',
+        RETURN_TYPE=rename_type(constructor_info.type_name),
+        CONSTRUCTOR=constructor_info.ConstructorFactoryName(rename_type),
+        CLASS=class_name,
+        TAG=info.tag,
+        PARAMS=constructor_info.ParametersDeclaration(
+            rename_type, force_optional=True))
+    for param in constructor_info.param_infos:
+      inits.Emit('    if ($E != null) _e.$E = $E;\n', E=param.name)
+
 # ------------------------------------------------------------------------------
 
 class HtmlDartInterfaceGenerator(object):
   """Generates dart interface and implementation for the DOM IDL interface."""
 
   def __init__(self, options, library_emitter, event_generator, interface,
                backend):
     self._renamer = options.renamer
     self._database = options.database
     self._template_loader = options.templates
@@ skipping 24 matching lines @@
               NAME=self._interface.id,
               PARAMS=info.ParametersDeclaration(self._DartType))
     self._backend.GenerateCallback(info)
 
   def GenerateInterface(self):
     interface_name = self._interface_type_info.interface_name()
 
     factory_provider = None
     if interface_name in interface_factories:
       factory_provider = interface_factories[interface_name]
-    factory_constructor_name = None
 
     constructors = []
     if interface_name in _static_classes:
       constructor_info = None
     else:
       constructor_info = AnalyzeConstructor(self._interface)
     if constructor_info:
       constructors.append(constructor_info)
       factory_provider = '_' + interface_name + 'FactoryProvider'
       factory_provider_emitter = self._library_emitter.FileEmitter(
           '_%sFactoryProvider' % interface_name, self._library_name)
       self._backend.EmitFactoryProvider(
           constructor_info, factory_provider, factory_provider_emitter)
 
-    # HTML Elements and SVG Elements have convenience constructors.
-    infos = ElementConstructorInfos(interface_name,
-        _element_constructors[self._library_name], factory_provider_name=
-        _factory_ctr_strings[self._library_name]['provider_name'])
+    infos = HtmlElementConstructorInfos(interface_name)
+    if infos:
+      template = self._template_loader.Load(
+          'factoryprovider_Elements.darttemplate')
+      EmitHtmlElementFactoryConstructors(
+          self._library_emitter.FileEmitter('_Elements', self._library_name,
+              template),
+          infos,
+          self._interface.id,
+          self._interface_type_info.implementation_name(),
+          self._DartType)
 
-    if infos:
-      factory_constructor_name = _factory_ctr_strings[
-          self._library_name]['constructor_name']
-    
     for info in infos:
       constructors.append(info.ConstructorInfo(self._interface.id))
       if factory_provider:
         assert factory_provider == info.factory_provider_name
       else:
         factory_provider = info.factory_provider_name
 
     implementation_emitter = self._ImplementationEmitter()
 
     base_type_info = None
@@ skipping 30 matching lines @@
         LIBRARYNAME=self._library_name,
         CLASSNAME=self._interface_type_info.implementation_name(),
         EXTENDS=' extends %s' % base_class if base_class else '',
         IMPLEMENTS=implements_str,
         DOMNAME=self._interface.doc_js_name,
         NATIVESPEC=self._backend.NativeSpec())
     self._backend.StartInterface(self._implementation_members_emitter)
 
     self._backend.AddConstructors(constructors, factory_provider,
         self._interface_type_info.implementation_name(),
-        base_class, factory_constructor_name=factory_constructor_name)
+        base_class)
 
     events_class_name = self._event_generator.ProcessInterface(
         self._interface, interface_name,
         self._backend.CustomJSMembers(),
         implementation_emitter)
     if events_class_name:
       self._backend.EmitEventGetter(events_class_name)
 
     merged_interface = self._interface_type_info.merged_interface()
     if merged_interface:
@@ skipping 610 matching lines @@
       'svg': DartLibrary('svg', template_loader, library_type, output_dir),
       'html': DartLibrary('html', template_loader, library_type, output_dir),
     }
 
   def AddFile(self, basename, library_name, path):
     self._libraries[library_name].AddFile(path)
 
   def Emit(self, emitter, auxiliary_dir):
     for lib in self._libraries.values():
       lib.Emit(emitter, auxiliary_dir)