[Effen] Move responsibility for inserting nodes to the OneChildListRenderNodeWrapper.

sky/sdk/lib/framework/fn.dart

 // Copyright 2015 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 library fn;
 
 import 'dart:async';
 import 'dart:collection';
+import 'dart:mirrors';
 import 'dart:sky' as sky;
 import 'reflect.dart' as reflect;
 import 'layout.dart';
 
 export 'layout.dart' show Style;
 
 final sky.Tracing _tracing = sky.window.tracing;
 
 final bool _shouldLogRenderDuration = false;
 final bool _shouldTrace = false;
@@ skipping 15 matching lines @@
     _key = key == null ? "$runtimeType" : "$runtimeType-$key";
     assert(this is App || _inRenderDirtyComponents); // you should not build the UI tree ahead of time, build it only during build()
   }
 
   // Subclasses which implements Nodes that become stateful may return true
   // if the |old| node has become stateful and should be retained.
   bool _willSync(UINode old) => false;
 
   bool get interchangeable => false; // if true, then keys can be duplicated
 
-  void _sync(UINode old, RenderCSSContainer host, RenderCSS insertBefore);
+  void _sync(UINode old, dynamic slot);
+  // 'slot' is the identifier that the parent RenderNodeWrapper uses to know
+  // where to put this descendant
 
   void _remove() {
     _defunct = true;
     _root = null;
     handleRemoved();
   }
   void handleRemoved() { }
 
+  UINode findAncestor(Type targetType) {
+    var ancestor = _parent;
+    while (ancestor != null && !reflectClass(ancestor.runtimeType).isSubtypeOf(reflectClass(targetType)))
+      ancestor = ancestor._parent;
+    return ancestor;
+  }
+
   int _nodeDepth;
   void _ensureDepth() {
     if (_nodeDepth == null) {
       if (_parent != null) {
         _parent._ensureDepth();
         _nodeDepth = _parent._nodeDepth + 1;
       } else {
         _nodeDepth = 0;
       }
     }
@@ skipping 15 matching lines @@
     String outString = opString.substring(opString.indexOf('.') + 1);
     _trace('_sync($outString) $key');
   }
 
   void _removeChild(UINode node) {
     _traceSync(_SyncOperation.REMOVAL, node._key);
     node._remove();
   }
 
   // Returns the child which should be retained as the child of this node.
-  UINode _syncChild(UINode node, UINode oldNode, RenderCSSContainer host,
-      RenderCSS insertBefore) {
-
+  UINode _syncChild(UINode node, UINode oldNode, dynamic slot) {
+    assert(node != null);
     assert(oldNode == null || node._key == oldNode._key);
 
     if (node == oldNode) {
       _traceSync(_SyncOperation.IDENTICAL, node._key);
       return node; // Nothing to do. Subtrees must be identical.
     }
 
     // TODO(rafaelw): This eagerly removes the old DOM. It may be that a
     // new component was built that could re-use some of it. Consider
     // syncing the new VDOM against the old one.
     if (oldNode != null && node._key != oldNode._key) {
       _removeChild(oldNode);
     }
 
     if (node._willSync(oldNode)) {
       _traceSync(_SyncOperation.STATEFUL, node._key);
-      oldNode._sync(node, host, insertBefore);
+      oldNode._sync(node, slot);
       node._defunct = true;
       assert(oldNode._root is RenderCSS);
       return oldNode;
     }
 
     assert(!node._defunct);
     node._parent = this;
 
     if (oldNode == null) {
       _traceSync(_SyncOperation.INSERTION, node._key);
     } else {
       _traceSync(_SyncOperation.STATELESS, node._key);
     }
-    node._sync(oldNode, host, insertBefore);
+    node._sync(oldNode, slot);
     if (oldNode != null)
       oldNode._defunct = true;
 
     assert(node._root is RenderCSS);
     return node;
   }
 }
 
 abstract class ContentNode extends UINode {
   UINode content;
 
   ContentNode(UINode content) : this.content = content, super(key: content._key);
 
-  void _sync(UINode old, RenderCSSContainer host, RenderCSS insertBefore) {
+  void _sync(UINode old, dynamic slot) {
     UINode oldContent = old == null ? null : (old as ContentNode).content;
-    content = _syncChild(content, oldContent, host, insertBefore);
+    content = _syncChild(content, oldContent, slot);
     assert(content._root != null);
     _root = content._root;
   }
 
   void _remove() {
     if (content != null)
       _removeChild(content);
     super._remove();
   }
 }
@@ skipping 111 matching lines @@
       target = target._parent;
     }
   }
 
   static void _ensureDocumentListener(String eventType) {
     if (_registeredEvents.add(eventType)) {
       sky.document.addEventListener(eventType, _dispatchEvent);
     }
   }
 
