[DO NOT CHECK IN] my debugging state for the assert when the drawer opens and closes prematurely

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';
@@ skipping 98 matching lines @@
     return ancestor;
   }
 
   void removeChild(UINode node) {
     node.remove();
   }
 
   // Returns the child which should be retained as the child of this node.
   UINode syncChild(UINode node, UINode oldNode, dynamic slot) {
 
+    assert(oldNode is! Component || !oldNode._disqualifiedFromEverAppearingAgain);
+
     if (node == oldNode) {
       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);
@@ skipping 195 matching lines @@
   }
 
   void remove() {
     assert(root != null);
     _nodeMap.remove(root);
     super.remove();
   }
 }
 
 abstract class OneChildRenderObjectWrapper extends RenderObjectWrapper {
-  final UINode child;
+  UINode _child;
+  UINode get child => _child;
 
-  OneChildRenderObjectWrapper({ this.child, Object key }) : super(key: key);
+  OneChildRenderObjectWrapper({ UINode child, Object key }) : _child = child, super(key: key);
 
   void syncRenderObject(RenderObjectWrapper old) {
     super.syncRenderObject(old);
     UINode oldChild = old == null ? null : (old as OneChildRenderObjectWrapper).child;
-    syncChild(child, oldChild, null);
+    _child = syncChild(child, oldChild, null);
   }
 
   void insert(RenderObjectWrapper child, dynamic slot) {
     final root = this.root; // TODO(ianh): Remove this once the analyzer is cleverer
     assert(slot == null);
     assert(root is RenderObjectWithChildMixin);
     root.child = child.root;
     assert(root == this.root); // TODO(ianh): Remove this once the analyzer is cleverer
   }
 
@@ skipping 172 matching lines @@
     final root = this.root; // TODO(ianh): Remove this once the analyzer is cleverer
     assert(slot == null || slot is RenderObject);
     assert(root is ContainerRenderObjectMixin);
     root.add(child.root, before: slot);
     assert(root == this.root); // TODO(ianh): Remove this once the analyzer is cleverer
   }
 
   void removeChild(UINode node) {
     final root = this.root; // TODO(ianh): Remove this once the analyzer is cleverer
     assert(root is ContainerRenderObjectMixin);
+    assert(node.root.parent == root);
     root.remove(node.root);
     super.removeChild(node);
     assert(root == this.root); // TODO(ianh): Remove this once the analyzer is cleverer
   }
 
   void remove() {
     assert(children != null);
     for (var child in children) {
       assert(child != null);
       removeChild(child);
@@ skipping 232 matching lines @@
     root.src = src;
     root.requestedSize = size;
   }
 
   void insert(RenderObjectWrapper child, dynamic slot) {
     assert(false);
     // Image does not support having children currently
   }
 }
 
-List<Component> _dirtyComponents = new List<Component>();
+Set<Component> _dirtyComponents = new Set<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) {
+    List<Component> sortedDirtyComponents = _dirtyComponents.toList();
+    sortedDirtyComponents.sort((Component a, Component b) => a._order - b._order);
+    for (var comp in sortedDirtyComponents) {
       comp._buildIfDirty();
     }
 
     _dirtyComponents.clear();
     _buildScheduled = false;
   } finally {
     _inRenderDirtyComponents = false;
   }
 
   UINode._notifyMountStatusChanged();
@@ skipping 13 matching lines @@
   if (!_buildScheduled) {
     _buildScheduled = true;
     new Future.microtask(_buildDirtyComponents);
   }
 }
 
 abstract class Component extends UINode {
   bool get _isBuilding => _currentlyBuilding == this;
   bool _dirty = true;
 
+  bool _disqualifiedFromEverAppearingAgain = false;
+
   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) {
@@ skipping 12 matching lines @@
 
   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() {
+    assert(!_disqualifiedFromEverAppearingAgain);
     super._didMount();
     if (_mountCallbacks != null)
       for (Function fn in _mountCallbacks)
         fn();
   }
 
   void _didUnmount() {
     super._didUnmount();
     if (_unmountCallbacks != null)
       for (Function fn in _unmountCallbacks)
         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;
     super.remove();
   }
 
   bool _willSync(UINode old) {
+    assert(!_disqualifiedFromEverAppearingAgain);
+
     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);
+    _disqualifiedFromEverAppearingAgain = true;
 
     // 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(_built == null || old == null);
+    assert(!_disqualifiedFromEverAppearingAgain);
 
     Component oldComponent = old as Component;
 
     _slot = slot;
 
     var oldBuilt;
     if (oldComponent == null) {
       oldBuilt = _built;
     } else {
       assert(_built == null);
       oldBuilt = oldComponent._built;
     }
 
     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() {
+    assert(!_disqualifiedFromEverAppearingAgain);
     if (!_dirty || !_mounted)
       return;
 
     assert(root != null);
     _sync(null, _slot);
   }
 
   void scheduleBuild() {
     setState(() {});
   }
 
   void setState(Function fn()) {
+    assert(!_disqualifiedFromEverAppearingAgain);
     _stateful = true;
     fn();
     if (_isBuilding || _dirty || !_mounted)
       return;
 
     _dirty = true;
     _scheduleComponentForRender(this);
   }
 
   UINode build();
@@ skipping 90 matching lines @@
     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);
 }