Make sure to sync the widgets even when we don't do a relayout.

sky/sdk/lib/widgets/block_viewport.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 '../rendering/block.dart';
 import '../rendering/box.dart';
 import '../rendering/object.dart';
 import 'widget.dart';
 
 // return null if index is greater than index of last entry
@@ skipping 63 matching lines @@
   void didUnmount() {
     root.callback = null;
     super.didUnmount();
   }
 
   // _offsets contains the offsets of each child from the top of the
   // list up to the last one we've ever created, and the offset of the
   // end of the last one. If there's no children, then the only offset
   // is 0.0.
   List<double> _offsets = <double>[0.0];
+  int _currentStartIndex = 0;
+  int _currentChildCount = 0;
 
   int _findIndexForOffsetBeforeOrAt(double offset) {
     int left = 0;
     int right = _offsets.length - 1;
     while (right >= left) {
       int middle = left + ((right - left) ~/ 2);
       if (_offsets[middle] < offset) {
         left = middle + 1;
       } else if (_offsets[middle] > offset) {
         right = middle - 1;
@@ skipping 16 matching lines @@
       _dirty = true;
       builder = newNode.builder;
       token = newNode.token;
       _offsets = <double>[0.0];
     }
     return true;
   }
 
   void syncRenderObject(BlockViewport old) {
     super.syncRenderObject(old);
-    if (_dirty)
+    if (_dirty) {
       root.markNeedsLayout();
+    } else {
+      if (_currentChildCount > 0) {
+        assert(_currentStartIndex >= 0);
+        assert(builder != null);
+        assert(root != null);
+        int lastIndex = _currentStartIndex + _currentChildCount;
+        for (int index = _currentStartIndex; index <= lastIndex; index += 1) {
+          Widget widget = builder(index);
+          assert(widget != null);
+          assert(widget.key != null);
+          _Key key = new _Key.fromWidget(widget);
+          Widget oldWidget = _childrenByKey[key];
+          assert(oldWidget != null);
+          assert(oldWidget.root.parent == root);
+          widget = syncChild(widget, oldWidget, root.childAfter(oldWidget.root));
+          assert(widget != null);
+          _childrenByKey[key] = widget;
+        }
+      }
+    }
   }
 
   Widget _getWidget(int index, BoxConstraints innerConstraints) {
     LayoutCallbackBuilderHandle handle = enterLayoutCallbackBuilder();
     try {
       assert(index >= 0);
       Widget widget = builder == null ? null : builder(index);
       if (widget == null)
         return null;
       assert(widget.key != null); // items in lists must have keys
@@ skipping 10 matching lines @@
         final double widgetEndOffset = widgetStartOffset + widgetRoot.getMaxIntrinsicHeight(innerConstraints);
         _offsets.add(widgetEndOffset);
       }
       return widget;
     } finally {
       exitLayoutCallbackBuilder(handle);
     }
   }
 
   void layout(BoxConstraints constraints) {
+    if (!_dirty)
+      return;
     _dirty = false;
 
     Map<_Key, Widget> newChildren = new Map<_Key, Widget>();
     Map<int, Widget> builtChildren = new Map<int, Widget>();
 
     final double height = root.size.height;
     final double endOffset = startOffset + height;
     BoxConstraints innerConstraints = new BoxConstraints.tightFor(width: constraints.constrainWidth());
 
     int startIndex;
@@ skipping 92 matching lines @@
         } else {
           assert(widget.root.parent == null);
           root.add(widget.root, before: nextSibling);
         }
         widget.updateSlot(nextSibling);
         nextSibling = widget.root;
       }      
     }
 
     _childrenByKey = newChildren;
+    _currentStartIndex = startIndex;
+    _currentChildCount = _childrenByKey.length;
   }
 
 }