Handle UINodes being moved around the Effen tree.

sky/sdk/lib/framework/fn2.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 'app.dart';
 import 'dart:async';
 import 'dart:collection';
 import 'dart:mirrors';
 import 'dart:sky' as sky;
 import 'package:vector_math/vector_math.dart';
 import 'reflect.dart' as reflect;
 import 'rendering/block.dart';
 import 'rendering/box.dart';
 import 'rendering/flex.dart';
 import 'rendering/object.dart';
 import 'rendering/paragraph.dart';
 import 'rendering/stack.dart';
 export 'rendering/object.dart' show Point, Size, Rect, Color, Paint, Path;
 export 'rendering/box.dart' show BoxDecoration, Border, BorderSide, EdgeDims;
 export 'rendering/flex.dart' show FlexDirection;
 
 // final sky.Tracing _tracing = sky.window.tracing;
 
 final bool _shouldLogRenderDuration = false;
-final bool _shouldTrace = false;
-
-enum _SyncOperation { identical, insertion, stateful, stateless, removal }
 
 /*
  * All Effen nodes derive from UINode. All nodes have a _parent, a _key and
  * can be sync'd.
  */
 abstract class UINode {
-  String _key;
-  UINode _parent;
-  UINode get parent => _parent;
-  RenderObject root;
-  bool _defunct = false;
 
   UINode({ Object key }) {
     _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()
   }
 
+  String _key;
+  String get key => _key;
+
+  UINode _parent;
+  UINode get parent => _parent;
+
+  bool _mounted = false;
+  bool _wasMounted = false;
+  bool get mounted => _mounted;
+  static bool _notifyingMountStatus = false;
+  static Set<UINode> _mountedChanged = new HashSet<UINode>();
+
+  void setParent(UINode newParent) {
+    assert(!_notifyingMountStatus);
+    _parent = newParent;
+    if (newParent == null) {
+      if (_mounted) {
+        _mounted = false;
+        _mountedChanged.add(this);
+      }
+    } else {
+      assert(newParent._mounted);
+      if (_parent._mounted != _mounted) {
+        _mounted = _parent._mounted;
+        _mountedChanged.add(this);
+      }
+    }
+  }
+
+  static void _notifyMountStatusChanged() {
+    try {
+      _notifyingMountStatus = true;
+      _mountedChanged.forEach((UINode node) {

[abarth-chromium, 2015/06/08 16:52:51]

for (UINode node in _mountedChanged) {
}

+        if (node._wasMounted != node._mounted) {
+          if (node._mounted)
+            node._didMount();
+          else
+            node._didUnmount();
+          node._wasMounted = node._mounted;
+        }
+      });
+      _mountedChanged.clear();
+    } finally {
+      _notifyingMountStatus = false;
+    }
+  }
+  void _didMount() { }
+  void _didUnmount() { }
+
+  RenderObject root;
+
   // 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, dynamic slot);
   // 'slot' is the identifier that the parent RenderObjectWrapper uses to know
   // where to put this descendant
 
   void remove() {
-    _defunct = true;
     root = null;
-    handleRemoved();
+    setParent(null);
   }
-  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;
-      }
-    }
-  }
-
-  void _trace(String message) {
-    if (!_shouldTrace)
-      return;
-
-    _ensureDepth();
-    print((' ' * _nodeDepth) + message);
-  }
-
-  void _traceSync(_SyncOperation op, String key) {
-    if (!_shouldTrace)
-      return;
-
-    String opString = op.toString().toLowerCase();
-    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, dynamic slot) {
+
     if (node == oldNode) {
-      _traceSync(_SyncOperation.identical, node == null ? '*null*' : node._key);
+      assert(node == null || node.mounted);
       return node; // Nothing to do. Subtrees must be identical.
     }
 
     if (node == null) {
       // the child in this slot has gone away
+      assert(oldNode.mounted);
       removeChild(oldNode);
+      assert(!oldNode.mounted);
       return null;
     }
-    assert(oldNode == null || node._key == oldNode._key);
 
-    // 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);
+    if (oldNode != null && node._key == oldNode._key && node._willSync(oldNode)) {
+      assert(oldNode.mounted);
+      assert(!node.mounted);
       oldNode._sync(node, slot);
-      node._defunct = true;
       assert(oldNode.root is RenderObject);
       return oldNode;
     }
 
-    assert(!node._defunct);
-    node._parent = this;
+    if (oldNode != null && node._key != oldNode._key) {
+      assert(oldNode.mounted);
+      removeChild(oldNode);
+      oldNode = null;
+    }
 
-    if (oldNode == null) {
-      _traceSync(_SyncOperation.insertion, node._key);
-    } else {
-      _traceSync(_SyncOperation.stateless, node._key);
-    }
+    assert(!node.mounted);
+    node.setParent(this);
     node._sync(oldNode, slot);
-    if (oldNode != null)
-      oldNode._defunct = true;
-
     assert(node.root is RenderObject);
     return node;
   }
 }
 
 abstract class ContentNode extends UINode {
   UINode content;
 
   ContentNode(UINode content) : this.content = content, super(key: content._key);
 
@@ skipping 121 matching lines @@
 
   RenderObjectWrapper({
     Object key
   }) : super(key: key);
 
   RenderObject createNode();
 
   void insert(RenderObjectWrapper child, dynamic slot);
 
   void _sync(UINode old, dynamic slot) {
+    assert(parent != null);
     if (old == null) {
       root = createNode();
       assert(root != null);
       var ancestor = findAncestor(RenderObjectWrapper);
       if (ancestor is RenderObjectWrapper)
         ancestor.insert(this, slot);
     } else {
       root = old.root;
-      assert(root != null);
     }
-
+    assert(mounted);
+    assert(root != null);
     _nodeMap[root] = this;
     syncRenderObject(old);
   }
 
   void syncRenderObject(RenderObjectWrapper old) {
     ParentData parentData = null;
-    UINode parent = _parent;
-    while (parent != null && parent is! RenderObjectWrapper) {
-      if (parent is ParentDataNode && parent.parentData != null) {
+    UINode ancestor = parent;
+    while (ancestor != null && ancestor is! RenderObjectWrapper) {
+      if (ancestor is ParentDataNode && ancestor.parentData != null) {
         if (parentData != null)
-          parentData.merge(parent.parentData); // this will throw if the types aren't the same
+          parentData.merge(ancestor.parentData); // this will throw if the types aren't the same
         else
-          parentData = parent.parentData;
+          parentData = ancestor.parentData;
       }
-      parent = parent._parent;
+      ancestor = ancestor.parent;
     }
     if (parentData != null) {
       assert(root.parentData != null);
-      root.parentData.merge(parentData); // this will throw if the types aren't approriate
-      assert(parent != null);
-      assert(parent.root != null);
-      parent.root.markNeedsLayout();
+      root.parentData.merge(parentData); // this will throw if the types aren't appropriate
+      if (parent.root != null)
+        parent.root.markNeedsLayout();
     }
   }
 
   void remove() {
     assert(root != null);
     _nodeMap.remove(root);
     super.remove();
   }
 }
 
@@ skipping 404 matching lines @@
     root.src = src;
     root.requestedSize = size;
   }
 
   void insert(RenderObjectWrapper child, dynamic slot) {
     assert(false);
     // Image does not support having children currently
   }
 }
 
