dart:html perf optimization based on runing Dromaeo benchmarks

lib/dom/templates/html/impl/impl_Element.darttemplate

 // 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.
 
 // TODO(jacobr): use _Lists.dart to remove some of the duplicated
 // functionality.
 class _ChildrenElementList implements ElementList {
   // Raw Element.
   final _ElementImpl _element;
   final _HTMLCollectionImpl _childElements;
 
   _ChildrenElementList._wrap(_ElementImpl element)
-    : _childElements = element._children,
+    : _childElements = element.$dom_children,
       _element = element;
 
   List<Element> _toList() {
     final output = new List(_childElements.length);
     for (int i = 0, len = _childElements.length; i < len; i++) {
       output[i] = _childElements[i];
     }
     return output;
   }
 
   _ElementImpl get first() {
-    return _element._firstElementChild;
+    return _element.$dom_firstElementChild;
   }
 
   void forEach(void f(Element element)) {
     for (_ElementImpl element in _childElements) {
       f(element);
     }
   }
 
   ElementList filter(bool f(Element element)) {
     final output = <Element>[];
@@ skipping 25 matching lines @@
 
   Collection map(f(Element element)) {
     final out = [];
     for (Element el in this) {
       out.add(f(el));
     }
     return out;
   }
 
   bool isEmpty() {
-    return _element._firstElementChild == null;
+    return _element.$dom_firstElementChild == null;
   }
 
   int get length() {
     return _childElements.length;
   }
 
   _ElementImpl operator [](int index) {
     return _childElements[index];
   }
 
   void operator []=(int index, _ElementImpl value) {
-    _element._replaceChild(value, _childElements[index]);
+    _element.$dom_replaceChild(value, _childElements[index]);
   }
 
    void set length(int newLength) {
      // TODO(jacobr): remove children when length is reduced.
      throw const UnsupportedOperationException('');
    }
 
   Element add(_ElementImpl value) {
-    _element._appendChild(value);
+    _element.$dom_appendChild(value);
     return value;
   }
 
   Element addLast(_ElementImpl value) => add(value);
 
   Iterator<Element> iterator() => _toList().iterator();
 
   void addAll(Collection<Element> collection) {
     for (_ElementImpl element in collection) {
-      _element._appendChild(element);
+      _element.$dom_appendChild(element);
     }
   }
 
   void sort(int compare(Element a, Element b)) {
     throw const UnsupportedOperationException('TODO(jacobr): should we impl?');
   }
 
   void copyFrom(List<Object> src, int srcStart, int dstStart, int count) {
     throw 'Not impl yet. todo(jacobr)';
   }
@@ skipping 24 matching lines @@
   }
 
   void clear() {
     // It is unclear if we want to keep non element nodes?
     _element.text = '';
   }
 
   Element removeLast() {
     final last = this.last();
     if (last != null) {
-      _element._removeChild(last);
+      _element.$dom_removeChild(last);
     }
     return last;
   }
 
   Element last() {
-    return _element.lastElementChild;
+    return _element.$dom_lastElementChild;
   }
 }
 
 // TODO(jacobr): this is an inefficient implementation but it is hard to see
 // a better option given that we cannot quite force NodeList to be an
 // ElementList as there are valid cases where a NodeList JavaScript object
 // contains Node objects that are not Elements.
 class _FrozenElementList implements ElementList {
   final List<Node> _nodeList;
 
@@ skipping 141 matching lines @@
     new _ElementList(super.getRange(start, length));
 }
 
 class ElementAttributeMap implements Map<String, String> {
 
   final _ElementImpl _element;
 
   ElementAttributeMap._wrap(this._element);
 
   bool containsValue(String value) {
-    final attributes = _element._attributes;
+    final attributes = _element.$dom_attributes;
     for (int i = 0, len = attributes.length; i < len; i++) {
       if(value == attributes[i].value) {
         return true;
       }
     }
     return false;
   }
 
   bool containsKey(String key) {
-    return _element._hasAttribute(key);
+    return _element.$dom_hasAttribute(key);
   }
 
   String operator [](String key) {
-    return _element._getAttribute(key);
+    return _element.$dom_getAttribute(key);
   }
 
   void operator []=(String key, String value) {
-    _element._setAttribute(key, value);
+    _element.$dom_setAttribute(key, value);
   }
 
   String putIfAbsent(String key, String ifAbsent()) {
     if (!containsKey(key)) {
       this[key] = ifAbsent();
     }
   }
 
   String remove(String key) {
-    _element._removeAttribute(key);
+    _element.$dom_removeAttribute(key);
   }
 
   void clear() {
-    final attributes = _element._attributes;
+    final attributes = _element.$dom_attributes;
     for (int i = attributes.length - 1; i >= 0; i--) {
       remove(attributes[i].name);
     }
   }
 
   void forEach(void f(String key, String value)) {
-    final attributes = _element._attributes;
+    final attributes = _element.$dom_attributes;
     for (int i = 0, len = attributes.length; i < len; i++) {
       final item = attributes[i];
       f(item.name, item.value);
     }
   }
 
   Collection<String> getKeys() {
     // TODO(jacobr): generate a lazy collection instead.
-    final attributes = _element._attributes;
+    final attributes = _element.$dom_attributes;
     final keys = new List<String>(attributes.length);
     for (int i = 0, len = attributes.length; i < len; i++) {
       keys[i] = attributes[i].name;
     }
     return keys;
   }
 
   Collection<String> getValues() {
     // TODO(jacobr): generate a lazy collection instead.
-    final attributes = _element._attributes;
+    final attributes = _element.$dom_attributes;
     final values = new List<String>(attributes.length);
     for (int i = 0, len = attributes.length; i < len; i++) {
       values[i] = attributes[i].value;
     }
     return values;
   }
 
   /**
    * The number of {key, value} pairs in the map.
    */
   int get length() {
-    return _element._attributes.length;
+    return _element.$dom_attributes.length;
   }
 
   /**
    * Returns true if there is no {key, value} pair in the map.
    */
   bool isEmpty() {
     return length == 0;
   }
 }
 
