Trivial parts of https://codereview.chromium.org/1218183009/ so that that patch isn't confused by v…

sky/sdk/lib/widgets/widget.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.
 
 import 'dart:async';
 import 'dart:collection';
 import 'dart:mirrors';
 import 'dart:sky' as sky;
 
 import '../base/hit_test.dart';
@@ skipping 106 matching lines @@
     setParent(null);
   }
 
   void removeChild(Widget node) {
     node.remove();
   }
 
   void detachRoot();
 
   // Returns the child which should be retained as the child of this node.
-  Widget syncChild(Widget node, Widget oldNode, dynamic slot) {
+  Widget syncChild(Widget newNode, Widget oldNode, dynamic slot) {
 
-    assert(oldNode is! Component || (oldNode is Component && !oldNode._disqualifiedFromEverAppearingAgain)); // TODO(ianh): Simplify this once the analyzer is cleverer
+    assert(oldNode is! Component ||
+           (oldNode is Component && !oldNode._disqualifiedFromEverAppearingAgain)); // TODO(ianh): Simplify this once the analyzer is cleverer
 
-    if (node == oldNode) {
-      assert(node == null || node.mounted);
-      assert(node is! RenderObjectWrapper || (node is RenderObjectWrapper && node._ancestor != null)); // TODO(ianh): Simplify this once the analyzer is cleverer
-      return node; // Nothing to do. Subtrees must be identical.
+    if (newNode == oldNode) {
+      assert(newNode == null || newNode.mounted);
+      assert(newNode is! RenderObjectWrapper ||
+             (newNode is RenderObjectWrapper && newNode._ancestor != null)); // TODO(ianh): Simplify this once the analyzer is cleverer
+      return newNode; // Nothing to do. Subtrees must be identical.
     }
 
-    if (node == null) {
+    if (newNode == null) {
       // the child in this slot has gone away
       assert(oldNode.mounted);
       oldNode.detachRoot();
       removeChild(oldNode);
       assert(!oldNode.mounted);
       return null;
     }
 
     if (oldNode != null) {
-      if (oldNode.runtimeType == node.runtimeType && oldNode.key == node.key) {
-        if (node._retainStatefulNodeIfPossible(oldNode)) {
+      if (oldNode.runtimeType == newNode.runtimeType && oldNode.key == newNode.key) {
+        if (newNode._retainStatefulNodeIfPossible(oldNode)) {
           assert(oldNode.mounted);
-          assert(!node.mounted);
+          assert(!newNode.mounted);
           oldNode.setParent(this);
-          oldNode._sync(node, slot);
+          oldNode._sync(newNode, slot);
           assert(oldNode.root is RenderObject);
           return oldNode;
         }
       } else {
         assert(oldNode.mounted);
         oldNode.detachRoot();
         removeChild(oldNode);
         oldNode = null;
       }
     }
 
-    assert(!node.mounted);
-    node.setParent(this);
-    node._sync(oldNode, slot);
-    assert(node.root is RenderObject);
-    return node;
+    assert(!newNode.mounted);
+    newNode.setParent(this);
+    newNode._sync(oldNode, slot);
+    assert(newNode.root is RenderObject);
+    return newNode;
   }
 
   String toString() {
     if (key == null)
       return '$runtimeType(unkeyed)';
     return '$runtimeType("$key")';
   }
 
 }
 
@@ skipping 250 matching lines @@
   final int _order;
   static int _currentOrder = 0;
 
   // 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(Widget old, dynamic slot) {
+  void _sync(Component old, dynamic slot) {
     assert(_built == null || old == null);
     assert(!_disqualifiedFromEverAppearingAgain);
 
-    Component oldComponent = old as Component;
-
     _slot = slot;
 
     var oldBuilt;
-    if (oldComponent == null) {
+    if (old == null) {
       oldBuilt = _built;
     } else {
       assert(_built == null);
-      oldBuilt = oldComponent._built;
+      oldBuilt = old._built;
     }
 
     int lastOrder = _currentOrder;
     _currentOrder = _order;
     _currentlyBuilding = this;
     _built = build();
     assert(_built != null);
     _currentlyBuilding = null;
     _currentOrder = lastOrder;
 
@@ skipping 548 matching lines @@
     if (root.parent == null) {
       // we haven't attached it yet
       assert(_container.child == null);
       _container.child = root;
     }
     assert(root.parent == _container);
   }
 
   Widget build() => builder();
 }