-
-Set<Component> _mountedComponents = new HashSet<Component>();
-Set<Component> _unmountedComponents = new HashSet<Component>();
-
-void _enqueueDidMount(Component c) {
-  assert(!_notifingMountStatus);
-  _mountedComponents.add(c);
-}
-
-void _enqueueDidUnmount(Component c) {
-  assert(!_notifingMountStatus);
-  _unmountedComponents.add(c);
-}
-
-bool _notifingMountStatus = false;
-
-void _notifyMountStatusChanged() {
-  try {
-    _notifingMountStatus = true;
-    _unmountedComponents.forEach((c) => c._didUnmount());
-    _mountedComponents.forEach((c) => c._didMount());
-    _mountedComponents.clear();
-    _unmountedComponents.clear();
-  } finally {
-    _notifingMountStatus = false;
-  }
-}
-
 List<Component> _dirtyComponents = new List<Component>();
 bool _buildScheduled = false;
 bool _inRenderDirtyComponents = false;
 
 void _buildDirtyComponents() {
   //_tracing.begin('fn::_buildDirtyComponents');
 
   Stopwatch sw;
   if (_shouldLogRenderDuration)
     sw = new Stopwatch()..start();
 
   try {
     _inRenderDirtyComponents = true;
 
     _dirtyComponents.sort((a, b) => a._order - b._order);
     for (var comp in _dirtyComponents) {
       comp._buildIfDirty();
     }
 
     _dirtyComponents.clear();
     _buildScheduled = false;
   } finally {
     _inRenderDirtyComponents = false;
   }
 
-  _notifyMountStatusChanged();
+  UINode._notifyMountStatusChanged();
 
   if (_shouldLogRenderDuration) {
     sw.stop();
     print('Render took ${sw.elapsedMicroseconds} microseconds');
   }
 
   //_tracing.end('fn::_buildDirtyComponents');
 }
 
 void _scheduleComponentForRender(Component c) {
@@ skipping 26 matching lines @@
     _mountCallbacks.add(fn);
   }
 
   void onDidUnmount(Function fn) {
     if (_unmountCallbacks == null)
       _unmountCallbacks = new List<Function>();
 
     _unmountCallbacks.add(fn);
   }
 
