Teach Widget some new tricks to enable build-during-layout.

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:sky' as sky;
 
 import 'package:sky/mojo/activity.dart' as activity;
 
+import '../base/debug.dart';
 import '../base/hit_test.dart';
 import '../rendering/box.dart';
 import '../rendering/object.dart';
 import '../rendering/sky_binding.dart';
 
 export '../rendering/box.dart' show BoxConstraints, BoxDecoration, Border, BorderSide, EdgeDims;
 export '../rendering/flex.dart' show FlexDirection;
 export '../rendering/object.dart' show Point, Offset, Size, Rect, Color, Paint, Path;
 
 final bool _shouldLogRenderDuration = false;
 
+typedef Widget Builder();
 typedef void WidgetTreeWalker(Widget);
 
 /// A base class for elements of the widget tree
 abstract class Widget {
 
   Widget({ String key }) : _key = key {
     assert(_isConstructedDuringBuild());
   }
 
   // TODO(jackson): Remove this workaround for limitation of Dart mixins
   Widget._withKey(String key) : _key = key {
     assert(_isConstructedDuringBuild());
   }
 
   // you should not build the UI tree ahead of time, build it only during build()
-  bool _isConstructedDuringBuild() => this is AbstractWidgetRoot || this is App || _inRenderDirtyComponents;
+  bool _isConstructedDuringBuild() => this is AbstractWidgetRoot || this is App || _inRenderDirtyComponents || _inLayoutCallbackBuilder > 0;
 
   String _key;
 
   /// A semantic identifer for this widget
   ///
   /// Keys are used to find matches when synchronizing two widget trees, for
   /// example after a [Component] rebuilds. Without keys, two widgets can match
   /// if their runtimeType matches. With keys, the keys must match as well.
   /// Assigning a key to a widget can improve performance by causing the
   /// framework to sync widgets that share a lot of common structure and can
@@ skipping 65 matching lines @@
 
   /// Override this function to learn when this [Widget] leaves the widget tree.
   void didUnmount() { }
 
   RenderObject _root;
 
   /// The underlying [RenderObject] associated with this [Widget].
   RenderObject get root => _root;
 
   // Subclasses which implements Nodes that become stateful may return true
-  // if the |old| node has become stateful and should be retained.
+  // if the node has become stateful and should be retained.
   // This is called immediately before _sync().
-  // Component._retainStatefulNodeIfPossible() calls syncFields().
-  bool _retainStatefulNodeIfPossible(Widget old) => false;
+  // Component.retainStatefulNodeIfPossible() calls syncFields().
+  bool retainStatefulNodeIfPossible(Widget newNode) => false;
 
   void _sync(Widget old, dynamic slot);
   void updateSlot(dynamic newSlot);
   // 'slot' is the identifier that the ancestor RenderObjectWrapper uses to know
   // where to put this descendant. If you just defer to a child, then make sure
   // to pass them the slot.
 
   Widget findAncestorRenderObjectWrapper() {
     var ancestor = _parent;
     while (ancestor != null && ancestor is! RenderObjectWrapper)
@@ skipping 35 matching lines @@
       // 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 == newNode.runtimeType && oldNode.key == newNode.key) {
-        if (newNode._retainStatefulNodeIfPossible(oldNode)) {
+        if (oldNode.retainStatefulNodeIfPossible(newNode)) {
           assert(oldNode.mounted);
           assert(!newNode.mounted);
           oldNode.setParent(this);
           oldNode._sync(newNode, slot);
           assert(oldNode.root is RenderObject);
           return oldNode;
         } else {
           oldNode.setParent(null);
         }
       } else {
@@ skipping 19 matching lines @@
     if (children.length > 0) {
       Widget lastChild = children.removeLast();
       String nextStartPrefix = prefix + ' +-';
       String nextPrefix = prefix + ' | ';
       for (Widget child in children)
         childrenString += child.toString(nextPrefix, nextStartPrefix);
       String lastStartPrefix = prefix + ' \'-';
       String lastPrefix = prefix + '   ';
       childrenString += lastChild.toString(lastPrefix, lastStartPrefix);
     }
+    return '$startPrefix${toStringName()}\n$childrenString';
+  }
+  String toStringName() {
     if (key == null)
-      return '$startPrefix$runtimeType(unkeyed)\n$childrenString';
-    return '$startPrefix$runtimeType("$key")\n$childrenString';
+      return '$runtimeType(unkeyed; hashCode=$hashCode)';
+    return '$runtimeType("$key"; hashCode=$hashCode)';
   }
 
 }
 
 
 // Descendants of TagNode provide a way to tag RenderObjectWrapper and
 // Component nodes with annotations, such as event listeners,
 // stylistic information, etc.
 abstract class TagNode extends Widget {
 
@@ skipping 295 matching lines @@
   void _sync(Widget old, dynamic slot) {
     assert(!_disqualifiedFromEverAppearingAgain);
     super._sync(old, slot);
   }
 
   Widget syncChild(Widget node, Widget oldNode, dynamic slot) {
     assert(!_disqualifiedFromEverAppearingAgain);
     return super.syncChild(node, oldNode, slot);
   }
 
-  bool _retainStatefulNodeIfPossible(StatefulComponent old) {
+  bool retainStatefulNodeIfPossible(StatefulComponent newNode) {
     assert(!_disqualifiedFromEverAppearingAgain);
+    assert(newNode != null);
+    assert(runtimeType == newNode.runtimeType);
+    assert(key == newNode.key);
+    assert(_built != null);
+    newNode._disqualifiedFromEverAppearingAgain = true;
 
-    if (old == null)
-      return false;
+    newNode._built = _built;
+    _built = null;
 
-    assert(runtimeType == old.runtimeType);
-    assert(key == old.key);
+    syncFields(newNode);
+    _dirty = true;
 
-    // Make |this|, the newly-created object, into the "old" Component, and kill it
-    _built = old._built;
-    assert(_built != null);
-    _disqualifiedFromEverAppearingAgain = true;
-
-    // Make |old| the "new" component
-    old._built = null;
-    old._dirty = true;
-    old.syncFields(this);
     return true;
   }
 
-  // This is called by _retainStatefulNodeIfPossible(), during
+  // This is called by retainStatefulNodeIfPossible(), during
   // syncChild(), just before _sync() is called. Derived
   // classes should override this method to update `this` to
   // account for the new values the parent passed to `source`.
   // Make sure to call super.syncFields(source) unless you are
   // extending StatefulComponent directly.
   void syncFields(Component source);
 
   void setState(Function fn()) {
     assert(!_disqualifiedFromEverAppearingAgain);
     fn();
     scheduleBuild();
   }
 }
 
 Set<Component> _dirtyComponents = new Set<Component>();
 bool _buildScheduled = false;
 bool _inRenderDirtyComponents = false;
+int _inLayoutCallbackBuilder = 0;
+
+class LayoutCallbackBuilderHandle { bool _active = true; }
+LayoutCallbackBuilderHandle enterLayoutCallbackBuilder() {
+  if (!inDebugBuild)
+    return null;
+  _inLayoutCallbackBuilder += 1;
+  return new LayoutCallbackBuilderHandle();
+}
+void exitLayoutCallbackBuilder(LayoutCallbackBuilderHandle handle) {
+  if (!inDebugBuild)
+    return;
+  assert(handle._active);
+  handle._active = false;
+  _inLayoutCallbackBuilder -= 1;
+}
 
 List<int> _debugFrameTimes = <int>[];
 
 void _absorbDirtyComponents(List<Component> list) {
   list.addAll(_dirtyComponents);
   _dirtyComponents.clear();
   list.sort((Component a, Component b) => a._order - b._order);
 }
 
 void _buildDirtyComponents() {
@@ skipping 60 matching lines @@
   RenderObject createNode();
 
   static final Map<RenderObject, RenderObjectWrapper> _nodeMap =
       new HashMap<RenderObject, RenderObjectWrapper>();
   static RenderObjectWrapper _getMounted(RenderObject node) => _nodeMap[node];
 
   RenderObjectWrapper _ancestor;
   void insertChildRoot(RenderObjectWrapper child, dynamic slot);
   void detachChildRoot(RenderObjectWrapper child);
 
+  void retainStatefulRenderObjectWrapper(RenderObjectWrapper newNode) {
+    newNode._root = _root;
+    newNode._ancestor = _ancestor;
+  }
+
   void _sync(RenderObjectWrapper old, dynamic slot) {
     // TODO(abarth): We should split RenderObjectWrapper into two pieces so that
     //               RenderViewObject doesn't need to inherit all this code it
     //               doesn't need.
     assert(parent != null || this is RenderViewWrapper);
     if (old == null) {
       _root = createNode();
+      assert(_root != null);
       _ancestor = findAncestorRenderObjectWrapper();
       if (_ancestor is RenderObjectWrapper)
         _ancestor.insertChildRoot(this, slot);
     } else {
       assert(old is RenderObjectWrapper);
       _root = old.root;
       _ancestor = old._ancestor;
+      assert(_root != null);
     }
     assert(_root == root); // in case a subclass reintroduces it
     assert(root != null);
     assert(mounted);
     _nodeMap[root] = this;
     syncRenderObject(old);
   }
 
   void updateSlot(dynamic newSlot) {
     // We never use the slot except during sync(), in which
@@ skipping 383 matching lines @@
 void runApp(App app, { RenderView renderViewOverride, bool enableProfilingLoop: false }) {
   WidgetSkyBinding.initWidgetSkyBinding(renderViewOverride: renderViewOverride);
   new AppContainer(app);
   if (enableProfilingLoop) {
     new Timer.periodic(const Duration(milliseconds: 20), (_) {
       app.scheduleBuild();
     });
   }
 }
 
-typedef Widget Builder();
-
 class RenderBoxToWidgetAdapter extends AbstractWidgetRoot {
 
   RenderBoxToWidgetAdapter(
     RenderObjectWithChildMixin<RenderBox> container,
     this.builder
   ) : _container = container, super() {
     assert(builder != null);
   }
 
   RenderObjectWithChildMixin<RenderBox> _container;
@@ skipping 20 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();
 }