Roll polymer packages to version 0.3.4

pkg/observe/lib/src/path_observer.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.
 
 library observe.src.path_observer;
 
 import 'dart:async';
 import 'dart:collection';
 import 'dart:math' show min;
 
 import 'package:logging/logging.dart' show Logger, Level;
 import 'package:observe/observe.dart';
 import 'package:smoke/smoke.dart' as smoke;
 
+import 'package:utf/utf.dart' show stringToCodepoints;
+
 /// A data-bound path starting from a view-model or model object, for example
 /// `foo.bar.baz`.
 ///
 /// When [open] is called, this will observe changes to the object and any
 /// intermediate object along the path, and send updated values accordingly.
 /// When [close] is called it will stop observing the objects.
 ///
 /// This class is used to implement `Node.bind` and similar functionality in
 /// the [template_binding](pub.dartlang.org/packages/template_binding) package.
 class PathObserver extends _Observer implements Bindable {
   PropertyPath _path;
   Object _object;
   _ObservedSet _directObserver;
 
   /// Observes [path] on [object] for changes. This returns an object
   /// that can be used to get the changes and get/set the value at this path.
   ///
   /// The path can be a [PropertyPath], or a [String] used to construct it.
   ///
   /// See [open] and [value].
   PathObserver(Object object, [path])
       : _object = object,
-        _path = path is PropertyPath ? path : new PropertyPath(path);
+        _path = new PropertyPath(path);
 
-  bool get _isClosed => _path == null;
+  PropertyPath get path => _path;
 
   /// Sets the value at this path.
   void set value(Object newValue) {
     if (_path != null) _path.setValueFrom(_object, newValue);
   }
 
   int get _reportArgumentCount => 2;
 
   /// Initiates observation and returns the initial value.
   /// The callback will be passed the updated [value], and may optionally be
@@ skipping 10 matching lines @@
     if (_directObserver != null) {
       _directObserver.close(this);
       _directObserver = null;
     }
     // Dart note: the JS impl does not do this, but it seems consistent with
     // CompoundObserver. After closing the PathObserver can't be reopened.
     _path = null;
     _object = null;
   }
 