-  void _sync(UINode old, RenderCSSContainer host, RenderCSS insertBefore) {
+  void _sync(UINode old, dynamic slot) {
     for (var type in listeners.keys) {
       _ensureDocumentListener(type);
     }
-
-    super._sync(old, host, insertBefore);
+    super._sync(old, slot);
   }
 }
 
 /*
  * RenderNodeWrappers correspond to a desired state of a RenderCSS.
  * They are fully immutable, with one exception: A UINode which is a
  * Component which lives within an OneChildListRenderNodeWrapper's
  * children list, may be replaced with the "old" instance if it has
  * become stateful.
  */
 abstract class RenderNodeWrapper extends UINode {
 
   static final Map<RenderCSS, RenderNodeWrapper> _nodeMap =
       new HashMap<RenderCSS, RenderNodeWrapper>();
 
   static RenderNodeWrapper _getMounted(RenderCSS node) => _nodeMap[node];
 
   RenderNodeWrapper({
     Object key,
     this.style,
     this.inlineStyle
   }) : super(key: key);
 
   final Style style;
   final String inlineStyle;
 
   RenderCSS _createNode();
   RenderNodeWrapper get _emptyNode;
 
-  void _sync(UINode old, RenderCSSContainer host, RenderCSS insertBefore) {
+  void insert(RenderNodeWrapper child, dynamic slot);
+
+  void _sync(UINode old, dynamic slot) {
     if (old == null) {
       _root = _createNode();
       assert(_root != null);
-      host.add(_root, before: insertBefore);
+      var ancestor = findAncestor(RenderNodeWrapper);
+      if (ancestor is RenderNodeWrapper)
+        ancestor.insert(this, slot);
       old = _emptyNode;
     } else {
       _root = old._root;
       assert(_root != null);
     }
 
     _nodeMap[_root] = this;
     _syncRenderNode(old);
   }
 
@@ skipping 38 matching lines @@
     assert(_root != null);
     _nodeMap.remove(_root);
     super._remove();
   }
 }
 
 final List<UINode> _emptyList = new List<UINode>();
 
 abstract class OneChildListRenderNodeWrapper extends RenderNodeWrapper {
 
+  // In OneChildListRenderNodeWrapper subclasses, slots are RenderCSS nodes
+  // to use as the "insert before" sibling in RenderCSSContainer.add() calls
+
   final List<UINode> children;
 
   OneChildListRenderNodeWrapper({
     Object key,
     List<UINode> children,
     Style style,
     String inlineStyle
   }) : this.children = children == null ? _emptyList : children,
   super(
     key: key,
     style: style,
     inlineStyle: inlineStyle
   ) {
     assert(!_debugHasDuplicateIds());
   }
 
+  void insert(RenderNodeWrapper child, dynamic slot) {
+    assert(slot == null || slot is RenderCSS);
+    _root.add(child._root, before: slot);
+  }
+
   void _remove() {
     assert(children != null);
     for (var child in children) {
       assert(child != null);
       _removeChild(child);
     }
     super._remove();
   }
 
   bool _debugHasDuplicateIds() {
@@ skipping 23 matching lines @@
 
     var oldChildren = old.children;
     var oldStartIndex = 0;
     var oldEndIndex = oldChildren.length;
 
     RenderCSS nextSibling = null;
     UINode currentNode = null;
     UINode oldNode = null;
 
     void sync(int atIndex) {
-      children[atIndex] = _syncChild(currentNode, oldNode, _root, nextSibling);
+      children[atIndex] = _syncChild(currentNode, oldNode, nextSibling);
       assert(children[atIndex] != null);
     }
 
     // Scan backwards from end of list while nodes can be directly synced
     // without reordering.
     while (endIndex > startIndex && oldEndIndex > oldStartIndex) {
       currentNode = children[endIndex - 1];
       oldNode = oldChildren[oldEndIndex - 1];
 
       if (currentNode._key != oldNode._key) {
@@ skipping 38 matching lines @@
         return false; // never re-order these nodes
 
       ensureOldIdMap();
       oldNode = oldNodeIdMap[currentNode._key];
       if (oldNode == null)
         return false;
 
       oldNodeIdMap[currentNode._key] = null; // mark it reordered
       assert(_root is RenderCSSContainer);
       assert(oldNode._root is RenderCSSContainer);
+
       old._root.remove(oldNode._root);
       _root.add(oldNode._root, before: nextSibling);
+
       return true;
     }
 
     // Scan forwards, this time we may re-order;
     nextSibling = _root.firstChild;
     while (startIndex < endIndex && oldStartIndex < oldEndIndex) {
       currentNode = children[startIndex];
       oldNode = oldChildren[oldStartIndex];
 
       if (currentNode._key == oldNode._key) {
@@ skipping 276 matching lines @@
   bool get _isBuilding => _currentlyBuilding == this;
   bool _dirty = true;
 
   UINode _built;
   final int _order;
   static int _currentOrder = 0;
   bool _stateful;
   static Component _currentlyBuilding;
   List<Function> _mountCallbacks;
   List<Function> _unmountCallbacks;
+  dynamic _slot; // cached slot from the last time we were synced
 
   void onDidMount(Function fn) {
     if (_mountCallbacks == null)
       _mountCallbacks = new List<Function>();
 
     _mountCallbacks.add(fn);
   }
 
   void onDidUnmount(Function fn) {
     if (_unmountCallbacks == null)
@@ skipping 52 matching lines @@
   }
 
   /* There are three cases here:
    * 1) Building for the first time:
    *      assert(_built == null && old == null)
    * 2) Re-building (because a dirty flag got set):
    *      assert(_built != null && old == null)
    * 3) Syncing against an old version
    *      assert(_built == null && old != null)
    */
-  void _sync(UINode old, RenderCSSContainer host, RenderCSS insertBefore) {
+  void _sync(UINode old, dynamic slot) {
     assert(!_defunct);
     assert(_built == null || old == null);
 
     Component oldComponent = old as Component;
 
+    _slot = slot;
+
     var oldBuilt;
     if (oldComponent == null) {
       oldBuilt = _built;
     } else {
       assert(_built == null);
       oldBuilt = oldComponent._built;
     }
 
     if (oldBuilt == null)
       _enqueueDidMount(this);
 
     int lastOrder = _currentOrder;
     _currentOrder = _order;
     _currentlyBuilding = this;
     _built = build();
     _currentlyBuilding = null;
     _currentOrder = lastOrder;
 
-    _built = _syncChild(_built, oldBuilt, host, insertBefore);
+    _built = _syncChild(_built, oldBuilt, slot);
     _dirty = false;
     _root = _built._root;
     assert(_root != null);
   }
 
   void _buildIfDirty() {
     if (!_dirty || _defunct)
       return;
 
     _trace('$_key rebuilding...');
-    _sync(null, _root.parent, _root.parent.childAfter(_root));
+    assert(_root != null);
+    _sync(null, _slot);
   }
 
   void scheduleBuild() {
     setState(() {});
   }
 
   void setState(Function fn()) {
     _stateful = true;
     fn();
     if (_isBuilding || _dirty || _defunct)
@@ skipping 12 matching lines @@
   App() : super(stateful: true) {
     _host = new RenderCSSRoot(this);
     _scheduleComponentForRender(this);
   }
 
   void _buildIfDirty() {
     if (!_dirty || _defunct)
       return;
 
     _trace('$_key rebuilding...');
-    _sync(null, _host, _root);
+    _sync(null, null);
+    if (_root.parent == null)
+      _host.add(_root);
+    assert(_root.parent == _host);
   }
 }
 
 class Text extends Component {
   Text(this.data) : super(key: '*text*');
   final String data;
   bool get interchangeable => true;
   UINode build() => new Paragraph(children: [new TextFragment(data)]);
 }