Let's hide double.INFINITY a bit more, by providing cleaner APIs for the cases where we're currentl…

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 59 matching lines @@
     this.minHeight: 0.0,
     this.maxHeight: double.INFINITY
   });
 
   BoxConstraints.tight(Size size)
     : minWidth = size.width,
       maxWidth = size.width,
       minHeight = size.height,
       maxHeight = size.height;
 
-  BoxConstraints.tightFor({
+  const BoxConstraints.tightFor({
     double width,
     double height
   }): minWidth = width != null ? width : 0.0,
       maxWidth = width != null ? width : double.INFINITY,
       minHeight = height != null ? height : 0.0,
       maxHeight = height != null ? height : double.INFINITY;
 
   BoxConstraints.loose(Size size)
     : minWidth = 0.0,
       maxWidth = size.width,
       minHeight = 0.0,
       maxHeight = size.height;
 
+  const BoxConstraints.expandWidth({
+    this.maxHeight: double.INFINITY
+  }): minWidth = double.INFINITY,
+      maxWidth = double.INFINITY,
+      minHeight = 0.0;
+
+  const BoxConstraints.expandHeight({
+    this.maxWidth: double.INFINITY
+  }): minWidth = 0.0,
+      minHeight = double.INFINITY,
+      maxHeight = double.INFINITY;
+
+  static const BoxConstraints expand = const BoxConstraints(
+    minWidth: double.INFINITY,
+    maxWidth: double.INFINITY,
+    minHeight: double.INFINITY,
+    maxHeight: double.INFINITY
+  );
+
   BoxConstraints deflate(EdgeDims edges) {
     assert(edges != null);
     double horizontal = edges.left + edges.right;
     double vertical = edges.top + edges.bottom;
     return new BoxConstraints(
       minWidth: math.max(0.0, minWidth - horizontal),
       maxWidth: maxWidth - horizontal,
       minHeight: math.max(0.0, minHeight - vertical),
       maxHeight: maxHeight - vertical
     );
@@ skipping 61 matching lines @@
 
   BoxConstraints widthConstraints() => new BoxConstraints(minWidth: minWidth, maxWidth: maxWidth);
 
   BoxConstraints heightConstraints() => new BoxConstraints(minHeight: minHeight, maxHeight: maxHeight);
 
   final double minWidth;
   final double maxWidth;
   final double minHeight;
   final double maxHeight;
 
-  double constrainWidth(double width) {
+  double constrainWidth([double width = double.INFINITY]) {
     return clamp(min: minWidth, max: maxWidth, value: width);
   }
 
-  double constrainHeight(double height) {
+  double constrainHeight([double height = double.INFINITY]) {
     return clamp(min: minHeight, max: maxHeight, value: height);
   }
 
   Size constrain(Size size) {
     Size result = new Size(constrainWidth(size.width), constrainHeight(size.height));
     if (size is _DebugSize)
       result = new _DebugSize(result, size._owner, size._canBeUsedByParent);
     return result;
   }
 
@@ skipping 115 matching lines @@
     _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);
+    assert(!size.isInfinite);
   }
   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);
@@ skipping 797 matching lines @@
     assert(false);
   }
 
   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);
+    assert(!_size.isInfinite);
 
     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()
@@ skipping 85 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;
     }
   }
 }