-  void _iterateObjects(void observe(obj)) {
+  void _iterateObjects(void observe(obj, prop)) {
     _path._iterateObjects(_object, observe);
   }
 
   bool _check({bool skipChanges: false}) {
     var oldValue = _value;
     _value = _path.getValueFrom(_object);
     if (skipChanges || _value == oldValue) return false;
 
-    _report(_value, oldValue);
+    _report(_value, oldValue, this);
     return true;
   }
 }
 
 /// A dot-delimieted property path such as "foo.bar" or "foo.10.bar".
 ///
 /// The path specifies how to get a particular value from an object graph, where
 /// the graph can include arrays and maps. Each segment of the path describes
 /// how to take a single step in the object graph. Properties like 'foo' or
 /// 'bar' are read as properties on objects, or as keys if the object is a [Map]
 /// or a [Indexable], while integer values are read as indexes in a [List].
 // TODO(jmesserly): consider specialized subclasses for:
 // * empty path
 // * "value"
 // * single token in path, e.g. "foo"
 class PropertyPath {
   /// The segments of the path.
   final List<Object> _segments;
 
   /// Creates a new [PropertyPath]. These can be stored to avoid excessive
   /// parsing of path strings.
   ///
   /// The provided [path] should be a String or a List. If it is a list it
   /// should contain only Symbols and integers. This can be used to avoid
   /// parsing.
   ///
   /// Note that this constructor will canonicalize identical paths in some cases
   /// to save memory, but this is not guaranteed. Use [==] for comparions
   /// purposes instead of [identical].
+  // Dart note: this is ported from `function getPath`.
   factory PropertyPath([path]) {
+    if (path is PropertyPath) return path;
+    if (path == null || (path is List && path.isEmpty)) path = '';
+
     if (path is List) {
       var copy = new List.from(path, growable: false);
       for (var segment in copy) {
-        if (segment is! int && segment is! Symbol) {
-          throw new ArgumentError('List must contain only ints and Symbols');
+        // Dart note: unlike Javascript, we don't support arbitraty objects that
+        // can be converted to a String.
+        // TODO(sigmund): consider whether we should support that here. It might
+        // be easier to add support for that if we switch first to use strings
+        // for everything instead of symbols.
+        if (segment is! int && segment is! String && segment is! Symbol) {
+          throw new ArgumentError(
+              'List must contain only ints, Strings, and Symbols');
         }
       }
       return new PropertyPath._(copy);
     }
 
-    if (path == null) path = '';
-
     var pathObj = _pathCache[path];
     if (pathObj != null) return pathObj;
 
-    if (!_isPathValid(path)) return _InvalidPropertyPath._instance;
 
-    final segments = [];
-    for (var segment in path.trim().split('.')) {
-      if (segment == '') continue;
-      var index = int.parse(segment, radix: 10, onError: (_) => null);
-      segments.add(index != null ? index : smoke.nameToSymbol(segment));
-    }
+    final segments = new _PathParser().parse(path);
+    if (segments == null) return _InvalidPropertyPath._instance;
 
     // TODO(jmesserly): we could use an UnmodifiableListView here, but that adds
     // memory overhead.
     pathObj = new PropertyPath._(segments.toList(growable: false));
     if (_pathCache.length >= _pathCacheLimit) {
       _pathCache.remove(_pathCache.keys.first);
     }
     _pathCache[path] = pathObj;
     return pathObj;
   }
 
   PropertyPath._(this._segments);
 
   int get length => _segments.length;
   bool get isEmpty => _segments.isEmpty;
   bool get isValid => true;
 
   String toString() {
     if (!isValid) return '<invalid path>';
-    return _segments
-        .map((s) => s is Symbol ? smoke.symbolToName(s) : s)
-        .join('.');
+    var sb = new StringBuffer();
+    bool first = true;
+    for (var key in _segments) {
+      if (key is Symbol) {
+        if (!first) sb.write('.');
+        sb.write(smoke.symbolToName(key));
+      } else {
+        _formatAccessor(sb, key);
+      }
+      first = false;
+    }
+    return sb.toString();
+  }
+
+  _formatAccessor(StringBuffer sb, Object key) {
+    if (key is int) {
+      sb.write('[$key]');
+    } else {
+      sb.write('["${key.toString().replaceAll('"', '\\"')}"]');
+    }
   }
 
   bool operator ==(other) {
     if (identical(this, other)) return true;
     if (other is! PropertyPath) return false;
     if (isValid != other.isValid) return false;
 
     int len = _segments.length;
     if (len != other._segments.length) return false;
     for (int i = 0; i < len; i++) {
@@ skipping 34 matching lines @@
   bool setValueFrom(Object obj, Object value) {
     var end = _segments.length - 1;
     if (end < 0) return false;
     for (int i = 0; i < end; i++) {
       if (obj == null) return false;
       obj = _getObjectProperty(obj, _segments[i]);
     }
     return _setObjectProperty(obj, _segments[end], value);
   }
 
-  void _iterateObjects(Object obj, void observe(obj)) {
+  void _iterateObjects(Object obj, void observe(obj, prop)) {
     if (!isValid || isEmpty) return;
 
     int i = 0, last = _segments.length - 1;
     while (obj != null) {
-      observe(obj);
+      observe(obj, _segments[0]);

[jakemac, 2014/07/25 16:40:33]

Is segments[0] what we want here? It might be worth throwing in a comment or
something since its not immediately clear to me what this function is intended
to be doing (or more specifically the new 2nd argument).

[Siggi Cherem (dart-lang), 2014/07/25 17:45:12]

yeah - basically the second argument is to optimize _ObserveSet - instead of
listening for every property on [obj], they want to make sure they listen on the
subset of properties that are used.

I added a comment here and in _ObserveSet as well.

 
       if (i >= last) break;
       obj = _getObjectProperty(obj, _segments[i++]);
     }
   }
+
+  // Dart note: it doesn't make sense to have compiledGetValueFromFn in Dart.
 }
 
+
+/// Visible only for testing:
+getSegmentsOfPropertyPathForTesting(p) => p._segments;
+
 class _InvalidPropertyPath extends PropertyPath {
   static final _instance = new _InvalidPropertyPath();
 
   bool get isValid => false;
   _InvalidPropertyPath() : super._([]);
 }
 
 bool _changeRecordMatches(record, key) {
   if (record is PropertyChangeRecord) {
     return (record as PropertyChangeRecord).name == key;
@@ skipping 11 matching lines @@
 /// them as part of path-observer segments.
 const _MAP_PROPERTIES = const [#keys, #values, #length, #isEmpty, #isNotEmpty];
 
 _getObjectProperty(object, property) {
   if (object == null) return null;
 
   if (property is int) {
     if (object is List && property >= 0 && property < object.length) {
       return object[property];
     }
+  } else if (property is String) {
+    return object[property];
   } else if (property is Symbol) {
     // Support indexer if available, e.g. Maps or polymer_expressions Scope.
     // This is the default syntax used by polymer/nodebind and
     // polymer/observe-js PathObserver.
     // TODO(sigmund): should we also support using checking dynamically for
     // whether the type practically implements the indexer API
     // (smoke.hasInstanceMethod(type, const Symbol('[]')))?
     if (object is Indexable<String, dynamic> ||
         object is Map<String, dynamic> && !_MAP_PROPERTIES.contains(property)) {
       return object[smoke.symbolToName(property)];
@@ skipping 39 matching lines @@
   }
 
   if (_logger.isLoggable(Level.FINER)) {
     _logger.finer("can't set $property in $object");
   }
   return false;
 }
 
 // From: https://github.com/rafaelw/ChangeSummary/blob/master/change_summary.js
 
-final _pathRegExp = () {
+final _identRegExp = () {
   const identStart = '[\$_a-zA-Z]';
   const identPart = '[\$_a-zA-Z0-9]';
-  const ident = '$identStart+$identPart*';
-  const elementIndex = '(?:[0-9]|[1-9]+[0-9]+)';
-  const identOrElementIndex = '(?:$ident|$elementIndex)';
-  const path = '(?:$identOrElementIndex)(?:\\.$identOrElementIndex)*';
-  return new RegExp('^$path\$');
+  return new RegExp('^$identStart+$identPart*\$');
 }();
 
-bool _isPathValid(String s) {
-  s = s.trim();
-  if (s == '') return true;
-  if (s[0] == '.') return false;
-  return _pathRegExp.hasMatch(s);
+_isIdent(s) => _identRegExp.hasMatch(s);
+
+// Dart note: refactored to convert to codepoints once and operate on codepoints
+// rather than characters.
+class _PathParser {
+  List keys = [];
+  int index = -1;
+  String key;
+
+  final Map<String, List<String>> _pathStateMachine = {
+    'beforePath': {
+      'ws': ['beforePath'],
+      'ident': ['inIdent', 'append'],
+      '[': ['beforeElement'],
+      'eof': ['afterPath']
+    },
+
+    'inPath': {
+      'ws': ['inPath'],
+      '.': ['beforeIdent'],
+      '[': ['beforeElement'],
+      'eof': ['afterPath']
+    },
+
+    'beforeIdent': {
+      'ws': ['beforeIdent'],
+      'ident': ['inIdent', 'append']
+    },
+
+    'inIdent': {
+      'ident': ['inIdent', 'append'],
+      '0': ['inIdent', 'append'],
+      'number': ['inIdent', 'append'],
+      'ws': ['inPath', 'push'],
+      '.': ['beforeIdent', 'push'],
+      '[': ['beforeElement', 'push'],
+      'eof': ['afterPath', 'push']
+    },
+
+    'beforeElement': {
+      'ws': ['beforeElement'],
+      '0': ['afterZero', 'append'],
+      'number': ['inIndex', 'append'],
+      "'": ['inSingleQuote', 'append', ''],
+      '"': ['inDoubleQuote', 'append', '']
+    },
+
+    'afterZero': {
+      'ws': ['afterElement', 'push'],
+      ']': ['inPath', 'push']
+    },
+
+    'inIndex': {
+      '0': ['inIndex', 'append'],
+      'number': ['inIndex', 'append'],
+      'ws': ['afterElement'],
+      ']': ['inPath', 'push']
+    },
+
+    'inSingleQuote': {
+      "'": ['afterElement'],
+      'eof': ['error'],
+      'else': ['inSingleQuote', 'append']
+    },
+
+    'inDoubleQuote': {
+      '"': ['afterElement'],
+      'eof': ['error'],
+      'else': ['inDoubleQuote', 'append']
+    },
+
+    'afterElement': {
+      'ws': ['afterElement'],
+      ']': ['inPath', 'push']
+    }
+  };
+
+  /// From getPathCharType: determines the type of a given [code]point.
+  String _getPathCharType(code) {
+    if (code == null) return 'eof';
+    switch(code) {
+      case 0x5B: // [
+      case 0x5D: // ]
+      case 0x2E: // .
+      case 0x22: // "
+      case 0x27: // '
+      case 0x30: // 0
+        return _char(code);
+
+      case 0x5F: // _
+      case 0x24: // $
+        return 'ident';
+
+      case 0x20: // Space
+      case 0x09: // Tab
+      case 0x0A: // Newline
+      case 0x0D: // Return
+      case 0xA0:  // No-break space
+      case 0xFEFF:  // Byte Order Mark
+      case 0x2028:  // Line Separator
+      case 0x2029:  // Paragraph Separator
+        return 'ws';
+    }
+
+    // a-z, A-Z
+    if ((0x61 <= code && code <= 0x7A) || (0x41 <= code && code <= 0x5A))
+      return 'ident';
+
+    // 1-9
+    if (0x31 <= code && code <= 0x39)
+      return 'number';
+
+    return 'else';
+  }
+
+  static String _char(int codepoint) => new String.fromCharCodes([codepoint]);
+
+  void push() {
+    if (key == null) return;
+
+    // Dart note: we store the keys with different types, rather than
+    // parsing/converting things later in toString.
+    if (_isIdent(key)) {
+      keys.add(smoke.nameToSymbol(key));
+    } else {
+      var index = int.parse(key, radix: 10, onError: (_) => null);
+      keys.add(index != null ? index : key);
+    }
+    key = null;
+  }
+
+  void append(newChar) {
+    key = (key == null) ? newChar : '$key$newChar';
+  }
+
+  bool _maybeUnescapeQuote(String mode, codePoints) {
+    if (index >= codePoints.length) return false;
+    var nextChar = _char(codePoints[index + 1]);
+    if ((mode == 'inSingleQuote' && nextChar == "'") ||
+        (mode == 'inDoubleQuote' && nextChar == '"')) {
+      index++;
+      append(nextChar);
+      return true;
+    }
+    return false;
+  }
+
+  /// Returns the parsed keys, or null if there was a parse error.
+  List<String> parse(String path) {
+    var codePoints = stringToCodepoints(path);
+    var mode = 'beforePath';
+
+    while (mode != null) {
+      index++;
+      var c = index >= codePoints.length ? null : codePoints[index];
+
+      if (c != null &&
+          _char(c) == '\\' && _maybeUnescapeQuote(mode, codePoints)) continue;
+
+      var type = _getPathCharType(c);
+      if (mode == 'error') return null;
+
+      var typeMap = _pathStateMachine[mode];
+      var transition = typeMap[type];
+      if (transition == null) transition = typeMap['else'];
+      if (transition == null) return null; // parse error;
+
+      mode = transition[0];
+      var actionName = transition.length > 1 ? transition[1] : null;
+      if (actionName == 'push' && key != null) push();
+      if (actionName == 'append') {
+        var newChar = transition.length > 2 && transition[2] != null
+            ? transition[2] : _char(c);
+        append(newChar);
+      }
+
+      if (mode == 'afterPath') return keys;
+    }
+    return null; // parse error
+  }
 }
 
 final Logger _logger = new Logger('observe.PathObserver');
 
 
 /// This is a simple cache. It's like LRU but we don't update an item on a
 /// cache hit, because that would require allocation. Better to let it expire
 /// and reallocate the PropertyPath.
 // TODO(jmesserly): this optimization is from observe-js, how valuable is it in
 // practice?
@@ skipping 20 matching lines @@
 ///      ..open((values) {
 ///        for (int i = 0; i < values.length; i++) {
 ///          print('The value at index $i is now ${values[i]}');
 ///        }
 ///      });
 ///
 ///   obj['a'] = 10; // print will be triggered async
 ///
 class CompoundObserver extends _Observer implements Bindable {
   _ObservedSet _directObserver;
+  bool _reportChangesOnOpen;
   List _observed = [];
 
-  bool get _isClosed => _observed == null;
-
-  CompoundObserver() {
+  CompoundObserver([this._reportChangesOnOpen = false]) {
     _value = [];
   }
 
   int get _reportArgumentCount => 3;
 
   /// Initiates observation and returns the initial value.
   /// The callback will be passed the updated [value], and may optionally be
   /// declared to take a second argument, which will contain the previous value.
   ///
   /// Implementation note: a third argument can also be declared, which will
   /// receive a list of objects and paths, such that `list[2 * i]` will access
   /// the object and `list[2 * i + 1]` will access the path, where `i` is the
   /// order of the [addPath] call. This parameter is only used by
   /// `package:polymer` as a performance optimization, and should not be relied
   /// on in new code.
   open(callback) => super.open(callback);
 
   void _connect() {
-    _check(skipChanges: true);
-
     for (var i = 0; i < _observed.length; i += 2) {
       var object = _observed[i];
       if (!identical(object, _observerSentinel)) {
         _directObserver = new _ObservedSet(this, object);
         break;
       }
     }
+
+    _check(skipChanges: !_reportChangesOnOpen);
   }
 
   void _disconnect() {
+    for (var i = 0; i < _observed.length; i += 2) {
+      if (identical(_observed[i], _observerSentinel)) {
+        _observed[i + 1].close();

[jakemac, 2014/07/25 16:40:33]

at first this looks like it could be out of bounds, even though _observed has an
even # of items its probably best to just ensure this, s/i < _observed.length/i
< _observed.length - 1

Or maybe this should be a list of classes that wrap up these two items that are
always together so its a bit less confusing? Or even just a generic pair/tuple
class?

[Siggi Cherem (dart-lang), 2014/07/25 17:45:12]

Yeah - I also dislike using this representation with pair of elements in the
array. I kept it as is just to continue to have the code as close to the
original. 

+      }
+    }
+
+    _observed = null;
     _value = null;
 
     if (_directObserver != null) {
       _directObserver.close(this);
       _directObserver = null;
     }
-
-    for (var i = 0; i < _observed.length; i += 2) {
-      if (identical(_observed[i], _observerSentinel)) {
-        _observed[i + 1].close();
-      }
-    }
-    _observed = null;
   }
 
   /// Adds a dependency on the property [path] accessed from [object].
   /// [path] can be a [PropertyPath] or a [String]. If it is omitted an empty
   /// path will be used.
   void addPath(Object object, [path]) {
     if (_isOpen || _isClosed) {
       throw new StateError('Cannot add paths once started.');
     }
 
-    if (path is! PropertyPath) path = new PropertyPath(path);
+    path = new PropertyPath(path);
     _observed..add(object)..add(path);
+    if (!_reportChangesOnOpen) return;
+    _value.add(path.getValueFrom(object));
   }
 
   void addObserver(Bindable observer) {
     if (_isOpen || _isClosed) {
       throw new StateError('Cannot add observers once started.');
     }
 
-    observer.open((_) => deliver());
     _observed..add(_observerSentinel)..add(observer);
+    if (!_reportChangesOnOpen) return;
+    _value.add(observer.open((_) => deliver()));
   }
 
-  void _iterateObjects(void observe(obj)) {
+  void _iterateObjects(void observe(obj, prop)) {
     for (var i = 0; i < _observed.length; i += 2) {
       var object = _observed[i];
       if (!identical(object, _observerSentinel)) {
         (_observed[i + 1] as PropertyPath)._iterateObjects(object, observe);
       }
     }
   }
 
   bool _check({bool skipChanges: false}) {
     bool changed = false;
     _value.length = _observed.length ~/ 2;
     var oldValues = null;
     for (var i = 0; i < _observed.length; i += 2) {
-      var pathOrObserver = _observed[i + 1];
       var object = _observed[i];
-      var value = identical(object, _observerSentinel) ?
-          (pathOrObserver as Bindable).value :
-          (pathOrObserver as PropertyPath).getValueFrom(object);
+      var path = _observed[i + 1];
+      var value;
+      if (identical(object, _observerSentinel)) {
+        var observable = path as Bindable;
+        value = _state == _Observer._UNOPENED ?
+            observable.open((_) => this.deliver()) :
+            observable.value;
+      } else {
+        value = (path as PropertyPath).getValueFrom(object);
+      }
 
       if (skipChanges) {
         _value[i ~/ 2] = value;
         continue;
       }
 
       if (value == _value[i ~/ 2]) continue;
 
       // don't allocate this unless necessary.
       if (_notifyArgumentCount >= 2) {
@@ skipping 17 matching lines @@
 /// An object accepted by [PropertyPath] where properties are read and written
 /// as indexing operations, just like a [Map].
 abstract class Indexable<K, V> {
   V operator [](K key);
   operator []=(K key, V value);
 }
 
 const _observerSentinel = const _ObserverSentinel();
 class _ObserverSentinel { const _ObserverSentinel(); }
 
+// Visible for testing
+get observerSentinelForTesting => _observerSentinel;
+
 // A base class for the shared API implemented by PathObserver and
 // CompoundObserver and used in _ObservedSet.
 abstract class _Observer extends Bindable {
-  static int _nextBirthId = 0;
-
-  /// A number indicating when the object was created.
-  final int _birthId = _nextBirthId++;
-
   Function _notifyCallback;
   int _notifyArgumentCount;
   var _value;
 
   // abstract members
-  void _iterateObjects(void observe(obj));
+  void _iterateObjects(void observe(obj, prop));
   void _connect();
   void _disconnect();
-  bool get _isClosed;
   bool _check({bool skipChanges: false});
 
-  bool get _isOpen => _notifyCallback != null;
+  static int _UNOPENED = 0;
+  static int _OPENED = 1;
+  static int _CLOSED = 2;
+  int _state = _UNOPENED;
+  bool get _isOpen => _state == _OPENED;
+  bool get _isClosed => _state == _CLOSED;
 
   /// The number of arguments the subclass will pass to [_report].
   int get _reportArgumentCount;
 
   open(callback) {
     if (_isOpen || _isClosed) {
       throw new StateError('Observer has already been opened.');
     }
 
     if (smoke.minArgs(callback) > _reportArgumentCount) {
       throw new ArgumentError('callback should take $_reportArgumentCount or '
           'fewer arguments');
     }
 
     _notifyCallback = callback;
     _notifyArgumentCount = min(_reportArgumentCount, smoke.maxArgs(callback));
 
     _connect();
+    _state = _OPENED;
     return _value;
   }
 
   get value => _discardChanges();
 
   void close() {
     if (!_isOpen) return;
 
     _disconnect();
     _value = null;
     _notifyCallback = null;
+    _state = _CLOSED;
   }
 
   _discardChanges() {
     _check(skipChanges: true);
     return _value;
   }
 
   void deliver() {
     if (_isOpen) _dirtyCheck();
   }
@@ skipping 15 matching lines @@
         case 3: _notifyCallback(newValue, oldValue, extraArg); break;
       }
     } catch (e, s) {
       // Deliver errors async, so if a single callback fails it doesn't prevent
       // other things from working.
       new Completer().completeError(e, s);
     }
   }
 }
 
+/// The observedSet abstraction is a perf optimization which reduces the total
+/// number of Object.observe observations of a set of objects. The idea is that
+/// groups of Observers will have some object dependencies in common and this
+/// observed set ensures that each object in the transitive closure of
+/// dependencies is only observed once. The observedSet acts as a write barrier
+/// such that whenever any change comes through, all Observers are checked for
+/// changed values.
+///
+/// Note that this optimization is explicitly moving work from setup-time to
+/// change-time.
+///
+/// TODO(rafaelw): Implement "garbage collection". In order to move work off
+/// the critical path, when Observers are closed, their observed objects are
+/// not Object.unobserve(d). As a result, it's possible that if the observedSet
+/// is kept open, but some Observers have been closed, it could cause "leaks"
+/// (prevent otherwise collectable objects from being collected). At some
+/// point, we should implement incremental "gc" which keeps a list of
+/// observedSets which may need clean-up and does small amounts of cleanup on a
+/// timeout until all is clean.
 class _ObservedSet {
   /// To prevent sequential [PathObserver]s and [CompoundObserver]s from
   /// observing the same object, we check if they are observing the same root
   /// as the most recently created observer, and if so merge it into the
   /// existing _ObservedSet.
   ///
   /// See <https://github.com/Polymer/observe-js/commit/f0990b1> and
   /// <https://codereview.appspot.com/46780044/>.
   static _ObservedSet _lastSet;
 
   /// The root object for a [PathObserver]. For a [CompoundObserver], the root
   /// object of the first path observed. This is used by the constructor to
   /// reuse an [_ObservedSet] that starts from the same object.
   Object _rootObject;
 
+  /// Subset of properties in [_rootObject] that we care about.
+  Set _rootObjectProperties;
+
   /// Observers associated with this root object, in birth order.
-  final Map<int, _Observer> _observers = new SplayTreeMap();
+  final List<_Observer> _observers = [];
 
   // Dart note: the JS implementation is O(N^2) because Array.indexOf is used
-  // for lookup in these two arrays. We use HashMap to avoid this problem. It
+  // for lookup in this array. We use HashMap to avoid this problem. It
   // also gives us a nice way of tracking the StreamSubscription.
   Map<Object, StreamSubscription> _objects;
-  Map<Object, StreamSubscription> _toRemove;
 
-  bool _resetNeeded = false;
-
-  factory _ObservedSet(_Observer observer, Object rootObj) {
-    if (_lastSet == null || !identical(_lastSet._rootObject, rootObj)) {
-      _lastSet = new _ObservedSet._(rootObj);
+  factory _ObservedSet(_Observer observer, Object rootObject) {
+    if (_lastSet == null || !identical(_lastSet._rootObject, rootObject)) {
+      _lastSet = new _ObservedSet._(rootObject);
     }
-    _lastSet.open(observer);
+    _lastSet.open(observer, rootObject);
   }
 
-  _ObservedSet._(this._rootObject);
+  _ObservedSet._(rootObject)
+      : _rootObject = rootObject,
+        _rootObjectProperties = rootObject == null ? null : new Set();
 
-  void open(_Observer obs) {
-    _observers[obs._birthId] = obs;
+  void open(_Observer obs, Object rootObject) {
+    if (_rootObject == null) {
+      _rootObject = rootObject;
+      _rootObjectProperties = new Set();
+    }
+
+    _observers.add(obs);
     obs._iterateObjects(observe);
   }
 
   void close(_Observer obs) {
-    var anyLeft = false;
-
-    _observers.remove(obs._birthId);
-
-    if (_observers.isNotEmpty) {
-      _resetNeeded = true;
-      scheduleMicrotask(reset);
-      return;
-    }
-    _resetNeeded = false;
+    if (_observers.isNotEmpty) return;
 
     if (_objects != null) {
       for (var sub in _objects) sub.cancel();
       _objects = null;
     }
+    _rootObject = null;
+    _rootObjectProperties = null;
   }
 
-  void observe(Object obj) {
+  void observe(Object obj, Object prop) {
+    if (identical(obj, _rootObject)) _rootObjectProperties.add(prop);
     if (obj is ObservableList) _observeStream(obj.listChanges);
     if (obj is Observable) _observeStream(obj.changes);
   }
 
   void _observeStream(Stream stream) {
     // TODO(jmesserly): we hash on streams as we have two separate change
     // streams for ObservableList. Not sure if that is the design we will use
     // going forward.
 
     if (_objects == null) _objects = new HashMap();
-    StreamSubscription sub = null;
-    if (_toRemove != null) sub = _toRemove.remove(stream);
-    if (sub != null) {
-      _objects[stream] = sub;
-    } else if (!_objects.containsKey(stream)) {
+    if (!_objects.containsKey(stream)) {
       _objects[stream] = stream.listen(_callback);
     }
   }
 
-  void reset() {
-    if (!_resetNeeded) return;
+  /// Whether we can ignore all change events in [records]. This is true if all
+  /// records are for properties in the [_rootObject] and we are not observing
+  /// any of those properties. Changes on objects other than [_rootObject], or
+  /// changes for properties in [_rootObjectProperties] can't be ignored.
+  bool _allRootObjectNonObservedProperties(List<ChangeRecord> records) {

[jakemac, 2014/07/25 16:40:34]

This function doesn't seem to be named very well, but if its copied over from
the JS side I guess its probably best to stay consistent. From the name I would
be expecting a list of the non-observed properties as a return value.

[Siggi Cherem (dart-lang), 2014/07/25 17:45:12]

Done. Yeah - this seems local enough that renaming it should be OK. I did the
rename and added a Dart note for it. That way we can still search for the old
name and find it.

If this starts getting used in other places (not just privately in this class),
then we should probably rename it back.

+    for (var rec in records) {
+      if (rec is PropertyChangeRecord) {
+        if (!identical(rec.object, _rootObject) ||
+            _rootObjectProperties.contains(rec.name)) {
+          return false;
+        }
+      } else if (rec is ListChangeRecord) {
+        if (!identical(rec.object, _rootObject) ||
+            _rootObjectProperties.contains(rec.index)) {
+          return false;
+        }
+      } else {
+        // TODO(sigmund): consider adding object to MapChangeRecord, and make
+        // this more precise.
+        return false;
+      }
+    }
+    return true;
+  }
 
-    var objs = _toRemove == null ? new HashMap() : _toRemove;
-    _toRemove = _objects;
-    _objects = objs;
-    for (var observer in _observers.values) {
+  void _callback(records) {
+    if (_allRootObjectNonObservedProperties(records)) return;
+    for (var observer in _observers.toList(growable: false)) {
       if (observer._isOpen) observer._iterateObjects(observe);
     }
 
-    for (var sub in _toRemove.values) sub.cancel();
-
-    _toRemove = null;
-  }
-
-  void _callback(records) {
-    for (var observer in _observers.values.toList(growable: false)) {
+    for (var observer in _observers.toList(growable: false)) {
       if (observer._isOpen) observer._check();
     }
-
-    _resetNeeded = true;
-    scheduleMicrotask(reset);
   }
 }
 
 const int _MAX_DIRTY_CHECK_CYCLES = 1000;