port polymer - 00e2982c78fcd396adaebff3118e94029a2b9fb0

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, Observable, NodeBindExtension {
   // Fully ported from revision:
-  // https://github.com/Polymer/polymer/blob/4dc481c11505991a7c43228d3797d28f21267779
+  // https://github.com/Polymer/polymer/blob/00e2982c78fcd396adaebff3118e94029a2b9fb0
   //
+  //   src/boot.js (static APIs on "Polymer" object)
   //   src/instance/attributes.js
   //   src/instance/base.js
   //   src/instance/events.js
   //   src/instance/mdv.js
   //   src/instance/properties.js
+  //   src/instance/style.js
   //   src/instance/utils.js
-  //
-  // Not yet ported:
-  //   src/instance/style.js -- blocked on ShadowCSS.shimPolyfillDirectives
 
   // TODO(jmesserly): should this really be public?
   /** Regular expression that matches data-bindings. */
   static final bindPattern = new RegExp(r'\{\{([^{}]*)}}');
 
   /**
    * Like [document.register] but for Polymer elements.
    *
    * Use the [name] to specify custom elment's tag name, for example:
    * "fancy-button" if the tag is used as `<fancy-button>`.
@@ skipping 23 matching lines @@
    * Future indicating that the Polymer library has been loaded and is ready
    * for use.
    */
   static Future get onReady => _ready.future;
 
   PolymerDeclaration _declaration;
 
   /** The most derived `<polymer-element>` declaration for this element. */
   PolymerDeclaration get declaration => _declaration;
 
-  Map<String, StreamSubscription> _elementObservers;
+  Map<String, StreamSubscription> _observers;
   bool _unbound; // lazy-initialized
   Job _unbindAllJob;
 
+  StreamSubscription _propertyObserver;
+
   bool get _elementPrepared => _declaration != null;
 
   bool get applyAuthorStyles => false;
   bool get resetStyleInheritance => false;
   bool get alwaysPrepare => false;
+  bool get preventDispose => false;
 
   /**
    * Shadow roots created by [parseElement]. See [getShadowRoot].
    */
   final _shadowRoots = new HashMap<String, ShadowRoot>();
 
   /** Map of items in the shadow root(s) by their [Element.id]. */
   // TODO(jmesserly): various issues:
   // * wrap in UnmodifiableMapView?
   // * should we have an object that implements noSuchMethod?
@@ skipping 35 matching lines @@
     // Dart note: get the _declaration, which also marks _elementPrepared
     _declaration = _getDeclaration(this.runtimeType);
     // do this first so we can observe changes during initialization
     observeProperties();
     // install boilerplate attributes
     copyInstanceAttributes();
     // process input attributes
     takeAttributes();
     // add event listeners
     addHostListeners();
-    // guarantees that while preparing, any sub-elements will also be prepared
+    // guarantees that while preparing, any
+    // sub-elements are also prepared
     _preparingElements++;
     // process declarative resources
     parseDeclarations(_declaration);
+    // decrement semaphore
     _preparingElements--;
     // user entry point
     ready();
   }
 
   /** Called when [prepareElement] is finished. */
   void ready() {}
 
   void enteredView() {
     if (!_elementPrepared) {
       prepareElement();
     }
     cancelUnbindAll(preventCascade: true);
   }
 
   void leftView() {
-    asyncUnbindAll();
+    if (!preventDispose) asyncUnbindAll();
   }
 
   /** Recursive ancestral <element> initialization, oldest first. */
   void parseDeclarations(PolymerDeclaration declaration) {
     if (declaration != null) {
       parseDeclarations(declaration.superDeclaration);
       parseDeclaration(declaration);
     }
   }
 
   /**
    * Parse input `<polymer-element>` as needed, override for custom behavior.
    */
   void parseDeclaration(Element elementElement) {
-    var root = shadowFromTemplate(fetchTemplate(elementElement));
+    var template = fetchTemplate(elementElement);
+
+    var root = null;
+    if (template != null) {
+      if (_declaration.attributes.containsKey('lightdom')) {
+        lightFromTemplate(template);
+      } else {
+        root = shadowFromTemplate(template);
+      }
+    }
 
     // Dart note: the following code is to support the getShadowRoot method.
     if (root is! ShadowRoot) return;
 
     var name = elementElement.attributes['name'];
     if (name == null) return;
     _shadowRoots[name] = root;
   }
 
   /**
    * Return a shadow-root template (if desired), override for custom behavior.
    */
   Element fetchTemplate(Element elementElement) =>
       elementElement.query('template');
 
   /**
+   * Utility function that stamps a `<template>` into light-dom.
+   */
+  Node lightFromTemplate(Element template) {
+    if (template == null) return null;
+    // stamp template
+    // which includes parsing and applying MDV bindings before being
+    // inserted (to avoid {{}} in attribute values)
+    // e.g. to prevent <img src="images/{{icon}}"> from generating a 404.
+    var dom = instanceTemplate(template);
+    // append to shadow dom
+    append(dom);
+    // perform post-construction initialization tasks on shadow root
+    shadowRootReady(this, template);
+    // return the created shadow root
+    return dom;
+  }
+
+  /**
    * Utility function that creates a shadow root from a `<template>`.
    *
    * The base implementation will return a [ShadowRoot], but you can replace it
    * with your own code and skip ShadowRoot creation. In that case, you should
    * return `null`.
    *
    * In your overridden method, you can use [instanceTemplate] to stamp the
    * template and initialize data binding, and [shadowRootReady] to intialize
    * other Polymer features like event handlers. It is fine to call
    * shadowRootReady with a node something other than a ShadowRoot; for example,
@@ skipping 43 matching lines @@
       $[n.id] = n;
     }
   }
 
   void attributeChanged(String name, String oldValue, String newValue) {
     if (name != 'class' && name != 'style') {
       attributeToProperty(name, newValue);
     }
   }
 
-  // TODO(jmesserly): use stream or future here?
+  // TODO(jmesserly): this could be a top level method.
   /**
-   * Run the `listener` callback *once*
-   * when `node` changes, or when its children or subtree changes.
+   * Returns a future when `node` changes, or when its children or subtree
+   * changes.
    *
-   *
-   * See [MutationObserver] if you want to listen to a stream of
-   * changes.
+   * Use [MutationObserver] if you want to listen to a stream of changes.
    */
