Rename mdv -> template_binding, remove experiemntal apis from dart:html

pkg/polymer/lib/src/instance.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 polymer;
 
 /**
  * Use this annotation to publish a field as an attribute. For example:
  *
  *     class MyPlaybackElement extends PolymerElement {
  *       // This will be available as an HTML attribute, for example:
  *       //     <my-playback volume="11">
  *       @published double volume;
  *     }
  */
 // TODO(jmesserly): does @published imply @observable or vice versa?
 const published = const PublishedProperty();
 
 /** An annotation used to publish a field as an attribute. See [published]. */
 class PublishedProperty extends ObservableProperty {
   const PublishedProperty();
 }
 
 /**
  * The mixin class for Polymer elements. It provides convenience features on top
  * of the custom elements web standard.
  */
-abstract class Polymer implements Element {
+abstract class Polymer implements Element, NodeBindExtension {
   // Fully ported from revision:
   // https://github.com/Polymer/polymer/blob/4dc481c11505991a7c43228d3797d28f21267779
   //
   //   src/instance/attributes.js
   //   src/instance/base.js
   //   src/instance/events.js
   //   src/instance/mdv.js
   //   src/instance/properties.js
   //   src/instance/utils.js
   //
@@ skipping 325 matching lines @@
       // attrs.
     } else if (propValue is bool) {
       attributes.remove(name);
     }
   }
 
   /**
    * Creates the document fragment to use for each instance of the custom
    * element, given the `<template>` node. By default this is equivalent to:
    *
-   *     template.createInstance(this, polymerSyntax);
+   *     templateBind(template).createInstance(this, polymerSyntax);
    *
    * Where polymerSyntax is a singleton `PolymerExpressions` instance from the
    * [polymer_expressions](https://pub.dartlang.org/packages/polymer_expressions)
    * package.
    *
    * You can override this method to change the instantiation behavior of the
    * template, for example to use a different data-binding syntax.
    */
   DocumentFragment instanceTemplate(Element template) =>
-      template.createInstance(this, _polymerSyntax);
+      templateBind(template).createInstance(this, _polymerSyntax);
+
+  NodeBinding createBinding(String name, model, String path) =>
+      nodeBindFallback(this).createBinding(name, model, path);
 
   NodeBinding bind(String name, model, String path) {
     // note: binding is a prepare signal. This allows us to be sure that any
     // property changes that occur as a result of binding will be observed.
     if (!_elementPrepared) prepareElement();
 
     var property = propertyForAttribute(name);
     if (property != null) {
       unbind(name);
       // use n-way Polymer binding
       var observer = bindProperty(property.simpleName, model, path);
       // reflect bound property to attribute when binding
       // to ensure binding is not left on attribute if property
       // does not update due to not changing.
       // Dart note: we include this patch:
       // https://github.com/Polymer/polymer/pull/319
       reflectPropertyToAttribute(MirrorSystem.getName(property.simpleName));
       return bindings[name] = observer;
     } else {
-      // Cannot call super.bind because of
-      // https://code.google.com/p/dart/issues/detail?id=13156
-      // https://code.google.com/p/dart/issues/detail?id=12456
-      return TemplateElement.mdvPackage(this).bind(name, model, path);
+      // Cannot call super.bind because template_binding is its own package
+      return nodeBindFallback(this).bind(name, model, path);
     }
   }
 
+  Map<String, NodeBinding> get bindings => nodeBindFallback(this).bindings;
+
+  void unbind(String name) => nodeBindFallback(this).unbind(name);
+
   void asyncUnbindAll() {
     if (_unbound == true) return;
     _unbindLog.fine('[$localName] asyncUnbindAll');
     _unbindAllJob = job(_unbindAllJob, unbindAll, const Duration(seconds: 0));
   }
 
   void unbindAll() {
     if (_unbound == true) return;
 
     unbindAllProperties();
-    // Cannot call super.bind because of
-    // https://code.google.com/p/dart/issues/detail?id=13156
-    // https://code.google.com/p/dart/issues/detail?id=12456
-    TemplateElement.mdvPackage(this).unbindAll();
+    nodeBindFallback(this).unbindAll();
 
     _unbindNodeTree(shadowRoot);
     // TODO(sjmiles): must also unbind inherited shadow roots
     _unbound = true;
   }
 
   void cancelUnbindAll({bool preventCascade}) {
     if (_unbound == true) {
       _unbindLog.warning(
           '[$localName] already unbound, cannot cancel unbindAll');
       return;
     }
     _unbindLog.fine('[$localName] cancelUnbindAll');
     if (_unbindAllJob != null) {
       _unbindAllJob.stop();
       _unbindAllJob = null;
     }
 
     // cancel unbinding our shadow tree iff we're not in the process of
     // cascading our tree (as we do, for example, when the element is inserted).
     if (preventCascade == true) return;
     _forNodeTree(shadowRoot, (n) {
       if (n is Polymer) {
         (n as Polymer).cancelUnbindAll();
       }
     });
   }
 
   static void _unbindNodeTree(Node node) {
-    _forNodeTree(node, (node) => node.unbindAll());
+    _forNodeTree(node, (node) => nodeBind(node).unbindAll());
   }
 
   static void _forNodeTree(Node node, void callback(Node node)) {
     if (node == null) return;
 
     callback(node);
     for (var child = node.firstChild; child != null; child = child.nextNode) {
       _forNodeTree(child, callback);
     }
   }
@@ skipping 487 matching lines @@
 /**
  * Base class for PolymerElements deriving from HtmlElement.
  *
  * See [Polymer].
  */
 class PolymerElement extends HtmlElement with Polymer, Observable {
   PolymerElement.created() : super.created() {
     polymerCreated();
   }
 }