restore 30868 and 30873

pkg/template_binding/lib/src/template.dart

 // Copyright (c) 2013, 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.
 
 part of template_binding;
 
 /** Extensions to [Element]s that behave as templates. */
 class TemplateBindExtension extends _ElementExtension {
   var _model;
   BindingDelegate _bindingDelegate;
   _TemplateIterator _iterator;
   bool _scheduled = false;
 
   Element _templateInstanceRef;
 
   // Note: only used if `this is! TemplateElement`
   DocumentFragment _content;
   bool _templateIsDecorated;
 
+  HtmlDocument _stagingDocument;
+
   var _bindingMap;
 
   TemplateBindExtension._(Element node) : super(node);
 
   Element get _node => super._node;
 
   TemplateBindExtension get _self => super._node is TemplateBindExtension
       ? _node : this;
 
   NodeBinding bind(String name, model, [String path]) {
@@ skipping 81 matching lines @@
     // Dart note: we store _bindingMap on the TemplateBindExtension instead of
     // the "content" because we already have an expando for it.
     var map = ref._bindingMap;
     if (map == null) {
       // TODO(rafaelw): Setup a MutationObserver on content to detect
       // when the instanceMap is invalid.
       map = new _InstanceBindingMap(content, delegate);
       ref._bindingMap = map;
     }
 
-    var instance = map.hasSubTemplate
-        ? _deepCloneIgnoreTemplateContent(content)
-        : content.clone(true);
+    var staging = _getTemplateStagingDocument();
+    var instance = _deepCloneIgnoreTemplateContent(content, staging);
 
     _addMapBindings(instance, map, model, delegate, bound);
     // TODO(rafaelw): We can do this more lazily, but setting a sentinel
     // in the parent of the template element, and creating it when it's
     // asked for by walking back to find the iterating template.
     _addTemplateInstanceRecord(instance, model);
     return instance;
   }
 
   /** The data model which is inherited through the tree. */
   get model => _model;
 
   void set model(value) {
     _model = value;
     _ensureSetModelScheduled();
   }
 
-  static Node _deepCloneIgnoreTemplateContent(Node node) {
-    var clone = node.clone(false); // Shallow clone.
+  static Node _deepCloneIgnoreTemplateContent(Node node, stagingDocument) {
+    var clone = stagingDocument.importNode(node, false);
     if (isSemanticTemplate(clone)) return clone;
 
     for (var c = node.firstChild; c != null; c = c.nextNode) {
-      clone.append(_deepCloneIgnoreTemplateContent(c));
+      clone.append(_deepCloneIgnoreTemplateContent(c, stagingDocument));
     }
     return clone;
   }
 
   /**
    * The binding delegate which is inherited through the tree. It can be used
    * to configure custom syntax for `{{bindings}}` inside this template.
    */
   BindingDelegate get bindingDelegate => _bindingDelegate;
 
@@ skipping 77 matching lines @@
             'attribute templates.');
       }
       templateElementExt = templateBind(
           _extractTemplateFromAttributeTemplate(_node));
       templateElementExt._templateIsDecorated = true;
       isNative = templateElementExt._node is TemplateElement;
       liftRoot = true;
      }
 
     if (!isNative) {
-      var doc = _getTemplateContentsOwner(
-          templateElementExt._node.ownerDocument);
+      var doc = _getOrCreateTemplateContentsOwner(templateElementExt._node);
       templateElementExt._content = doc.createDocumentFragment();
     }
 
     if (instanceRef != null) {
       // template is contained within an instance, its direct content must be
       // empty
       templateElementExt._templateInstanceRef = instanceRef;
     } else if (liftContents) {
       _liftNonNativeChildrenIntoContent(templateElementExt, _node, liftRoot);
     } else if (bootstrapContents) {
       bootstrap(templateElementExt.content);
     }
 
     return true;
   }
 
   static final _contentsOwner = new Expando();
+  static final _ownerStagingDocument = new Expando();
 
   // http://dvcs.w3.org/hg/webcomponents/raw-file/tip/spec/templates/index.html#dfn-template-contents-owner
-  static Document _getTemplateContentsOwner(HtmlDocument doc) {
-    if (doc.window == null) {
-      return doc;
-    }
+  static HtmlDocument _getOrCreateTemplateContentsOwner(Element template) {
+    var doc = template.ownerDocument;
+    if (doc.window == null) return doc;
+
     var d = _contentsOwner[doc];
     if (d == null) {
       // TODO(arv): This should either be a Document or HTMLDocument depending
       // on doc.
       d = doc.implementation.createHtmlDocument('');
       while (d.lastChild != null) {
         d.lastChild.remove();
       }
       _contentsOwner[doc] = d;
     }
     return d;
   }
 
+  HtmlDocument _getTemplateStagingDocument() {
+    if (_stagingDocument == null) {
+      var owner = _node.ownerDocument;
+      var doc = _ownerStagingDocument[owner];
+      if (doc == null) {
+        doc = owner.implementation.createHtmlDocument('');
+        _ownerStagingDocument[owner] = doc;
+      }
+      _stagingDocument = doc;
+    }
+    return _stagingDocument;
+  }
+
   // For non-template browsers, the parser will disallow <template> in certain
   // locations, so we allow "attribute templates" which combine the template
   // element with the top-level container node of the content, e.g.
   //
   //   <tr template repeat="{{ foo }}"" class="bar"><td>Bar</td></tr>
   //
   // becomes
   //
   //   <template repeat="{{ foo }}">
   //   + #document-fragment
@@ skipping 134 matching lines @@
     node = node.parentNode;
   }
 
   // Note: JS code tests that getElementById is present. We can't do that
   // easily, so instead check for the types known to implement it.
   if (node is Document || node is ShadowRoot || node is SvgSvgElement) {
     return node;
   }
   return null;
 }