-  void onMutation(Node node, void listener(MutationObserver obs)) {
-    new MutationObserver((records, MutationObserver observer) {
-      listener(observer);
+  Future<List<MutationRecord>> onMutation(Node node) {
+    var completer = new Completer();
+    new MutationObserver((mutations, observer) {
       observer.disconnect();
+      completer.complete(mutations);
     })..observe(node, childList: true, subtree: true);
+    return completer.future;
   }
 
   void copyInstanceAttributes() {
     _declaration._instanceAttributes.forEach((name, value) {
       attributes.putIfAbsent(name, () => value);
     });
   }
 
   void takeAttributes() {
     if (_declaration._publishLC == null) return;
@@ skipping 10 matching lines @@
     var property = propertyForAttribute(name);
     if (property == null) return;
 
     // filter out 'mustached' values, these are to be
     // replaced with bound-data and are not yet values
     // themselves.
     if (value == null || value.contains(Polymer.bindPattern)) return;
 
     // get original value
     final self = reflect(this);
-    final defaultValue = self.getField(property.simpleName).reflectee;
+    final currentValue = self.getField(property.simpleName).reflectee;
 
     // deserialize Boolean or Number values from attribute
-    final newValue = deserializeValue(value, defaultValue,
-        _inferPropertyType(defaultValue, property));
+    final newValue = deserializeValue(value, currentValue,
+        _inferPropertyType(currentValue, property));
 
     // only act if the value has changed
-    if (!identical(newValue, defaultValue)) {
+    if (!identical(newValue, currentValue)) {
       // install new value (has side-effects)
       self.setField(property.simpleName, newValue);
     }
   }
 
   /** Return the published property matching name, or null. */
   // TODO(jmesserly): should we just return Symbol here?
   DeclarationMirror propertyForAttribute(String name) {
     final publishLC = _declaration._publishLC;
     if (publishLC == null) return null;
     //console.log('propertyForAttribute:', name, 'matches', match);
     return publishLC[name];
   }
 
   /**
-   * Convert representation of [value] based on [type] and [defaultValue].
+   * Convert representation of [value] based on [type] and [currentValue].
    */
   // TODO(jmesserly): this should probably take a ClassMirror instead of
   // TypeMirror, but it is currently impossible to get from a TypeMirror to a
   // ClassMirror.
-  Object deserializeValue(String value, Object defaultValue, TypeMirror type) =>
-      deserialize.deserializeValue(value, defaultValue, type);
+  Object deserializeValue(String value, Object currentValue, TypeMirror type) =>
+      deserialize.deserializeValue(value, currentValue, type);
 
   String serializeValue(Object value) {
     if (value == null) return null;
 
     if (value is bool) {
       return _toBoolean(value) ? '' : null;
     } else if (value is String || value is int || value is double) {
       return '$value';
     }
     return null;
   }
 
-  void reflectPropertyToAttribute(String name) {
+  void reflectPropertyToAttribute(Symbol name) {
     // TODO(sjmiles): consider memoizing this
     final self = reflect(this);
     // try to intelligently serialize property value
     // TODO(jmesserly): cache symbol?
-    final propValue = self.getField(new Symbol(name)).reflectee;
+    final propValue = self.getField(name).reflectee;
     final serializedValue = serializeValue(propValue);
     // boolean properties must reflect as boolean attributes
     if (serializedValue != null) {
-      attributes[name] = serializedValue;
+      attributes[MirrorSystem.getName(name)] = serializedValue;
       // TODO(sorvell): we should remove attr for all properties
       // that have undefined serialization; however, we will need to
       // refine the attr reflection system to achieve this; pica, for example,
       // relies on having inferredType object properties not removed as
       // attrs.
     } else if (propValue is bool) {
-      attributes.remove(name);
+      attributes.remove(MirrorSystem.getName(name));
     }
   }
 
   /**
    * Creates the document fragment to use for each instance of the custom
    * element, given the `<template>` node. By default this is equivalent to:
    *
    *     templateBind(template).createInstance(this, polymerSyntax);
    *
    * Where polymerSyntax is a singleton `PolymerExpressions` instance from the
@@ skipping 17 matching lines @@
     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));
+      reflectPropertyToAttribute(property.simpleName);
       return bindings[name] = observer;
     } else {
       // 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();
     nodeBindFallback(this).unbindAll();
 
-    _unbindNodeTree(shadowRoot);
-    // TODO(sjmiles): must also unbind inherited shadow roots
+    var root = shadowRoot;
+    while (root != null) {
+      _unbindNodeTree(root);
+      root = root.olderShadowRoot;
+    }
     _unbound = true;
   }
 
   void cancelUnbindAll({bool preventCascade}) {
     if (_unbound == true) {
       _unbindLog.warning(
           '[$localName] already unbound, cannot cancel unbindAll');
       return;
     }
     _unbindLog.fine('[$localName] cancelUnbindAll');
@@ skipping 20 matching lines @@
     if (node == null) return;
 
     callback(node);
     for (var child = node.firstChild; child != null; child = child.nextNode) {
       _forNodeTree(child, callback);
     }
   }
 
   /** Set up property observers. */
   void observeProperties() {
-    // TODO(sjmiles):
-    // we observe published properties so we can reflect them to attributes
-    // ~100% of our team's applications would work without this reflection,
-    // perhaps we can make it optional somehow
-    //
-    // add user's observers
+    // TODO(jmesserly): we don't have CompoundPathObserver, so this
+    // implementation is a little bit different. We also don't expose the
+    // "generateCompoundPathObserver" method.
     final observe = _declaration._observe;
     final publish = _declaration._publish;
+
     if (observe != null) {
-      observe.forEach((name, value) {
-        if (publish != null && publish.containsKey(name)) {
-          observeBoth(name, value);
-        } else {
-          observeProperty(name, value);
-        }
-      });
+      for (var name in observe.keys) {
+        observeArrayValue(name, reflect(this).getField(name), null);
+      }
     }
-    // add observers for published properties
-    if (publish != null) {
-      publish.forEach((name, value) {
-        if (observe == null || !observe.containsKey(name)) {
-          observeAttributeProperty(name);
-        }
-      });
+    if (observe != null || publish != null) {
+      // Instead of using CompoundPathObserver, set up a binding using normal
+      // change records.
+      _propertyObserver = changes.listen(notifyPropertyChanges);
     }
   }
 
-  void _observe(String name, void callback(newValue, oldValue)) {
-    _observeLog.fine('[$localName] watching [$name]');
-    // TODO(jmesserly): this is a little different than the JS version so we
-    // can pass the oldValue, which is missing from Dart's PathObserver.
-    // This probably gives us worse performance.
-    var path = new PathObserver(this, name);
-    Object oldValue = null;
-    _registerObserver(name, path.changes.listen((_) {
-      final newValue = path.value;
-      final old = oldValue;
-      oldValue = newValue;
-      callback(newValue, old);
-    }));
-  }
+  /** Responds to property changes on this element. */
+  // Dart note: this takes a list of changes rather than trying to deal with
+  // what CompoundPathObserver would give us. Simpler and probably faster too.
+  void notifyPropertyChanges(Iterable<ChangeRecord> changes) {
+    final observe = _declaration._observe;
+    final publish = _declaration._publish;
 
-  void _registerObserver(String name, StreamSubscription sub) {
-    if (_elementObservers == null) {
-      _elementObservers = new Map<String, StreamSubscription>();
+    // Summarize old and new values, so we only handle each change once.
+    final valuePairs = new Map<Symbol, _PropertyValue>();
+    for (var c in changes) {
+      if (c is! PropertyChangeRecord) continue;
+
+      valuePairs.putIfAbsent(c.name, () => new _PropertyValue(c.oldValue))
+          .newValue = c.newValue;
     }
-    _elementObservers[name] = sub;
-  }
 
-  void observeAttributeProperty(String name) {
-    _observe(name, (value, old) => reflectPropertyToAttribute(name));
-  }
+    valuePairs.forEach((name, pair) {
+      if (publish != null && publish.containsKey(name)) {
+        reflectPropertyToAttribute(name);
+      }
+      if (observe == null) return;
 
-  void observeProperty(String name, Symbol method) {
-    _observe(name, (value, old) => _invoke(method, [old]));
-  }
-
-  void observeBoth(String name, Symbol methodName) {
-    _observe(name, (value, old) {
-      reflectPropertyToAttribute(name);
-      _invoke(methodName, [old]);
+      var method = observe[name];
+      if (method != null) {
+        // observes the value if it is an array
+        observeArrayValue(name, pair.newValue, pair.oldValue);
+        // TODO(jmesserly): the JS code tries to avoid calling the same method
+        // twice, but I don't see how that is possible.
+        // Dart note: JS also passes "arguments", so we pass all change records.
+        invokeMethod(method, [pair.oldValue, pair.newValue, changes]);
+      }
     });
   }
 
-  void unbindProperty(String name) {
-    if (_elementObservers == null) return;
-    var sub = _elementObservers.remove(name);
-    if (sub != null) sub.cancel();
+  void observeArrayValue(Symbol name, Object value, Object old) {
+    final observe = _declaration._observe;
+    if (observe == null) return;
+
+    // we only care if there are registered side-effects
+    var callbackName = observe[name];
+    if (callbackName == null) return;
+
+    // if we are observing the previous value, stop
+    if (old is ObservableList) {
+      if (_observeLog.isLoggable(Level.FINE)) {
+        _observeLog.fine('[$localName] observeArrayValue: unregister observer '
+            '$name');
+      }
+
+      unregisterObserver('${MirrorSystem.getName(name)}__array');
+    }
+    // if the new value is an array, being observing it
+    if (value is ObservableList) {
+      if (_observeLog.isLoggable(Level.FINE)) {
+        _observeLog.fine('[$localName] observeArrayValue: register observer '
+            '$name');
+      }
+      var sub = (value as ObservableList).changes.listen((changes) {
+        invokeMethod(callbackName, [old]);
+      });
+      registerObserver('${MirrorSystem.getName(name)}__array', sub);
+    }
   }
 
+  void unbindProperty(String name) => unregisterObserver(name);
+
   void unbindAllProperties() {
-    if (_elementObservers == null) return;
-    for (var sub in _elementObservers.values) sub.cancel();
-    _elementObservers.clear();
+    if (_propertyObserver != null) {
+      _propertyObserver.cancel();
+      _propertyObserver = null;
+    }
+    unregisterObservers();
+  }
+
+  /** Bookkeeping observers for memory management. */
+  void registerObserver(String name, StreamSubscription sub) {
+    if (_observers == null) {
+      _observers = new Map<String, StreamSubscription>();
+    }
+    _observers[name] = sub;
+  }
+
+  bool unregisterObserver(String name) {
+    var sub = _observers.remove(name);
+    if (sub == null) return false;
+    subl.cancel();
+    return true;
+  }
+
+  void unregisterObservers() {
+    if (_observers == null) return;
+    for (var sub in _observers.values) sub.cancel();
+    _observers.clear();
+    _observers = null;
   }
 
   /**
    * Bind a [property] in this object to a [path] in model. *Note* in Dart it
    * is necessary to also define the field:
    *
    *     var myProperty;
    *
    *     created() {
    *       super.created();
@@ skipping 95 matching lines @@
 
   String findEventDelegate(Event event) =>
       _declaration._eventDelegates[_eventNameFromType(event.type)];
 
   /** Call [methodName] method on [this] with [args], if the method exists. */
   // TODO(jmesserly): I removed the [node] argument as it was unused. Reconcile.
   void dispatchMethod(Symbol methodName, List args) {
     bool log = _eventsLog.isLoggable(Level.FINE);
     if (log) _eventsLog.fine('>>> [$localName]: dispatch $methodName');
 
-    _invoke(methodName, args);
+    invokeMethod(methodName, args);
 
     if (log) _eventsLog.info('<<< [$localName]: dispatch $methodName');
   }
 
-  InstanceMirror _invoke(Symbol methodName, List args) {
+  invokeMethod(Symbol methodName, List args) {
     // TODO(sigmund): consider making callbacks list all arguments
     // explicitly. Unless VM mirrors are optimized first, this will be expensive
     // once custom elements extend directly from Element (see issue 11108).
     var self = reflect(this);
     var method = self.type.methods[methodName];
     if (method != null) {
       // This will either truncate the argument list or extend it with extra
       // null arguments, so it will match the signature.
       // TODO(sigmund): consider accepting optional arguments when we can tell
       // them appart from named arguments (see http://dartbug.com/11334)
       args.length = method.parameters.where((p) => !p.isOptional).length;
     }
-    return self.invoke(methodName, args);
+    return self.invoke(methodName, args).reflectee;
   }
 
   void instanceEventListener(Event event) {
     _listenLocal(this, event);
   }
 
   // TODO(sjmiles): much of the below privatized only because of the vague
   // notion this code is too fiddly and we need to revisit the core feature
   void _listenLocal(Polymer host, Event event) {
     // TODO(jmesserly): do we need this check? It was using cancelBubble, see:
@@ skipping 170 matching lines @@
    * Remove [className] from [old], add class to [anew], if they exist.
    */
   void classFollows(Element anew, Element old, String className) {
     if (old != null) {
       old.classes.remove(className);
     }
     if (anew != null) {
       anew.classes.add(className);
     }
   }
+
+  /**
+   * Installs external stylesheets and <style> elements with the attribute
+   * polymer-scope='controller' into the scope of element. This is intended
+   * to be a called during custom element construction. Note, this incurs a
+   * per instance cost and should be used sparingly.
+   *
+   * The need for this type of styling should go away when the shadowDOM spec
+   * addresses these issues:
+   *
+   * https://www.w3.org/Bugs/Public/show_bug.cgi?id=21391
+   * https://www.w3.org/Bugs/Public/show_bug.cgi?id=21390
+   * https://www.w3.org/Bugs/Public/show_bug.cgi?id=21389
+   *
+   * @param element The custom element instance into whose controller (parent)
+   * scope styles will be installed.
+   * @param elementElement The <element> containing controller styles.
+   */
+  // TODO(sorvell): remove when spec issues are addressed
+  void installControllerStyles() {
+    var scope = findStyleController();
+    if (scope != null && scopeHasElementStyle(scope, _STYLE_CONTROLLER_SCOPE)) {
+      // allow inherited controller styles
+      var decl = _declaration;
+      var cssText = new StringBuffer();
+      while (decl != null) {
+        cssText.write(decl.cssTextForScope(_STYLE_CONTROLLER_SCOPE));
+        decl = decl.superDeclaration;
+      }
+      if (cssText.length > 0) {
+        var style = this.element.cssTextToScopeStyle(cssText.toString(),
+              _STYLE_CONTROLLER_SCOPE);
+        // TODO(sorvell): for now these styles are not shimmed
+        // but we may need to shim them
+        Polymer.applyStyleToScope(style, scope);
+      }
+    }
+  }
+
+  Node findStyleController() {
+    if (js.context != null && js.context['ShadowDOMPolyfill'] != null) {
+      return document.querySelector('head'); // get wrapped <head>.
+    } else {
+      // find the shadow root that contains this element
+      var n = this;
+      while (n.parentNode) {
+        n = n.parentNode;
+      }
+      return identical(n, document) ? document.head : n;
+    }
+  }
+
+  bool scopeHasElementStyle(scope, descriptor) {
+    var rule = '$_STYLE_SCOPE_ATTRIBUTE=$localName-$descriptor';
+    return scope.querySelector('style[$rule]') != null;
+  }
+
+  static void applyStyleToScope(StyleElement style, Node scope) {
+    if (style == null) return;
+
+    // TODO(sorvell): necessary for IE
+    // see https://connect.microsoft.com/IE/feedback/details/790212/
+    // cloning-a-style-element-and-adding-to-document-produces
+    // -unexpected-result#details
+    // var clone = style.cloneNode(true);
+    var clone = new StyleElement()..text = style.text;
+
+    var attr = style.attributes[_STYLE_SCOPE_ATTRIBUTE];
+    if (attr != null) {
+      clone.attributes[_STYLE_SCOPE_ATTRIBUTE] = attr;
+    }
+
+    scope.append(clone);
+  }
+
+  /**
+   * Prevents flash of unstyled content
+   * This is the list of selectors for veiled elements
+   */
+  static List<Element> veiledElements = ['body'];
+
+  /** Apply unveil class. */
+  static void unveilElements() {
+    window.requestAnimationFrame((_) {
+      var nodes = document.querySelectorAll('.$_VEILED_CLASS');
+      for (var node in nodes) {
+        (node.classes)..add(_UNVEIL_CLASS)..remove(_VEILED_CLASS);
+      }
+      // NOTE: depends on transition end event to remove 'unveil' class.
+      if (nodes.isNotEmpty) {
+        window.onTransitionEnd.first.then((_) {
+          for (var node in nodes) {
+            node.classes.remove(_UNVEIL_CLASS);
+          }
+        });
+      }
+    });
+  }
 }
 
 // Dart note: Polymer addresses n-way bindings by metaprogramming: redefine
 // the property on the PolymerElement instance to always get its value from the
 // model@path. We can't replicate this in Dart so we do the next best thing:
 // listen to changes on both sides and update the values.
 // TODO(jmesserly): our approach leads to race conditions in the bindings.
 // See http://code.google.com/p/dart/issues/detail?id=13567
 class _PolymerBinding extends NodeBinding {
   final InstanceMirror _target;
@@ skipping 77 matching lines @@
 /**
  * Base class for PolymerElements deriving from HtmlElement.
  *
  * See [Polymer].
  */
 class PolymerElement extends HtmlElement with Polymer, Observable {
   PolymerElement.created() : super.created() {
     polymerCreated();
   }
 }
+
+class _PropertyValue {
+  Object oldValue, newValue;
+  _PropertyValue(this.oldValue);
+}