@@ skipping 26 matching lines @@
   final ClientRect client;
   final ClientRect offset;
   final ClientRect scroll;
 
   // TODO(jacobr): should we move these outside of ElementRect to avoid the
   // overhead of computing them every time even though they are rarely used.
   final _ClientRectImpl _boundingClientRect; 
   final _ClientRectListImpl _clientRects;
 
   _ElementRectImpl(_ElementImpl element) :
-    client = new _SimpleClientRect(element._clientLeft,
-                                  element._clientTop,
-                                  element._clientWidth, 
-                                  element._clientHeight), 
-    offset = new _SimpleClientRect(element._offsetLeft,
-                                  element._offsetTop,
-                                  element._offsetWidth,
-                                  element._offsetHeight),
-    scroll = new _SimpleClientRect(element._scrollLeft,
-                                  element._scrollTop,
-                                  element._scrollWidth,
-                                  element._scrollHeight),
-    _boundingClientRect = element._getBoundingClientRect(),
-    _clientRects = element._getClientRects();
+    client = new _SimpleClientRect(element.$dom_clientLeft,
+                                  element.$dom_clientTop,
+                                  element.$dom_clientWidth, 
+                                  element.$dom_clientHeight), 
+    offset = new _SimpleClientRect(element.$dom_offsetLeft,
+                                  element.$dom_offsetTop,
+                                  element.$dom_offsetWidth,
+                                  element.$dom_offsetHeight),
+    scroll = new _SimpleClientRect(element.$dom_scrollLeft,
+                                  element.$dom_scrollTop,
+                                  element.$dom_scrollWidth,
+                                  element.$dom_scrollHeight),
+    _boundingClientRect = element.$dom_getBoundingClientRect(),
+    _clientRects = element.$dom_getClientRects();
 
   _ClientRectImpl get bounding() => _boundingClientRect;
 
   // TODO(jacobr): cleanup.
   List<ClientRect> get clientRects() {
     final out = new List(_clientRects.length);
     for (num i = 0; i < _clientRects.length; i++) {
       out[i] = _clientRects.item(i);
     }
     return out;
@@ skipping 28 matching lines @@
 
   void set elements(Collection<Element> value) {
     final elements = this.elements;
     elements.clear();
     elements.addAll(value);
   }
 
   ElementList get elements() => new _ChildrenElementList._wrap(this);
 
   ElementList queryAll(String selectors) =>
-    new _FrozenElementList._wrap(_querySelectorAll(selectors));
+    new _FrozenElementList._wrap($dom_querySelectorAll(selectors));
 
   Set<String> get classes() {
     if (_cssClassSet === null) {
       _cssClassSet = new _CssClassSet(this);
     }
     return _cssClassSet;
   }
 
   void set classes(Collection<String> value) {
     _CssClassSet classSet = classes;
@@ skipping 22 matching lines @@
         new Completer<ElementRect>());
   }
 
   Future<CSSStyleDeclaration> get computedStyle() {
      // TODO(jacobr): last param should be null, see b/5045788
      return getComputedStyle('');
   }
 
   Future<CSSStyleDeclaration> getComputedStyle(String pseudoElement) {
     return _createMeasurementFuture(
-        () => _window._getComputedStyle(this, pseudoElement),
+        () => _window.$dom_getComputedStyle(this, pseudoElement),
         new Completer<CSSStyleDeclaration>());
   }
 $!MEMBERS
 }
