[Effen] Make syncChild() support the _new_ child being null.

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 'dart:async';
 import 'dart:collection';
 import 'dart:mirrors';
 import 'dart:sky' as sky;
@@ skipping 75 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, dynamic slot) {
-    assert(node != null);
-    assert(oldNode == null || node._key == oldNode._key);
+  UINode syncChild(UINode node, UINode oldNode, dynamic slot) {
 
     if (node == oldNode) {
-      _traceSync(_SyncOperation.IDENTICAL, node._key);
+      _traceSync(_SyncOperation.IDENTICAL, node == null ? '*null*' : node._key);
       return node; // Nothing to do. Subtrees must be identical.
     }
 
+    if (node == null) {
+      // the child in this slot has gone away
+      removeChild(oldNode);
+      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);
       oldNode._sync(node, slot);
@@ skipping 19 matching lines @@
   }
 }
 
 abstract class ContentNode extends UINode {
   UINode content;
 
   ContentNode(UINode content) : this.content = content, super(key: content._key);
 
   void _sync(UINode old, dynamic slot) {
     UINode oldContent = old == null ? null : (old as ContentNode).content;
-    content = _syncChild(content, oldContent, slot);
+    content = syncChild(content, oldContent, slot);
     assert(content.root != null);
     root = content.root;
   }
 
   void _remove() {
     if (content != null)
       removeChild(content);
     super._remove();
   }
 }
@@ skipping 279 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, 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 437 matching lines @@
     if (oldBuilt == null)
       _enqueueDidMount(this);
 
     int lastOrder = _currentOrder;
     _currentOrder = _order;
     _currentlyBuilding = this;
     _built = build();
     _currentlyBuilding = null;
     _currentOrder = lastOrder;
 
-    _built = _syncChild(_built, oldBuilt, slot);
+    _built = syncChild(_built, oldBuilt, slot);
     _dirty = false;
     root = _built.root;
     assert(root != null);
   }
 
   void _buildIfDirty() {
     if (!_dirty || _defunct)
       return;
 
     _trace('$_key rebuilding...');
@@ skipping 37 matching lines @@
     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)]);
 }