Added render tracing to Effen

sky/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:sky' as sky;
 import 'reflect.dart' as reflect;
 
 bool _initIsInCheckedMode() {
   String testFn(i) { double d = i; return d.toString(); }
   try {
     testFn('not a double');
   } catch (ex) {
     return true;
   }
   return false;
 }
 
 final bool _isInCheckedMode = _initIsInCheckedMode();
 final bool _shouldLogRenderDuration = false;
+final bool _shouldTrace = false;
 
 class Style {
   final String _className;
   static final Map<String, Style> _cache = new HashMap<String, Style>();
 
   static int _nextStyleId = 1;
 
   static String _getNextClassName() { return "style${_nextStyleId++}"; }
 
   Style extend(Style other) {
@@ skipping 29 matching lines @@
 
 /*
  * All Effen nodes derive from Node. All nodes have a _parent, a _key and
  * can be sync'd.
  */
 abstract class Node {
   String _key;
   Node _parent;
   sky.Node _root;
   bool _defunct = false;
+  int _nodeDepth;
 
   Node({ Object key }) {
     _key = key == null ? "$runtimeType" : "$runtimeType-$key";
   }
 
   // Subclasses which implements Nodes that become stateful may return true
   // if the |old| node has become stateful and should be retained.
   bool _willSync(Node old) => false;
 
   void _sync(Node old, sky.ParentNode host, sky.Node insertBefore);
 
   void _remove() {
     _defunct = true;
     _root = null;
   }
 
+  void _ensureDepth() {
+    if (_nodeDepth == null) {
+      _nodeDepth = 0;
+      Node parent = _parent;
+      while (parent != null) {
+        _nodeDepth++;
+        parent = parent._parent;
+      }
+    }
+  }
+
+  void _trace(String message) {
+    if (!_shouldTrace)
+      return;
+
+    _ensureDepth();
+    StringBuffer buffer = new StringBuffer();
+    int depth = _nodeDepth;
+    while (depth-- > 0) {
+      buffer.write(' ');
+    }
+    buffer.write(message);
+    print(buffer);
+  }
+
+  void _removeChild(Node node) {
+    _trace('_sync(remove) ${node._key}');
+    node._remove();
+  }
+
   // Returns the child which should be retained as the child of this node.
   Node _syncChild(Node node, Node oldNode, sky.ParentNode host,
       sky.Node insertBefore) {
-    if (node == oldNode)
+
+    if (node == oldNode) {
+      _trace('_sync(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) {
+      _trace('_sync(remove) ${node._key}');
       oldNode._remove();
     }
 
     if (node._willSync(oldNode)) {
+      _trace('_sync(statefull) ${node._key} -> ${oldNode._key}');
       oldNode._sync(node, host, insertBefore);
       node._defunct = true;
       assert(oldNode._root is sky.Node);
       return oldNode;
     }
 
     node._parent = this;
+
+    if (oldNode == null) {
+      _trace('_sync(insert) ${node._key}');
+    } else {
+      _trace('_sync(stateless) ${node._key} <- ${oldNode._key}');
+    }
     node._sync(oldNode, host, insertBefore);
     if (oldNode != null)
       oldNode._defunct = true;
 
     assert(node._root is sky.Node);
     return node;
   }
 }
 
 /*
@@ skipping 152 matching lines @@
     for (var type in listeners.keys) {
       _ensureDocumentListener(type);
     }
 
     Node oldContent = old == null ? null : (old as EventTarget).content;
     content = _syncChild(content, oldContent , host, insertBefore);
     _root = content._root;
   }
 
   void _remove() {
-    content._remove();
+    _removeChild(content);
     super._remove();
   }
 }
 
 class Text extends RenderNode {
   final String data;
 
   // Text nodes are special cases of having non-unique keys (which don't need
   // to be assigned as part of the API). Since they are unique in not having
   // children, there's little point to reordering, so we always just re-assign
@@ skipping 40 matching lines @@
 
     if (_isInCheckedMode) {
       _debugReportDuplicateIds();
     }
   }
 
   void _remove() {
     super._remove();
     if (_children != null) {
       for (var child in _children) {
-        child._remove();
+        _removeChild(child);
       }
     }
   }
 
   void _debugReportDuplicateIds() {
     var idSet = new HashSet<String>();
     for (var child in _children) {
       if (child is Text) {
         continue; // Text nodes all have the same key and are never reordered.
       }
@@ skipping 122 matching lines @@
     while (startIndex < endIndex) {
       currentNode = _children[startIndex];
       sync(startIndex);
       startIndex++;
     }
 
     // Removals
     currentNode = null;
     while (oldStartIndex < oldEndIndex) {
       oldNode = oldChildren[oldStartIndex];
-      oldNode._remove();
+      _removeChild(oldNode);
       advanceOldStartIndex();
     }
   }
 }
 
 class Container extends Element {
 
   String get _tagName => 'div';
 
   static final Container _emptyContainer = new Container();
@@ skipping 170 matching lines @@
   void didMount() {}
   void didUnmount() {}
 
   // TODO(rafaelw): It seems wrong to expose DOM at all. This is presently
   // needed to get sizing info.
   sky.Node getRoot() => _root;
 
   void _remove() {
     assert(_built != null);
     assert(_root != null);
-    _built._remove();
+    _removeChild(_built);
     _built = null;
     _unmountedComponents.add(this);
     super._remove();
   }
 
   bool _willSync(Node old) {
     Component oldComponent = old as Component;
     if (oldComponent == null || !oldComponent._stateful)
       return false;
 
@@ skipping 44 matching lines @@
     _built = _syncChild(_built, oldBuilt, host, insertBefore);
     _dirty = false;
     _root = _built._root;
   }
 
   void _buildIfDirty() {
     if (!_dirty || _defunct)
       return;
 
     assert(_host != null);
+    _trace('$_key rebuilding...');
     _sync(null, _host, _insertionPoint);
   }
 
   void scheduleBuild() {
     setState(() {});
   }
 
   void setState(Function fn()) {
     _stateful = true;
     fn();
     if (_isBuilding || _dirty || _defunct)
       return;
 
     _dirty = true;
     _scheduleComponentForRender(this);
   }
 
   Node build();
 }
 
 abstract class App extends Component {
   sky.Node _host;
 
   App() : super(stateful: true) {
     _host = sky.document.createElement('div');
     sky.document.appendChild(_host);
     _scheduleComponentForRender(this);
   }
 }