Refactor layout/relayout into a single method.

sky/sdk/lib/framework/layout2.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 'node.dart';
 import 'dart:sky' as sky;
 
 // ABSTRACT LAYOUT
 
 class ParentData {
@@ skipping 56 matching lines @@
     assert(child.parentData != null);
     child.parentData.detach();
     super.dropChild(child);
   }
 
   static List<RenderNode> _nodesNeedingLayout = new List<RenderNode>();
   static bool _debugDoingLayout = false;
   bool _needsLayout = true;
   bool get needsLayout => _needsLayout;
   RenderNode _relayoutSubtreeRoot;
-  void saveRelayoutSubtreeRoot(RenderNode relayoutSubtreeRoot) {
-    _relayoutSubtreeRoot = relayoutSubtreeRoot;
-    assert(_relayoutSubtreeRoot == null || _relayoutSubtreeRoot._relayoutSubtreeRoot == null);
-    assert(_relayoutSubtreeRoot == null || _relayoutSubtreeRoot == parent || (parent is RenderNode && _relayoutSubtreeRoot == parent._relayoutSubtreeRoot));
-  }
+  dynamic _constraints;
+  dynamic get constraints => _constraints;
   bool debugAncestorsAlreadyMarkedNeedsLayout() {
     if (_relayoutSubtreeRoot == null)
-      return true;
+      return true; // we haven't yet done layout even once, so there's nothing for us to do
     RenderNode node = this;
     while (node != _relayoutSubtreeRoot) {
       assert(node._relayoutSubtreeRoot == _relayoutSubtreeRoot);
       assert(node.parent != null);
       node = node.parent as RenderNode;
       if (!node._needsLayout)
         return false;
     }
-    assert(node._relayoutSubtreeRoot == null);
+    assert(node._relayoutSubtreeRoot == node);
     return true;
   }
   void markNeedsLayout() {
     assert(!_debugDoingLayout);
     assert(!_debugDoingPaint);
     if (_needsLayout) {
       assert(debugAncestorsAlreadyMarkedNeedsLayout());
       return;
     }
     _needsLayout = true;
-    if (_relayoutSubtreeRoot != null) {
+    assert(_relayoutSubtreeRoot != null);
+    if (_relayoutSubtreeRoot != this) {
       assert(parent is RenderNode);
       parent.markNeedsLayout();
     } else {
       _nodesNeedingLayout.add(this);
     }
   }
   static void flushLayout() {
     _debugDoingLayout = true;
     List<RenderNode> dirtyNodes = _nodesNeedingLayout;
     _nodesNeedingLayout = new List<RenderNode>();
     dirtyNodes..sort((a, b) => a.depth - b.depth)..forEach((node) {
       if (node._needsLayout && node.attached)
         node._doLayout();
     });
     _debugDoingLayout = false;
   }
   void _doLayout() {
     try {
-      assert(_relayoutSubtreeRoot == null);
-      relayout();
+      assert(_relayoutSubtreeRoot == this);
+      performLayout();
     } catch (e, stack) {
       print('Exception raised during layout of ${this}: ${e}');
       print(stack);
       return;
     }
     assert(!_needsLayout); // check that the relayout() method marked us "not dirty"
   }
-  /* // this method's signature is subclass-specific, but will exist in
-     // some form in all subclasses:
-     void layout({arguments..., RenderNode relayoutSubtreeRoot}) {
-       bool childArgumentsChanged = ...; // true if arguments we're going to pass to the children are different than last time, false otherwise
-       if (this node has an opinion about its size, e.g. because it autosizes based on kids, or has an intrinsic dimension) {
-         if (relayoutSubtreeRoot != null) {
-           saveRelayoutSubtreeRoot(relayoutSubtreeRoot);
-           // for each child, if we are going to size ourselves around them:
-           if (child.needsLayout || childArgumentsChanged)
-             child.layout(... relayoutSubtreeRoot: relayoutSubtreeRoot);
-           width = ...;
-           height = ...;
-         } else {
-           saveRelayoutSubtreeRoot(null); // you can skip this if there's no way you would ever have called saveRelayoutSubtreeRoot() before
-           // we're the root of the relayout subtree
-           // for each child, if we are going to size ourselves around them:
-           if (child.needsLayout || childArgumentsChanged)
-             child.layout(... relayoutSubtreeRoot: this);
-           width = ...;
-           height = ...;
-         }
-       } else {
-         // we're sizing ourselves exclusively on input from the parent (arguments to this function)
-         // ignore relayoutSubtreeRoot
-         saveRelayoutSubtreeRoot(null); // you can skip this if there's no way you would ever have called saveRelayoutSubtreeRoot() before
-         width = ...; // based on input from arguments only
-         height = ...; // based on input from arguments only
-       }
-       // for each child whose size we'll ignore when deciding ours:
-       if (child.needsLayout || childArgumentsChanged)
-         child.layout(... relayoutSubtreeRoot: null); // or just omit relayoutSubtreeRoot
-       layoutDone();
-       return;
-     }
-  */
-  void relayout() {
+  void layout(dynamic constraints, { bool parentUsesSize: false }) {
+    RenderNode relayoutSubtreeRoot;
+    if (!parentUsesSize || sizedByParent || parent is! RenderNode)
+      relayoutSubtreeRoot = this;
+    else
+      relayoutSubtreeRoot = parent._relayoutSubtreeRoot;
+    if (!needsLayout && constraints == _constraints && relayoutSubtreeRoot == _relayoutSubtreeRoot)
+      return;
+    _constraints = constraints;
+    _relayoutSubtreeRoot = relayoutSubtreeRoot;
+    if (sizedByParent)
+      performResize();
+    performLayout();
+    _needsLayout = false;
+    markNeedsPaint();
+  }
+  bool get sizedByParent => false; // return true if the constraints are the only input to the sizing algorithm (in particular, child nodes have no impact)
+  void performResize(); // set the local dimensions, using only the constraints (only called if sizedByParent is true)
+  void performLayout();
     // Override this to perform relayout without your parent's
     // involvement.
     //
-    // This is what is called after the first layout(), if you mark
-    // yourself dirty and don't have a _relayoutSubtreeRoot set; in
-    // other words, either if your parent doesn't care what size you
-    // are (and thus didn't pass a relayoutSubtreeRoot to your
-    // layout() method) or if you sized yourself entirely based on
-    // what your parents told you, and not based on your children (and
-    // thus you never called saveRelayoutSubtreeRoot()).
+    // This is called during layout. If sizedByParent is true, then
+    // performLayout() should not change your dimensions, only do that
+    // in performResize(). If sizedByParent is false, then set both
+    // your dimensions and do your children's layout here.
     //
-    // In the former case, you can resize yourself here at will. In
-    // the latter case, just leave your dimensions unchanged.
-    //
-    // If _relayoutSubtreeRoot is set (i.e. you called saveRelayout-
-    // SubtreeRoot() in your layout(), with a relayoutSubtreeRoot
-    // argument that was non-null), then if you mark yourself as dirty
-    // then we'll tell that subtree root instead, and the layout will
-    // occur via the layout() tree rather than starting from this
-    // relayout() method.
-    //
-    // when calling children's layout() methods, skip any children
-    // that have needsLayout == false unless the arguments you are
-    // passing in have changed since the last time
-    assert(_relayoutSubtreeRoot == null);
-    layoutDone();
-  }
-  void layoutDone({bool needsPaint: true}) {
-    // make sure to call this at the end of your layout() or relayout()
-    _needsLayout = false;
-    if (needsPaint)
-      markNeedsPaint();
-  }
+    // When calling layout() on your children, pass in
+    // "parentUsesSize: true" if your size or layout is dependent on
+    // your child's size.
 
   // when the parent has rotated (e.g. when the screen has been turned
   // 90 degrees), immediately prior to layout() being called for the
   // new dimensions, rotate() is called with the old and new angles.
   // The next time paint() is called, the coordinate space will have
   // been rotated N quarter-turns clockwise, where:
   //    N = newAngle-oldAngle
   // ...but the rendering is expected to remain the same, pixel for
   // pixel, on the output device. Then, the layout() method or
   // equivalent will be invoked.
 
   void rotate({
     int oldAngle, // 0..3
     int newAngle, // 0..3
     Duration time
   }) { }
 
 
   // PAINTING
 
   static bool _debugDoingPaint = false;
   void markNeedsPaint() {
     assert(!_debugDoingPaint);
-    // TODO(abarth): It's very redunant to call this for every node in the
+    // TODO(abarth): It's very redundant to call this for every node in the
     // render tree during layout. We should instead compute a summary bit and
     // call it once at the end of layout.
     sky.view.scheduleFrame();
   }
   void paint(RenderNodeDisplayList canvas) { }
 
 
   // HIT TESTING  
 
   void handlePointer(sky.PointerEvent event) {
@@ skipping 281 matching lines @@
 
   // override this to report what dimensions you would have if you
   // were laid out with the given constraints this can walk the tree
   // if it must, but it should be as cheap as possible; just get the
   // dimensions and nothing else (e.g. don't calculate hypothetical
   // child positions if they're not needed to determine dimensions)
   BoxDimensions getIntrinsicDimensions(BoxConstraints constraints) {
     return new BoxDimensions.withConstraints(constraints);
   }
 
-  void layout(BoxConstraints constraints, { RenderNode relayoutSubtreeRoot }) {
+  BoxConstraints get constraints => super.constraints as BoxConstraints;
+  void performResize() {
+    // default behaviour for subclasses that have sizedByParent = true
     width = constraints.constrainWidth(0.0);
     height = constraints.constrainHeight(0.0);
-    layoutDone();
+    assert(height < double.INFINITY);
+    assert(width < double.INFINITY);
+  }
+  void performLayout() {
+    // descendants have to either override performLayout() to set both
+    // width and height and lay out children, or, set sizedByParent to
+    // true so that performResize()'s logic above does its thing.
+    assert(sizedByParent);
   }
 
   bool hitTest(HitTestResult result, { double x, double y }) {
     hitTestChildren(result, x: x, y: y);
     result.add(this);
     return true;
   }
   void hitTestChildren(HitTestResult result, { double x, double y }) { }
 
   double width;
@@ skipping 19 matching lines @@
   }
 
   BoxDimensions getIntrinsicDimensions(BoxConstraints constraints) {
     assert(padding != null);
     constraints = constraints.deflate(padding);
     if (child == null)
       return super.getIntrinsicDimensions(constraints);
     return child.getIntrinsicDimensions(constraints);
   }
 
-  void layout(BoxConstraints constraints, { RenderNode relayoutSubtreeRoot }) {
+  void performLayout() {
     assert(padding != null);
-    constraints = constraints.deflate(padding);
+    BoxConstraints innerConstraints = constraints.deflate(padding);
     if (child == null) {
-      width = constraints.constrainWidth(padding.left + padding.right);
-      height = constraints.constrainHeight(padding.top + padding.bottom);
+      width = innerConstraints.constrainWidth(padding.left + padding.right);
+      height = innerConstraints.constrainHeight(padding.top + padding.bottom);
       return;
     }
-    if (relayoutSubtreeRoot != null)
-      saveRelayoutSubtreeRoot(relayoutSubtreeRoot);
-    else
-      relayoutSubtreeRoot = this;
-    child.layout(constraints, relayoutSubtreeRoot: relayoutSubtreeRoot);
+    child.layout(innerConstraints, parentUsesSize: true);
     assert(child.parentData is BoxParentData);
     child.parentData.x = padding.left;
     child.parentData.y = padding.top;
     width = constraints.constrainWidth(padding.left + child.width + padding.right);
     height = constraints.constrainHeight(padding.top + child.height + padding.bottom);
   }
 
   void paint(RenderNodeDisplayList canvas) {
     if (child != null)
       canvas.paintChild(child, child.parentData.x, child.parentData.y);
@@ skipping 65 matching lines @@
     if (_decoration.backgroundColor != null) {
       sky.Paint paint = new sky.Paint()..color = _decoration.backgroundColor;
       canvas.drawCircle(new sky.Rect()..setLTRB(0.0, 0.0, width, height), paint);
     }
   }
 }
 
 
 // RENDER VIEW LAYOUT MANAGER
 
+class ViewConstraints {
+
+  const ViewConstraints({
+    this.width: 0.0, this.height: 0.0, this.orientation: null
+  });
+
+  final double width;
+  final double height;
+  final int orientation;
+
+}
+
 class RenderView extends RenderNode with RenderNodeWithChildMixin<RenderBox> {
 
   RenderView({
     RenderBox child,
     this.timeForRotation: const Duration(microseconds: 83333)
   }) {
     this.child = child;
   }
 
   double _width;
   double get width => _width;
   double _height;
   double get height => _height;
 
   int _orientation; // 0..3
   int get orientation => _orientation;
   Duration timeForRotation;
 
-  void layout({
-    double newWidth,
-    double newHeight,
-    int newOrientation
-  }) {
-    if (newOrientation != orientation) {
-      if (orientation != null && child != null)
-        child.rotate(oldAngle: orientation, newAngle: newOrientation, time: timeForRotation);
-      _orientation = newOrientation;
+  ViewConstraints get constraints => super.constraints as ViewConstraints;
+  bool get sizedByParent => true;
+  void performResize() {
+    if (constraints.orientation != _orientation) {
+      if (_orientation != null && child != null)
+        child.rotate(oldAngle: _orientation, newAngle: constraints.orientation, time: timeForRotation);
+      _orientation = constraints.orientation;
     }
-    if ((newWidth != width) || (newHeight != height)) {
-      _width = newWidth;
-      _height = newHeight;
-      relayout();
-    } else {
-      layoutDone();
-    }
+    _width = constraints.width;
+    _height = constraints.height;
+    assert(height < double.INFINITY);
+    assert(width < double.INFINITY);
   }
-
-  void relayout() {
+  void performLayout() {
     if (child != null) {
       child.layout(new BoxConstraints.tight(width: width, height: height));
       assert(child.width == width);
       assert(child.height == height);
     }
-    layoutDone();
   }
 
   void rotate({ int oldAngle, int newAngle, Duration time }) {
-    assert(false); // nobody tells the screen to rotate, the whole rotate() dance is started from our layout()
+    assert(false); // nobody tells the screen to rotate, the whole rotate() dance is started from our performResize()
   }
 
   bool hitTest(HitTestResult result, { double x, double y }) {
     if (child != null && x >= 0.0 && x < child.width && y >= 0.0 && y < child.height)
       child.hitTest(result, x: x, y: y);
     result.add(this);
     return true;
   }
 
   void paint(RenderNodeDisplayList canvas) {
@@ skipping 73 matching lines @@
     while (child != null) {
       outerHeight += child.getIntrinsicDimensions(innerConstraints).height;
       assert(child.parentData is BlockParentData);
       child = child.parentData.nextSibling;
     }
 
     return new BoxDimensions(width: outerWidth,
                              height: constraints.constrainHeight(outerHeight));
   }
 
-  BoxConstraints _constraints; // value cached from parent for relayout call
-  void layout(BoxConstraints constraints, { RenderNode relayoutSubtreeRoot }) {
-    if (relayoutSubtreeRoot != null)
-      saveRelayoutSubtreeRoot(relayoutSubtreeRoot);
-    else
-      relayoutSubtreeRoot = this;
+  void performLayout() {
+    assert(constraints is BoxConstraints);
     width = constraints.constrainWidth(constraints.maxWidth);
     assert(width < double.INFINITY);
-    _constraints = constraints;
-    internalLayout(relayoutSubtreeRoot);
-  }
-
-  void relayout() {
-    internalLayout(this);
-  }
-
-  void internalLayout(RenderNode relayoutSubtreeRoot) {
-    assert(_constraints != null);
     double y = 0.0;
     double innerWidth = width;
     RenderBox child = firstChild;
     while (child != null) {
-      child.layout(new BoxConstraints(minWidth: innerWidth, maxWidth: innerWidth),
-                   relayoutSubtreeRoot: relayoutSubtreeRoot);
+      child.layout(new BoxConstraints(minWidth: innerWidth, maxWidth: innerWidth), parentUsesSize: true);
       assert(child.parentData is BlockParentData);
       child.parentData.x = 0.0;
       child.parentData.y = y;
       y += child.height;
       child = child.parentData.nextSibling;
     }
-    height = _constraints.constrainHeight(y);
-    layoutDone();
+    height = constraints.constrainHeight(y);
   }
 
   void hitTestChildren(HitTestResult result, { double x, double y }) {
     defaultHitTestChildren(result, x: x, y: y);
   }
 
   void paint(RenderNodeDisplayList canvas) {
     super.paint(canvas);
     defaultPaint(canvas);
   }
@@ skipping 29 matching lines @@
       _direction = value;
       markNeedsLayout();
     }
   }
 
   void setParentData(RenderBox child) {
     if (child.parentData is! FlexBoxParentData)
       child.parentData = new FlexBoxParentData();
   }
 
-  BoxConstraints _constraints;  // value cached from parent for relayout call
-  void layout(BoxConstraints constraints, { RenderNode relayoutSubtreeRoot }) {
-    if (relayoutSubtreeRoot != null)
-      saveRelayoutSubtreeRoot(relayoutSubtreeRoot);
-    else
-      relayoutSubtreeRoot = this;
-    _constraints = constraints;
+  bool get sizedByParent => true;
+  void performResize() {
     width = _constraints.constrainWidth(_constraints.maxWidth);
     height = _constraints.constrainHeight(_constraints.maxHeight);
     assert(height < double.INFINITY);
     assert(width < double.INFINITY);
-    internalLayout(relayoutSubtreeRoot);
-  }
-
-  void relayout() {
-    internalLayout(this);
   }
 
   int _getFlex(RenderBox child) {
     assert(child.parentData is FlexBoxParentData);
     return child.parentData.flex != null ? child.parentData.flex : 0;
   }
 
-  void internalLayout(RenderNode relayoutSubtreeRoot) {
+  void performLayout() {
     // Based on http://www.w3.org/TR/css-flexbox-1/ Section 9.7 Resolving Flexible Lengths
     // Steps 1-3. Determine used flex factor, size inflexible items, calculate free space
     int totalFlex = 0;
-    assert(_constraints != null);
-    double freeSpace = (_direction == FlexDirection.Horizontal) ? _constraints.maxWidth : _constraints.maxHeight;
+    assert(constraints != null);
+    double freeSpace = (_direction == FlexDirection.Horizontal) ? constraints.maxWidth : constraints.maxHeight;
     RenderBox child = firstChild;
     while (child != null) {
       int flex = _getFlex(child);
       if (flex > 0) {
         totalFlex += child.parentData.flex;
       } else {
-        BoxConstraints constraints = new BoxConstraints(maxHeight: _constraints.maxHeight,
-                                                        maxWidth: _constraints.maxWidth);
-        child.layout(constraints,
-                     relayoutSubtreeRoot: relayoutSubtreeRoot);
+        BoxConstraints innerConstraints = new BoxConstraints(maxHeight: constraints.maxHeight,
+                                                             maxWidth: constraints.maxWidth);
+        child.layout(innerConstraints, parentUsesSize: true);
         freeSpace -= (_direction == FlexDirection.Horizontal) ? child.width : child.height;
       }
       child = child.parentData.nextSibling;
     }
 
     // Steps 4-5. Distribute remaining space to flexible children.
     double spacePerFlex = totalFlex > 0 ? (freeSpace / totalFlex) : 0.0;
     double usedSpace = 0.0;
     child = firstChild;
     while (child != null) {
       int flex = _getFlex(child);
       if (flex > 0) {
         double spaceForChild = spacePerFlex * flex;
-        BoxConstraints constraints;
+        BoxConstraints innerConstraints;
         switch (_direction) {
           case FlexDirection.Horizontal:
-            constraints = new BoxConstraints(maxHeight: _constraints.maxHeight,
-                                             minWidth: spaceForChild,
-                                             maxWidth: spaceForChild);
+            innerConstraints = new BoxConstraints(maxHeight: constraints.maxHeight,
+                                                  minWidth: spaceForChild,
+                                                  maxWidth: spaceForChild);
             break;
           case FlexDirection.Vertical:
-            constraints = new BoxConstraints(minHeight: spaceForChild,
-                                             maxHeight: spaceForChild,
-                                             maxWidth: _constraints.maxWidth);
+            innerConstraints = new BoxConstraints(minHeight: spaceForChild,
+                                                  maxHeight: spaceForChild,
+                                                  maxWidth: constraints.maxWidth);
             break;
         }
-        child.layout(constraints, relayoutSubtreeRoot: relayoutSubtreeRoot);
+        child.layout(innerConstraints, parentUsesSize: true);
       }
 
       // For now, center the flex items in the cross direction
       switch (_direction) {
         case FlexDirection.Horizontal:
           child.parentData.x = usedSpace;
           usedSpace += child.width;
-          child.parentData.y = height / 2 - child.height / 2;
+          child.parentData.y = height / 2.0 - child.height / 2.0;
           break;
         case FlexDirection.Vertical:
           child.parentData.y = usedSpace;
           usedSpace += child.height;
-          child.parentData.x = width / 2 - child.width / 2;
+          child.parentData.x = width / 2.0 - child.width / 2.0;
           break;
       }
       child = child.parentData.nextSibling;
     }
-    layoutDone();
   }
 
   void hitTestChildren(HitTestResult result, { double x, double y }) {
     defaultHitTestChildren(result, x: x, y: y);
   }
 
   void paint(RenderNodeDisplayList canvas) {
     super.paint(canvas);
     defaultPaint(canvas);
   }
 }