-
   Component({ Object key, bool stateful })
       : _stateful = stateful != null ? stateful : false,
         _order = _currentOrder + 1,
         super(key: key);
 
   Component.fromArgs(Object key, bool stateful)
       : this(key: key, stateful: stateful);
 
   void _didMount() {
+    super._didMount();
     if (_mountCallbacks != null)
       _mountCallbacks.forEach((fn) => fn());
   }
 
   void _didUnmount() {
+    super._didUnmount();
     if (_unmountCallbacks != null)
       _unmountCallbacks.forEach((fn) => fn());
   }
 
   // TODO(rafaelw): It seems wrong to expose DOM at all. This is presently
   // needed to get sizing info.
   RenderObject getRoot() => root;
 
   void remove() {
     assert(_built != null);
     assert(root != null);
     removeChild(_built);
     _built = null;
-    _enqueueDidUnmount(this);
     super.remove();
   }
 
   bool _willSync(UINode old) {
     Component oldComponent = old as Component;
     if (oldComponent == null || !oldComponent._stateful)
       return false;
 
     // Make |this| the "old" Component
     _stateful = false;
     _built = oldComponent._built;
     assert(_built != null);
 
     // Make |oldComponent| the "new" component
     reflect.copyPublicFields(this, oldComponent);
     oldComponent._built = null;
     oldComponent._dirty = true;
     return true;
   }
 
   /* 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, 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();
+    assert(_built != null);
     _currentlyBuilding = null;
     _currentOrder = lastOrder;
 
     _built = syncChild(_built, oldBuilt, slot);
+    assert(_built != null);
     _dirty = false;
     root = _built.root;
     assert(root != null);
   }
 
   void _buildIfDirty() {
-    if (!_dirty || _defunct)
+    if (!_dirty || !_mounted)
       return;
 
-    _trace('$_key rebuilding...');
     assert(root != null);
     _sync(null, _slot);
   }
 
   void scheduleBuild() {
     setState(() {});
   }
 
   void setState(Function fn()) {
     _stateful = true;
     fn();
-    if (_isBuilding || _dirty || _defunct)
+    if (_isBuilding || _dirty || !_mounted)
       return;
 
     _dirty = true;
     _scheduleComponentForRender(this);
   }
 
   UINode build();
 }
 
 class Container extends Component {
@@ skipping 11 matching lines @@
     this.margin,
     this.decoration,
     this.desiredSize,
     this.padding
   }) : super(key: key);
 
   UINode build() {
     UINode current = child;
 
     if (padding != null)
-      current = new Padding(padding: padding, child: current);
+      current = new Padding(padding: padding, child: current, key: '$key-padding');
 
     if (decoration != null)
-      current = new DecoratedBox(decoration: decoration, child: current);
+      current = new DecoratedBox(decoration: decoration, child: current, key: '$key-decoration');
 
     if (desiredSize != null)
-      current = new SizedBox(desiredSize: desiredSize, child: current);
+      current = new SizedBox(desiredSize: desiredSize, child: current, key: '$key-size');
 
     if (margin != null)
-      current = new Padding(padding: margin, child: current);
+      current = new Padding(padding: margin, child: current, key: '$key-margin');
 
     if (transform != null)
-      current = new Transform(transform: transform, child: current);
+      current = new Transform(transform: transform, child: current, key: '$key-transform');
 
     return current;
   }
 }
 
 class _AppView extends AppView {
   _AppView() : super(null);
 
   void dispatchEvent(sky.Event event, HitTestResult result) {
     super.dispatchEvent(event, result);
 
     UINode target = RenderObjectWrapper._getMounted(result.path.first);
 
     // TODO(rafaelw): StopPropagation?
     while (target != null) {
       if (target is EventListenerNode)
         target._handleEvent(event);
       target = target._parent;
     }
   }
 }
 
 abstract class App extends Component {
 
   App() : super(stateful: true) {
     _appView = new _AppView();
     _scheduleComponentForRender(this);
+    _mounted = true;
   }
 
   AppView _appView;
   AppView get appView => _appView;
 
   void _buildIfDirty() {
     assert(_dirty);
-    assert(!_defunct);
-    _trace('$_key rebuilding app...');
+    assert(_mounted);
     _sync(null, null);
     if (root.parent == null)
       _appView.root = root;
     assert(root.parent is RenderView);
   }
 }
 
 class Text extends Component {
   Text(this.data) : super(key: '*text*');
   final String data;
   bool get interchangeable => true;
   UINode build() => new Paragraph(text: data);
 }