+
+final _START_TAG_REGEXP = const RegExp('<(\\w+)');
+class _ElementFactoryProvider {
+  static final _CUSTOM_PARENT_TAG_MAP = const {
+    'body' : 'html',
+    'head' : 'html',
+    'caption' : 'table',
+    'td': 'tr',
+    'colgroup': 'table',
+    'col' : 'colgroup',
+    'tr' : 'tbody',
+    'tbody' : 'table',
+    'tfoot' : 'table',
+    'thead' : 'table',
+    'track' : 'audio',
+  };
+
+  /** @domName Document.createElement */
+  factory Element.html(String html) {
+    // TODO(jacobr): this method can be made more robust and performant.
+    // 1) Cache the dummy parent elements required to use innerHTML rather than
+    //    creating them every call.
+    // 2) Verify that the html does not contain leading or trailing text nodes.
+    // 3) Verify that the html does not contain both <head> and <body> tags.
+    // 4) Detatch the created element from its dummy parent.
+    String parentTag = 'div';
+    String tag;
+    final match = _START_TAG_REGEXP.firstMatch(html);
+    if (match !== null) {
+      tag = match.group(1).toLowerCase();
+      if (_CUSTOM_PARENT_TAG_MAP.containsKey(tag)) {
+        parentTag = _CUSTOM_PARENT_TAG_MAP[tag];
+      }
+    }
+    final _ElementImpl temp = new Element.tag(parentTag);
+    temp.innerHTML = html;
+
+    Element element;
+    if (temp.elements.length == 1) {
+      element = temp.elements.first;
+    } else if (parentTag == 'html' && temp.elements.length == 2) {
+      // Work around for edge case in WebKit and possibly other browsers where
+      // both body and head elements are created even though the inner html
+      // only contains a head or body element.
+      element = temp.elements[tag == 'head' ? 0 : 1];
+    } else {
+      throw new IllegalArgumentException('HTML had ${temp.elements.length} ' +
+          'top level elements but 1 expected');
+    }
+    element.remove();
+    return element;
+  }
+
+  /** @domName Document.createElement */
+$if FROG
+  // Optimization to improve performance until the frog compiler inlines this
+  // method.
+  factory Element.tag(String tag) native "return document.createElement(tag)";
+$else
+  factory Element.tag(String tag) => _document.$dom_createElement(tag);
+$endif
+}