dart:html perf optimization based on runing Dromaeo benchmarks

lib/dom/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."""
 
 from systemfrog import *
 from systeminterface import *
 
 # Members from the standard dom that should not be exposed publicly in dart:html
 # but need to be exposed internally to implement dart:html on top of a standard
 # browser.
 _private_html_members = set([
-  'Element.clientLeft',
-  'Element.clientTop',
-  'Element.clientWidth',
-  'Element.clientHeight',
-  'Element.offsetLeft',
-  'Element.offsetTop',
-  'Element.offsetWidth',
-  'Element.offsetHeight',
-  'Element.scrollLeft',
-  'Element.scrollTop',
-  'Element.scrollWidth',
-  'Element.scrollHeight',
-  'Element.childElementCount',
-  'Element.firstElementChild',
-  'Element.hasAttribute',
-  'Element.getAttribute',
-  'Element.removeAttribute',
-  'Element.setAttribute',
-  'Element.className',
-  'Element.children',
-  'Element.querySelectorAll',
-  'NodeSelector.querySelectorAll',
-  'Document.querySelectorAll',
-  'DocumentFragment.querySelectorAll',
-  'Element.getBoundingClientRect',
-  'Element.getClientRects',
-  'Node.appendChild',
-  'Node.removeChild',
-  'Node.replaceChild',
-  'Node.attributes',
-  'Node.childNodes',
   'Document.createElement',
   'Document.createElementNS',
   'Document.createEvent',
   'Document.createTextNode',
   'Document.createTouchList',
-  'Window.getComputedStyle',
-  'EventTarget.removeEventListener',
+  'Document.getElementById',
+  'Document.getElementsByClassName',
+  'Document.getElementsByName',
+  'Document.getElementsByTagName',
+  'Document.querySelectorAll',
+  'DocumentFragment.querySelectorAll',
+  'Element.childElementCount',
+  'Element.children',
+  'Element.className',
+  'Element.clientHeight',
+  'Element.clientLeft',
+  'Element.clientTop',
+  'Element.clientWidth',
+  'Element.firstElementChild',
+  'Element.getAttribute',
+  'Element.getBoundingClientRect',
+  'Element.getClientRects',
+  'Element.getElementsByClassName',
+  'Element.getElementsByTagName',
+  'Element.hasAttribute',
+  'Element.lastElementChild',
+  'Element.offsetHeight',
+  'Element.offsetLeft',
+  'Element.offsetTop',
+  'Element.offsetWidth',
+  'Element.querySelectorAll',
+  'Element.removeAttribute',
+  'Element.scrollHeight',
+  'Element.scrollLeft',
+  'Element.scrollTop',
+  'Element.scrollWidth',
+  'Element.setAttribute',
+  'Event.initEvent',
   'EventTarget.addEventListener',
   'EventTarget.dispatchEvent',
-  'Event.initEvent',
+  'EventTarget.removeEventListener',
   'MouseEvent.initMouseEvent',
+  'Node.appendChild',
+  'Node.attributes',
+  'Node.childNodes',
+  'Node.firstChild',
+  'Node.lastChild',
+  "Node.nodeType",
+  'Node.removeChild',
+  'Node.replaceChild',
+  'NodeSelector.querySelectorAll',
+  'Window.getComputedStyle',
+])
+
+_manually_generated_html_members = set([
+  'Document.querySelectorAll',
+  'Document.querySelector',
 ])
 
 # Members from the standard dom that exist in the dart:html library with
 # identical functionality but with cleaner names.
 _html_library_renames = {
     'Document.defaultView': 'window',
     'DocumentFragment.querySelector': 'query',
     'NodeSelector.querySelector': 'query',
     'Element.querySelector': 'query',
     'Element.webkitMatchesSelector' : 'matchesSelector',
     'Element.scrollIntoViewIfNeeded': 'scrollIntoView',
-    'Document.querySelector': 'query',
     'Node.cloneNode': 'clone',
     'Node.nextSibling': 'nextNode',
     'Node.ownerDocument': 'document',
     'Node.parentNode': 'parent',
     'Node.previousSibling': 'previousNode',
     'Node.textContent': 'text',
-    'SVGElement.className': '_svgClassName',
-    'SVGAnimatedString.className': '_svgClassName',
-    'SVGStylable.className': '_svgClassName',
+    'SVGElement.className': '$dom_svgClassName',
+    'SVGAnimatedString.className': '$dom_svgClassName',
+    'SVGStylable.className': '$dom_svgClassName',
 }
 
 #TODO(jacobr): inject annotations into the interfaces based on this table and
 # on _html_library_renames.
 _injected_doc_fragments = {
     'Element.query': '  /** @domName querySelector, Document.getElementById */',
 }
 # Members and classes from the dom that should be removed completelly from
 # dart:html.  These could be expressed in the IDL instead but expressing this
 # as a simple table instead is more concise.
 # Syntax is: ClassName.(get\.|set\.)?MemberName
 # Using get: and set: is optional and should only be used when a getter needs
 # to be suppressed but not the setter, etc. 
 # TODO(jacobr): cleanup and augment this list.
 _html_library_remove = set([
     'Window.get:document', # Removed as we have a custom implementation.
     'NodeList.item',
     "Attr.*",
 #    "BarProp.*",
 #    "BarInfo.*",
 #    "Blob.webkitSlice",
 #    "CDATASection.*",
 #    "Comment.*",
 #    "DOMImplementation.*",
-    "Document.get:documentElement",
     "Document.get:forms",
 #    "Document.get:selectedStylesheetSet",
 #    "Document.set:selectedStylesheetSet",
 #    "Document.get:preferredStylesheetSet",
     "Document.get:links",
-    "Document.getElementsByTagName",
     "Document.set:domain",
     "Document.get:implementation",
     "Document.createAttributeNS",
     "Document.get:inputEncoding",
-    "Document.getElementById",
-    "Document.getElementsByClassName",
     "Document.get:height",
     "Document.get:width",
-    "Element.getElementsByClassName",
     "Element.getElementsByTagNameNS",
-    "Element.getElementsByTagName",
     "Document.get:compatMode",
     "Document.importNode",
     "Document.evaluate",
     "Document.get:images",
-    "Document.querySelector",
     "Document.createExpression",
     "Document.getOverrideStyle",
     "Document.xmlStandalone",
     "Document.createComment",
     "Document.adoptNode",
     "Document.get:characterSet",
     "Document.createAttribute",
-    "Document.querySelectorAll",
     "Document.get:URL",
     "Document.createEntityReference",
     "Document.get:documentURI",
     "Document.set:documentURI",
     "Document.createNodeIterator",
     "Document.createProcessingInstruction",
     "Document.get:doctype",
-    "Document.getElementsByName",
     "Document.createTreeWalker",
     "Document.location",
     "Document.createNSResolver",
     "Document.get:xmlEncoding",
     "Document.get:defaultCharset",
     "Document.get:applets",
     "Document.getSelection",
     "Document.xmlVersion",
     "Document.get:anchors",
     "Document.getElementsByTagNameNS",
@@ skipping 78 matching lines @@
     "Node.isDefaultNamespace",
     "Node.compareDocumentPosition",
     "Node.get:baseURI",
     "Node.isSameNode",
     "Node.get:DOCUMENT_POSITION_DISCONNECTED",
     "Node.get:DOCUMENT_NODE",
     "Node.get:DOCUMENT_POSITION_CONTAINS",
     "Node.get:COMMENT_NODE",
     "Node.get:ENTITY_REFERENCE_NODE",
     "Node.isSupported",
-    "Node.get:firstChild",
     "Node.get:DOCUMENT_POSITION_IMPLEMENTATION_SPECIFIC",
-    "Node.get:lastChild",
     "Node.get:NOTATION_NODE",
     "Node.normalize",
     "Node.get:parentElement",
     "Node.get:ATTRIBUTE_NODE",
     "Node.get:ENTITY_NODE",
     "Node.get:DOCUMENT_POSITION_CONTAINED_BY",
     "Node.get:prefix",
     "Node.set:prefix",
     "Node.get:DOCUMENT_POSITION_PRECEDING",
-    "Node.get:nodeType",
     "Node.removeEventListener",
     "Node.get:nodeValue",
     "Node.set:nodeValue",
     "Node.get:CDATA_SECTION_NODE",
     "Node.get:nodeName",
     "Node.addEventListener",
     "Node.lookupPrefix",
     "Node.get:PROCESSING_INSTRUCTION_NODE",
     "Notification.dispatchEvent",
     "Notification.addEventListener",
@@ skipping 156 matching lines @@
     return not self._Matches(interface, member, member_prefix,
         _html_library_remove)
 
   def _Matches(self, interface, member, member_prefix, candidates):
     for interface_name in self._AllAncestorInterfaces(interface):
       if (DartType(interface_name) + '.' + member in candidates or
           DartType(interface_name) + '.' + member_prefix + member in candidates):
         return True
     return False
 
-  def MaybeReturnDocument(self, return_type):
-    """
-    To make it appear that there are not a distinct Document and
-    HTMLHtmlElement (document.documentElement) objects we always use
-    documentElement instead of the regular document object so must not
-    allow a regular document to leak out.
-    """
-    # TODO(jacobr): any method that returns a Node could also theoretically
-    # really return a Document but there are alot of methods that return nodes
-    # and they all appear to be safe.  Consider the alternate strategy of
-    # whitelisting just the known safe methods that return Nodes.
-    return (DartType(return_type) == 'EventTarget' or
-        DartType(return_type) == 'Document')
-
   def _AllAncestorInterfaces(self, interface):
     interfaces = ([interface.id] +
         self._generator._AllImplementedInterfaces(interface))
     return interfaces
 
-  def RenameInHtmlLibrary(self, interface, member, member_prefix=''):
+  def RenameInHtmlLibrary(self, interface, member, member_prefix='',
+                          implementation_class=False):
     """
     Returns the name of the member in the HTML library or None if the member is
     suppressed in the HTML library
     """
     if not self._AllowInHtmlLibrary(interface, member, member_prefix):
       return None
 
+    target_name = member
     for interface_name in self._AllAncestorInterfaces(interface):
       name = interface_name + '.' + member
       if name in _html_library_renames:
-        return _html_library_renames[name]
+        target_name = _html_library_renames[name]
       name = interface.id + '.' + member_prefix + member
       if name in _html_library_renames:
-        return _html_library_renames[name]
+        target_name = _html_library_renames[name]
 
-    if self._PrivateInHtmlLibrary(interface, member, member_prefix):
-      return '_' + member
+    if not target_name.startswith('_'):
+      if self._PrivateInHtmlLibrary(interface, member, member_prefix):
+        target_name = '$dom_' + target_name
+      elif implementation_class and self._ManuallyGeneratedInHtmlLibrary(
+          interface, member, member_prefix):
+        target_name = '_' + target_name
 
     # No rename required
-    return member
+    return target_name
 
   def _PrivateInHtmlLibrary(self, interface, member, member_prefix):
     return self._Matches(interface, member, member_prefix,
         _private_html_members)
 
+  def _ManuallyGeneratedInHtmlLibrary(self, interface, member, member_prefix):
+    return self._Matches(interface, member, member_prefix,
+        _manually_generated_html_members)
+
   # TODO(jacobr): this already exists
   def _TraverseParents(self, interface, callback):
     for parent in interface.parents:
       parent_id = parent.type.id
       if self._database.HasInterface(parent_id):
         parent_interface = self._database.GetInterface(parent_id)
         callback(parent_interface)
         self._TraverseParents(parent_interface, callback)
 
   # TODO(jacobr): this isn't quite right.... 
@@ skipping 210 matching lines @@
       return
     raise Exception('Unexpected getter/setter combination %s %s' %
                     (getter, setter))
 
   def AddOperation(self, info):
     """
     Arguments:
       operations - contains the overloads, one or more operations with the same
         name.
     """
-    html_name = self._shared.RenameInHtmlLibrary(self._interface, info.name)
+    html_name = self._shared.RenameInHtmlLibrary(
+        self._interface, info.name)
     if html_name and not self._shared.IsPrivate(html_name):
       self._members_emitter.Emit('\n'
                                  '  $TYPE $NAME($PARAMS);\n',
                                  TYPE=info.type_name,         
                                  NAME=html_name,
                                  PARAMS=info.ParametersInterfaceDeclaration())
 
   def FinishInterface(self):
     pass
 
@@ skipping 153 matching lines @@
     # TODO(sra): Use separate mixins for mutable implementations of List<T>.
     # TODO(sra): Use separate mixins for typed array implementations of List<T>.
     if self._interface.id != 'NodeList':
       template_file = 'immutable_list_mixin.darttemplate'
       template = self._system._templates.Load(template_file)
       self._members_emitter.Emit(template, E=DartType(element_type))
 
   def AddAttribute(self, getter, setter):
   
     html_getter_name = self._shared.RenameInHtmlLibrary(
-      self._interface, DartDomNameOfAttribute(getter), 'get:')
+      self._interface, DartDomNameOfAttribute(getter), 'get:',
+          implementation_class=True)
     html_setter_name = self._shared.RenameInHtmlLibrary(
-      self._interface, DartDomNameOfAttribute(getter), 'set:')
+      self._interface, DartDomNameOfAttribute(getter), 'set:',
+          implementation_class=True)
 
     if not html_getter_name:
       getter = None
     if not html_setter_name:
       setter = None
 
     if not getter and not setter:
       return
 
-    if ((getter and (html_getter_name != getter.id or
-                     self._shared.MaybeReturnDocument(getter.type.id))) or
-        (setter and (html_setter_name != setter.id or
-                     self._shared.MaybeReturnDocument(setter.type.id))) or
-        self._interface.id == 'Document'):
+    if ((getter and html_getter_name != getter.id) or
+        (setter and html_setter_name != setter.id)):
       if getter:
         self._AddRenamingGetter(getter, html_getter_name)
       if setter:
         self._AddRenamingSetter(setter, html_setter_name)
       return
 
     # If the (getter, setter) pair is shadowing, we can't generate a shadowing
     # field (Issue 1633).
     (super_getter, super_getter_interface) = self._FindShadowedAttribute(getter)
     (super_setter, super_setter_interface) = self._FindShadowedAttribute(setter)
@@ skipping 39 matching lines @@
       self._AddSetter(setter)
 
   def _AddGetter(self, attr):
     self._AddRenamingGetter(attr, DartDomNameOfAttribute(attr))
 
   def _AddSetter(self, attr):
     self._AddRenamingSetter(attr, DartDomNameOfAttribute(attr))
 
   def _AddRenamingGetter(self, attr, html_name):
     return_type = self._NarrowOutputType(attr.type.id)
-    if self._shared.MaybeReturnDocument(attr.type.id):
-      self._members_emitter.Emit(
-        '\n  $TYPE get $(HTML_NAME)() => '
-        '_FixHtmlDocumentReference(_$(HTML_NAME));\n',
-        HTML_NAME=html_name,
-        TYPE=return_type)
-      html_name = '_' + html_name
-      # For correctness this needs to be the return type of the native helper
-      # method due to the fact that the real HTMLDocument object is not typed
-      # as a document.  TODO(jacobr): we could simplify this.
-      return_type = '_EventTargetImpl'
-
     self._members_emitter.Emit(
-        '\n  $TYPE get $(HTML_NAME)() native "return $(THIS).$NAME;";\n',
+        '\n  $TYPE get $(HTML_NAME)() native "return this.$NAME;";\n',
         HTML_NAME=html_name,
         NAME=attr.id,
-        TYPE=return_type,
-        THIS='this.parentNode' if self._interface.id == 'Document' else 'this')
+        TYPE=return_type)
 
   def _AddRenamingSetter(self, attr, html_name):
     self._members_emitter.Emit(
         '\n  void set $HTML_NAME($TYPE value)'
-        ' native "$(THIS).$NAME = value;";\n',
+        ' native "this.$NAME = value;";\n',
         HTML_NAME=html_name,
         NAME=attr.id,
-        TYPE=self._NarrowInputType(attr.type.id),
-        THIS='this.parentNode' if self._interface.id == 'Document' else 'this')
+        TYPE=self._NarrowInputType(attr.type.id))
 
   def AddOperation(self, info):
     """
     Arguments:
       info: An OperationInfo object.
     """
-    html_name = self._shared.RenameInHtmlLibrary(self._interface, info.name)
+    html_name = self._shared.RenameInHtmlLibrary(
+        self._interface, info.name, implementation_class=True)
     if not html_name:
       return
 
-    maybe_return_document = self._shared.MaybeReturnDocument(info.type_name)
-
     # Do we need a native body?
-    if (self._interface.id == 'Document' or  # Need alternate 'this'
-        html_name != info.name or            # renamed operation
-        maybe_return_document):              # need to wrap value
-      # For example: use window.document instead of his.parentNode.
+    if (html_name != info.name):
       return_type = self._NarrowOutputType(info.type_name)
       
       operation_emitter = self._members_emitter.Emit('$!SCOPE',
-          THIS=('this.parentNode' if self._interface.id == 'Document'
-              else 'this'),
           TYPE=return_type,
           HTML_NAME=html_name,
           NAME=info.name,
           RETURN='' if return_type == 'void' else 'return ',
           PARAMNAMES=info.ParametersAsArgumentList(),
           PARAMS=info.ParametersImplementationDeclaration(
               lambda type_name: self._NarrowInputType(type_name)))
 
-      if maybe_return_document:
-        assert len(info.overloads) == 1
-        operation_emitter.Emit(
-            '\n'
-            '  $TYPE $(HTML_NAME)($PARAMS) => '
-            '_FixHtmlDocumentReference(_$(HTML_NAME)($PARAMNAMES));\n'
-            '\n'
-            '  _EventTargetImpl _$(HTML_NAME)($PARAMS)'
-            ' native "return $(THIS).$NAME($PARAMNAMES);";\n')
-      else:
-        operation_emitter.Emit(
-            '\n'
-            '  $TYPE $(HTML_NAME)($PARAMS)'
-            ' native "$(RETURN)$(THIS).$NAME($PARAMNAMES);";\n')
+      operation_emitter.Emit(
+          '\n'
+          '  $TYPE $(HTML_NAME)($PARAMS)'
+          ' native "$(RETURN)this.$NAME($PARAMNAMES);";\n')
     else:
       self._members_emitter.Emit(
           '\n'
           '  $TYPE $NAME($PARAMS) native;\n',
           TYPE=self._NarrowOutputType(info.type_name),
           NAME=info.name,
           PARAMS=info.ParametersImplementationDeclaration(
               lambda type_name: self._NarrowInputType(type_name)))
 
   def AddEventAttributes(self, event_attrs):
@@ skipping 21 matching lines @@
         events_members.Emit(
             "\n"
             "  EventListenerList get $NAME() => _get('$RAWNAME');\n",
             RAWNAME=event_name,
             NAME=_html_event_names[event_name])
       else:
         raise Exception('No known html even name for event: ' + event_name)
 
   def _EmitEventGetter(self, events_class):
     self._members_emitter.Emit(
-        '\n  $TYPE get on() =>\n    new $TYPE($EVENTTARGET);\n',
-        TYPE=events_class,
-        EVENTTARGET='_jsDocument' if self._interface.id == 'Document'
-            else 'this')
+        '\n  $TYPE get on() =>\n    new $TYPE(this);\n',
+        TYPE=events_class)
 
 # ------------------------------------------------------------------------------
 
 class HtmlFrogSystem(HtmlSystem):
 
   def __init__(self, templates, database, emitters, output_dir, generator):
     super(HtmlFrogSystem, self).__init__(
         templates, database, emitters, output_dir, generator)
     self._dart_frog_file_paths = []
 
@@ skipping 118 matching lines @@
     self._system = system
     self._interface = interface
     self._super_interface = super_interface
     self._dart_code = dart_code
     self._base_members = base_members
     self._current_secondary_parent = None
     self._shared = shared
     self._template = template
 
   def DomObjectName(self):
-    return '_documentPtr' if self._interface.id == 'Document' else '_ptr'
+    return '_ptr'
 
   # TODO(jacobr): these 3 methods are duplicated.
   def _NarrowToImplementationType(self, type_name):
     # TODO(sra): Move into the 'system' and cache the result.
     if type_name == 'EventListener':
       # Callbacks are typedef functions so don't have a class.
       return type_name
     if self._system._database.HasInterface(type_name):
       interface = self._system._database.GetInterface(type_name)
       if RecognizeCallback(interface):
@@ skipping 22 matching lines @@
         base = self._ImplClassName(supertype)
       if IsDartCollectionType(supertype):
         # List methods are injected in AddIndexer.
         pass
       else:
         base = self._ImplClassName(supertype)
    
     # TODO(jacobr): this is fragile. There isn't a guarantee that dart:dom
     # will continue to exactly match the IDL names.
     dom_name = interface.javascript_binding_name
-    # We hard code the cases for these classes
-    if dom_name != 'HTMLHtmlElement' and dom_name != 'Document':
-      self._system._wrap_cases.append(
-          '    case "%s": return new %s._wrap(domObject);' %
-          (dom_name, self._class_name))
+    self._system._wrap_cases.append(
+        "    case '%s': return new %s._wrap(domObject);" %
+        (dom_name, self._class_name))
 
     extends = ' extends ' + base if base else ' extends _DOMTypeBase'
 
     # TODO: Include all implemented interfaces, including other Lists.
     implements = [interface_name]
     element_type = MaybeTypedArrayElementType(self._interface)
     if element_type:
       implements.append('List<' + DartType(element_type) + '>')
     implements_str = ', '.join(implements)
 
     (self._members_emitter,
      self._top_level_emitter) = self._dart_code.Emit(
         self._template + '$!TOP_LEVEL',
         #class $CLASSNAME$EXTENDS$IMPLEMENTS$NATIVESPEC {
         #$!MEMBERS
         #}
         NATIVESPEC='', # hack to make reusing the same templates work.
         CLASSNAME=self._class_name,
         EXTENDS=extends,
         IMPLEMENTS=' implements ' + implements_str)
 
-    # Document requires a custom wrapper.
-    if dom_name != 'Document':
-      self._members_emitter.Emit(
-          '  $(CLASSNAME)._wrap(ptr) : super._wrap(ptr);\n',
-          CLASSNAME=self._class_name)
+    self._members_emitter.Emit(
+        '  $(CLASSNAME)._wrap(ptr) : super._wrap(ptr);\n',
+        CLASSNAME=self._class_name)
 
     # Emit a factory provider class for the constructor.
     constructor_info = AnalyzeConstructor(interface)
     if constructor_info:
       self._EmitFactoryProvider(interface_name, constructor_info)
 
     emit_events, events = self._shared.GetEventAttributes(self._interface)
     if not emit_events:
       return
     elif events:
@@ skipping 63 matching lines @@
 
   def _MethodName(self, prefix, name):
     method_name = prefix + name
     if name in self._base_members:  # Avoid illegal Dart 'static override'.
       method_name = method_name + '_' + self._interface.id
     return method_name
 
   def AddAttribute(self, getter, setter):
     dom_name = DartDomNameOfAttribute(getter or setter)
     html_getter_name = self._shared.RenameInHtmlLibrary(
-        self._interface, dom_name, 'get:')
+        self._interface, dom_name, 'get:', implementation_class=True)
     html_setter_name = self._shared.RenameInHtmlLibrary(
-        self._interface, dom_name, 'set:')
+        self._interface, dom_name, 'set:', implementation_class=True)
 
     if getter and html_getter_name:
       self._AddGetter(getter, html_getter_name)
     if setter and html_setter_name:
       self._AddSetter(setter, html_setter_name)
 
   def _AddGetter(self, attr, html_name):
-    if self._shared.MaybeReturnDocument(attr.type.id): 
-      self._members_emitter.Emit(
-          '\n'
-          '  $TYPE get $(HTML_NAME)() => '
-          '_FixHtmlDocumentReference(_wrap($(THIS).$DOM_NAME));\n',
-          HTML_NAME=html_name,
-          DOM_NAME=DartDomNameOfAttribute(attr),
-          TYPE=DartType(attr.type.id),
-          THIS=self.DomObjectName())
-    else:
-      self._members_emitter.Emit(
-        '\n'
-        '  $TYPE get $(HTML_NAME)() => _wrap($(THIS).$DOM_NAME);\n',
-        HTML_NAME=html_name,
-        DOM_NAME=DartDomNameOfAttribute(attr),
-        TYPE=DartType(attr.type.id),
-        THIS=self.DomObjectName())
+    self._members_emitter.Emit(
+      '\n'
+      '  $TYPE get $(HTML_NAME)() => _wrap($(THIS).$DOM_NAME);\n',
+      HTML_NAME=html_name,
+      DOM_NAME=DartDomNameOfAttribute(attr),
+      TYPE=DartType(attr.type.id),
+      THIS=self.DomObjectName())
 
   def _AddSetter(self, attr, html_name):
     self._members_emitter.Emit(
         '\n'
         '  void set $(HTML_NAME)($TYPE value) { '
         '$(THIS).$DOM_NAME = _unwrap(value); }\n',
         HTML_NAME=html_name,
         DOM_NAME=DartDomNameOfAttribute(attr),
         TYPE=DartType(attr.type.id),
         THIS=self.DomObjectName())
@@ skipping 213 matching lines @@
         '  }\n',
         THIS=self.DomObjectName(),
         TYPE=DartType(element_type),
         METHOD=method_name)
 
   def AddOperation(self, info):
     """
     Arguments:
       info: An OperationInfo object.
     """
-    html_name = self._shared.RenameInHtmlLibrary(self._interface, info.name)
+    html_name = self._shared.RenameInHtmlLibrary(
+        self._interface, info.name, implementation_class=True)
 
     if not html_name:
       return
 
     body = self._members_emitter.Emit(
         '\n'
         '  $TYPE $HTML_NAME($PARAMS) {\n'
         '$!BODY'
         '  }\n',
         TYPE=info.type_name,
@@ skipping 19 matching lines @@
       operation: the IDLOperation to call.
     """
     argument_expressions = self._UnwrappedParameters(
         info,
         len(operation.arguments))  # Just the parameters this far.
 
     if info.type_name != 'void':
       # We could place the logic for handling Document directly in _wrap
       # but we chose to place it here so that bugs in the wrapper and
       # wrapperless implementations are more consistent. 
