Add asserts to catch potential misuses of the rendering framework.

sky/sdk/lib/rendering/box.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:math' as math;
 import 'dart:sky' as sky;
 
 import 'package:vector_math/vector_math.dart';
 
 import '../base/debug.dart';
@@ skipping 175 matching lines @@
       result = new _DebugSize(result, size._owner, size._canBeUsedByParent);
     return result;
   }
 
   bool get isInfinite => maxWidth >= double.INFINITY && maxHeight >= double.INFINITY;
 
   bool get hasTightWidth => minWidth >= maxWidth;
   bool get hasTightHeight => minHeight >= maxHeight;
   bool get isTight => hasTightWidth && hasTightHeight;
 
+  bool contains(Size size) {
+    return (minWidth <= size.width) && (size.width <= math.max(minWidth, maxWidth)) &&
+           (minHeight <= size.height) && (size.height <= math.max(minHeight, maxHeight));
+  }
+
   bool operator ==(other) {
     if (identical(this, other))
       return true;
     return other is BoxConstraints &&
            minWidth == other.minWidth &&
            maxWidth == other.maxWidth &&
            minHeight == other.minHeight &&
            maxHeight == other.maxHeight;
   }
   int get hashCode {
@@ skipping 77 matching lines @@
   }
   // getDistanceToActualBaseline() should return the distance from the
   // y-coordinate of the position of the box to the y-coordinate of
   // the first given baseline in the box's contents, if any, or null
   // otherwise.
   double getDistanceToActualBaseline(TextBaseline baseline) {
     assert(!needsLayout);
     return null;
   }
 
-  // This whole block should only be here in debug builds
-  bool _debugDoingThisLayout = false;
-  bool _debugCanParentUseSize;
-  void layoutWithoutResize() {
-    _debugDoingThisLayout = true;
-    _debugCanParentUseSize = false;
-    super.layoutWithoutResize();
-    _debugCanParentUseSize = null;
-    _debugDoingThisLayout = false;
+  BoxConstraints get constraints => super.constraints;
+  bool debugDoesMeetConstraints() {
+    assert(constraints != null);
+    assert(_size != null);
+    assert(!_size.isInfinite);
+    return constraints.contains(_size);
   }
-  void layout(dynamic constraints, { bool parentUsesSize: false }) {
-    _debugDoingThisLayout = true;
-    _debugCanParentUseSize = parentUsesSize;
-    super.layout(constraints, parentUsesSize: parentUsesSize);
-    _debugCanParentUseSize = null;
-    _debugDoingThisLayout = false;
-  }
-
-  BoxConstraints get constraints => super.constraints;
   void performResize() {
     // default behaviour for subclasses that have sizedByParent = true
     size = constraints.constrain(Size.zero);
     assert(size.height < double.INFINITY);
     assert(size.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, { Point position }) {
     hitTestChildren(result, position: position);
     result.add(new BoxHitTestEntry(this, position));
     return true;
   }
   void hitTestChildren(HitTestResult result, { Point position }) { }
 
+  // TODO(ianh): move size up to before constraints
   // TODO(ianh): In non-debug builds, this should all just be:
   // Size size = Size.zero;
   // In debug builds, however:
   Size _size = Size.zero;
-  Size get size => _size;
+  Size get size {
+    if (_size is _DebugSize) {
+      final _DebugSize _size = this._size; // TODO(ianh): Remove this once the analyzer is cleverer
+      assert(_size._owner == this);
+      if (RenderObject.debugActiveLayout != null) {
+        // we are always allowed to access our own size (for print debugging and asserts if nothing else)
+        // other than us, the only object that's allowed to read our size is our parent, if they're said they will
+        assert(debugDoingThisResize || debugDoingThisLayout ||
+               (RenderObject.debugActiveLayout == parent && _size._canBeUsedByParent));
+      }
+      assert(_size == this._size); // TODO(ianh): Remove this once the analyzer is cleverer
+    }
+    return _size;
+  }
   void set size(Size value) {
     assert(RenderObject.debugDoingLayout);
-    assert(_debugDoingThisLayout);
+    assert((sizedByParent && debugDoingThisResize) ||
+           (!sizedByParent && debugDoingThisLayout));
     if (value is _DebugSize) {
       assert(value._canBeUsedByParent);
       assert(value._owner.parent == this);
     }
-    _size = inDebugBuild ? new _DebugSize(value, this, _debugCanParentUseSize) : value;
+    _size = inDebugBuild ? new _DebugSize(value, this, debugCanParentUseSize) : value;
   }
 
   String debugDescribeSettings(String prefix) => '${super.debugDescribeSettings(prefix)}${prefix}size: ${size}\n';
 }
 
 class RenderProxyBox extends RenderBox with RenderObjectWithChildMixin<RenderBox> {
 
   // ProxyBox assumes the child will be at 0,0 and will have the same size
 
   RenderProxyBox([RenderBox child = null]) {
@@ skipping 772 matching lines @@
   void performLayout() {
     if (_rootConstraints.orientation != _orientation) {
       if (_orientation != null && child != null)
         child.rotate(oldAngle: _orientation, newAngle: _rootConstraints.orientation, time: timeForRotation);
       _orientation = _rootConstraints.orientation;
     }
     _size = new Size(_rootConstraints.width, _rootConstraints.height);
     assert(_size.height < double.INFINITY);
     assert(_size.width < double.INFINITY);
 
-    if (child != null) {
+    if (child != null)
       child.layout(new BoxConstraints.tight(_size));
-      assert(child.size.width == width);
-      assert(child.size.height == height);
-    }
   }
 
   void rotate({ int oldAngle, int newAngle, Duration time }) {
     assert(false); // nobody tells the screen to rotate, the whole rotate() dance is started from our performResize()
   }
 
   bool hitTest(HitTestResult result, { Point position }) {
     if (child != null) {
       Rect childBounds = new Rect.fromSize(child.size);
       if (childBounds.contains(position))
@@ skipping 79 matching lines @@
 
   void defaultPaint(RenderCanvas canvas) {
     RenderBox child = firstChild;
     while (child != null) {
       assert(child.parentData is ParentDataType);
       canvas.paintChild(child, child.parentData.position);
       child = child.parentData.nextSibling;
     }
   }
 }