Roll polymer to 0.3.5

pkg/template_binding/lib/src/template_iterator.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;
 
 // This code is a port of what was formerly known as Model-Driven-Views, now
 // located at:
 //     https://github.com/polymer/TemplateBinding
 //     https://github.com/polymer/NodeBind
@@ skipping 239 matching lines @@
   }
 
   void _updateDependencies(_TemplateBindingMap directives, model) {
     _closeDependencies();
 
     final template = _templateElement;
 
     _hasIf = directives._if != null;
     _hasRepeat = directives._repeat != null;
 
+    var ifValue = true;
     if (_hasIf) {
       _ifOneTime = directives._if.onlyOneTime;
       _ifValue = _processBinding('if', directives._if, template, model);
+      ifValue = _ifValue;
 
       // oneTime if & predicate is false. nothing else to do.
-      if (_ifOneTime) {
-        if (!_toBoolean(_ifValue)) {
-          _updateIteratedValue(null);
-          return;
-        }
-      } else {
-        (_ifValue as Bindable).open(_updateIteratedValue);
+      if (_ifOneTime && !_toBoolean(ifValue)) {
+        _valueChanged(null);
+        return;
+      }
+
+      if (!_ifOneTime) {
+        ifValue = (ifValue as Bindable).open(_updateIfValue);
       }
     }
 
     if (_hasRepeat) {
       _oneTime = directives._repeat.onlyOneTime;
       _value = _processBinding('repeat', directives._repeat, template, model);
     } else {
       _oneTime = directives._bind.onlyOneTime;
       _value = _processBinding('bind', directives._bind, template, model);
     }
 
-    if (!_oneTime) _value.open(_updateIteratedValue);
+    var value = _value;
+    if (!_oneTime) {
+      value = _value.open(_updateIteratedValue);
+    }
 
-    _updateIteratedValue(null);
+    if (!_toBoolean(ifValue)) {
+      _valueChanged(null);
+      return;
+    }
+
+    _updateValue(value);
   }
 
-  void _updateIteratedValue(_) {
+  /// Gets the updated value of the bind/repeat. This can potentially call
+  /// user code (if a bindingDelegate is set up) so we try to avoid it if we
+  /// already have the value in hand (from Observer.open).
+  Object _getUpdatedValue() {
+    var value = _value;
+    // Dart note: x.discardChanges() is x.value in Dart.
+    if (!_toBoolean(_oneTime)) value = value.value;
+    return value;
+  }
+
+  void _updateIfValue(ifValue) {
+    if (!_toBoolean(ifValue)) {
+      _valueChanged(null);
+      return;
+    }
+    _updateValue(_getUpdatedValue());
+  }
+
+  void _updateIteratedValue(value) {
     if (_hasIf) {
       var ifValue = _ifValue;
       if (!_ifOneTime) ifValue = (ifValue as Bindable).value;
       if (!_toBoolean(ifValue)) {
         _valueChanged([]);
         return;
       }
     }
 
-    var value = _value;
-    if (!_oneTime) value = (value as Bindable).value;
+    _updateValue(value);
+  }
+
+  void _updateValue(Object value) {
     if (!_hasRepeat) value = [value];
     _valueChanged(value);
   }
 
   void _valueChanged(Object value) {
     if (value is! List) {
       if (value is Iterable) {
         // Dart note: we support Iterable by calling toList.
         // But we need to be careful to observe the original iterator if it
         // supports that.
@@ skipping 207 matching lines @@
     _closed = true;
   }
 }
 
 // Dart note: the JavaScript version just puts an expando on the array.
 class _BoundNodes {
   final List<Node> nodes;
   final List<Bindable> instanceBindings;
   _BoundNodes(this.nodes, this.instanceBindings);
 }