-      if self._shared.MaybeReturnDocument(info.type_name): 
-        emitter.Emit('$(INDENT)return _FixHtmlDocumentReference('
-                     '_wrap($(THIS).$NAME($ARGS)));\n',
-                     INDENT=indent,
-                     THIS=self.DomObjectName(),
-                     NAME=info.name,
-                     ARGS=argument_expressions)
-      else:
-        emitter.Emit('$(INDENT)return _wrap($(THIS).$NAME($ARGS));\n',
-                     INDENT=indent,
-                     THIS=self.DomObjectName(),
-                     NAME=info.name,
-                     ARGS=argument_expressions)
+      emitter.Emit('$(INDENT)return _wrap($(THIS).$NAME($ARGS));\n',
+                   INDENT=indent,
+                   THIS=self.DomObjectName(),
+                   NAME=info.name,
+                   ARGS=argument_expressions)
     else:
       emitter.Emit('$(INDENT)$(THIS).$NAME($ARGS);\n'
                    '$(INDENT)return;\n',
                    INDENT=indent,
                    THIS=self.DomObjectName(),
                    NAME=info.name,
                    ARGS=argument_expressions)
 
   def GenerateDispatch(self, emitter, info, indent, position, overloads):
     """Generates a dispatch to one of the overloads.
@@ skipping 85 matching lines @@
     # dispatch has removed f(X), leaving only f(Y), but there is no guarantee
     # that Y = Z-X, so we need to check for Y.
     true_code = emitter.Emit(
         '$(INDENT)if ($COND) {\n'
         '$!TRUE'
         '$(INDENT)}\n',
         COND=test, INDENT=indent)
     self.GenerateDispatch(
         true_code, info, indent + '  ', position + 1, positive)
     return True