Adding an inheriting data model to Node

tools/dom/src/ModelTreeObserver.dart

Index: tools/dom/src/ModelTreeObserver.dart
diff --git a/tools/dom/src/ModelTreeObserver.dart b/tools/dom/src/ModelTreeObserver.dart
new file mode 100644
index 0000000000000000000000000000000000000000..7565b942809d5a93fc6d24112919dbf11be4f0cc
--- /dev/null
+++ b/tools/dom/src/ModelTreeObserver.dart
@@ -0,0 +1,86 @@
+// 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 html;
+
+class _ModelTreeObserver {
+  static bool _initialized = false;
+
+  /**
+   * Start an observer watching the document for tree changes to automatically
+   * propagate model changes.
+   */
+  static void initialize() {
+    if (!_initialized) {
+      _initialized = true;
+

[Jacob, 2013/03/15 18:50:19]

What about when there are true shadow DOMs on the page?
Don't you need to add observers to the root of each shadow DOM as well?
Probably just add a TODO that you don't support ShadowDOM and file a bug.

[blois, 2013/03/15 20:14:10]

Done.

+      if (MutationObserver.supported) {
+        var observer = new MutationObserver(_processTreeChange);
+        observer.observe(document, childList: true, subtree: true);
+      } else {
+        document.on['DOMNodeInserted'].listen(_handleNodeInserted);
+        document.on['DOMNodeRemoved'].listen(_handleNodeRemoved);
+      }
+    }
+  }
+
+  static void _processTreeChange(List<MutationRecord> mutations,
+      MutationObserver observer) {
+    for (var record in mutations) {
+      for (var node in record.addedNodes) {
+        // When nodes enter the document we need to make sure that all of the
+        // models are properly propagated through the entire sub-tree.
+        propagateModel(node, _calculatedModel(node), true);
+      }
+      for (var node in record.removedNodes) {
+        propagateModel(node, _calculatedModel(node), false);
+      }
+    }
+  }
+
+  static void _handleNodeInserted(MutationEvent e) {
+    var node = e.target;

[Jacob, 2013/03/15 18:50:19]

mutation observers are async while DOMNodeInserted is sync.
You should force the DOMNodeInserted and DOMNodeRemoved to batch and execute on
the next microtask so that behavior is consistent across old and new browsers.

[blois, 2013/03/15 20:14:10]

Done.

+    propagateModel(node, _calculatedModel(node), true);
+  }
+
+  static void _handleNodeRemoved(MutationEvent e) {
+    var node = e.target;
+    propagateModel(node, _calculatedModel(node), false);
+  }
+
+  /**
+   * Figures out what the model should be for a node, avoiding any cached
+   * model values.
+   */
+  static _calculatedModel(node) {
+    if (node._hasLocalModel == true) {
+      return node._model;
+    } else if (node.parentNode != null) {
+      return node.parentNode._model;
+    }
+    return null;
+  }
+
+  /**
+   * Pushes model changes down through the tree.
+   *
+   * Set fullTree to true if the state of the tree is unknown and model changes
+   * should be propagated through the entire tree.
+   */
+  static void propagateModel(Node node, model, bool fullTree) {
+    if (node._hasLocalModel != true && node._model != model &&

[Jennifer Messerly, 2013/03/15 03:20:46]

I wonder if it's worth noting that we're potentially calling into user code
(operator ==) here.

I think it's the right choice but might be worth a comment.

In observers, an exception from one observer could mess up the propagation of
other observers, so I take pains to wrap it in a try-catch and deliver the
exception to a handler:

https://github.com/dart-lang/web-ui/blob/master/lib/observe/observable.dart#L629

I don't know if that's necessarily a good pattern either, though. It feels
heavyweight to put in a guard, but since dart:html is a platform library it
might be worth it.

[blois, 2013/03/15 18:26:05]

The error handling here is the question-  I believe there's supposed to be a
global unhandled exception handler- ideally this would pass the error onto that
and continue. Following up with Florian & Mads to see where that work is, adding
a TODO in the meantime.

We have a similar issue right now with setImmediate (and probably elsewhere).

+        node._modelChangedStream != null) {
+      node._model = model;
+      node._modelChangedStream.add(model);
+    }
+    for (var child = node.$dom_firstChild; child != null;

[Jacob, 2013/03/15 18:50:19]

high level: I think it would be a lot more efficient to lazily compute the
models than to aggressively propagate models.  For example, when compiled to JS,
this code currently adds expandos to every Element and Text node on a page even
though most of them don't care at all.  I'd suggest instead making the getter
for model a bit more expensive.  For example, if the model hasn't been computed,
it should walk up the tree to find the first valid model.

[blois, 2013/03/15 20:14:10]

Models are only cached locally when a change listener is on the node, otherwise
the model is found by traversing the tree.

+        child = child.nextNode) {
+      if (child._hasLocalModel != true) {
+        propagateModel(child, model, fullTree);
+      } else if (fullTree) {
+        propagateModel(child, child._model, true);
+      }
+    }
+  }
+}