[Effen] minor cleanup

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;
@@ skipping 67 matching lines @@
 void _parentInsertBefore(sky.ParentNode parent,
                          sky.Node node,
                          sky.Node ref) {
   if (ref != null) {
     ref.insertBefore([node]);
   } else {
     parent.appendChild(node);
   }
 }
 
+enum _SyncOperation { IDENTICAL, INSERTION, STATEFUL, STATELESS, REMOVAL }
+
 /*
  * 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;
@@ skipping 31 matching lines @@
     _ensureDepth();
     StringBuffer buffer = new StringBuffer();
     int depth = _nodeDepth;
     while (depth-- > 0) {
       buffer.write(' ');
     }
     buffer.write(message);
     print(buffer);
   }
 
+  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(Node node) {
-    _trace('_sync(remove) ${node._key}');
+    _traceSync(_SyncOperation.REMOVAL, 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) {
 
     assert(oldNode == null || node._key == oldNode._key);
 
     if (node == oldNode) {
-      _trace('_sync(identical) ${node._key}');
+      _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)) {
-      _trace('_sync(statefull) ${node._key}');
+      _traceSync(_SyncOperation.STATEFUL, node._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}');
+      _traceSync(_SyncOperation.INSERTION, node._key);
     } else {
-      _trace('_sync(stateless) ${node._key}');
+      _traceSync(_SyncOperation.STATELESS, node._key);
     }
     node._sync(oldNode, host, insertBefore);
     if (oldNode != null)
       oldNode._defunct = true;
 
     assert(node._root is sky.Node);
     return node;
   }
 }
 
@@ skipping 477 matching lines @@
     super._syncNode(old);
 
     Anchor oldAnchor = old as Anchor;
     sky.HTMLAnchorElement skyAnchor = _root as sky.HTMLAnchorElement;
 
     if (href != oldAnchor.href)
       skyAnchor.href = href;
   }
 }
 
+
+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>();
-Set<Component> _mountedComponents = new HashSet<Component>();
-Set<Component> _unmountedComponents = new HashSet<Component>();
-
 bool _buildScheduled = false;
 bool _inRenderDirtyComponents = false;
 
-void _notifyMountStatusChanged() {
-  _unmountedComponents.forEach((c) => c._didUnmount());
-  _mountedComponents.forEach((c) => c._didMount());
-  _mountedComponents.clear();
-  _unmountedComponents.clear();
-}
 
 void _buildDirtyComponents() {
   Stopwatch sw;
   if (_shouldLogRenderDuration)
     sw = new Stopwatch()..start();
 
   try {
     _inRenderDirtyComponents = true;
 
     _dirtyComponents.sort((a, b) => a._order - b._order);
@@ skipping 75 matching lines @@
 
   // 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);
     _removeChild(_built);
     _built = null;
-    _unmountedComponents.add(this);
+    _enqueueDidUnmount(this);
     super._remove();
   }
 
   bool _willSync(Node old) {
     Component oldComponent = old as Component;
     if (oldComponent == null || !oldComponent._stateful)
       return false;
 
     // Make |this| the "old" Component
     _stateful = false;
@@ skipping 23 matching lines @@
 
     var oldBuilt;
     if (oldComponent == null) {
       oldBuilt = _built;
     } else {
       assert(_built == null);
       oldBuilt = oldComponent._built;
     }
 
     if (oldBuilt == null)
-      _mountedComponents.add(this);
+      _enqueueDidMount(this);
 
     int lastOrder = _currentOrder;
     _currentOrder = _order;
     _currentlyBuilding = this;
     _built = build();
     _currentlyBuilding = null;
     _currentOrder = lastOrder;
 
     _built = _syncChild(_built, oldBuilt, host, insertBefore);
     _dirty = false;
@@ skipping 28 matching lines @@
 
 abstract class App extends Component {
   sky.Node _host;
 
   App() : super(stateful: true) {
     _host = sky.document.createElement('div');
     sky.document.appendChild(_host);
     _scheduleComponentForRender(this);
   }
 }