Introduce RenderProxyBox and RenderSizedBox

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 398 matching lines @@
                                  (left == other.left);
 }
 
 class BoxConstraints {
   const BoxConstraints({
     this.minWidth: 0.0,
     this.maxWidth: double.INFINITY,
     this.minHeight: 0.0,
     this.maxHeight: double.INFINITY});
 
-  const BoxConstraints.tight({ double width: 0.0, double height: 0.0 })
-    : minWidth = width,
-      maxWidth = width,
-      minHeight = height,
-      maxHeight = height;
+  BoxConstraints.tight(sky.Size size)
+    : minWidth = size.width,
+      maxWidth = size.width,
+      minHeight = size.height,
+      maxHeight = size.height;
 
   BoxConstraints deflate(EdgeDims edges) {
     assert(edges != null);
     return new BoxConstraints(
       minWidth: minWidth,
       maxWidth: maxWidth - (edges.left + edges.right),
       minHeight: minHeight,
       maxHeight: maxHeight - (edges.top + edges.bottom)
     );
   }
@@ skipping 69 matching lines @@
   bool hitTest(HitTestResult result, { sky.Point position }) {
     hitTestChildren(result, position: position);
     result.add(this);
     return true;
   }
   void hitTestChildren(HitTestResult result, { sky.Point position }) { }
 
   sky.Size size = new sky.Size(0.0, 0.0);
 }
 
+abstract class RenderProxyBox extends RenderBox with RenderNodeWithChildMixin<RenderBox> {
+  RenderProxyBox(RenderBox child) {
+    this.child = child;
+  }
+
+  BoxDimensions getIntrinsicDimensions(BoxConstraints constraints) {
+    return child.getIntrinsicDimensions(constraints);
+  }
+
+  void performLayout() {
+    child.layout(constraints, parentUsesSize: true);
+    size = child.size;
+  }
+
+  void hitTestChildren(HitTestResult result, { sky.Point position }) {
+    child.hitTest(result, position: position);
+  }
+
+  void paint(RenderNodeDisplayList canvas) {
+    child.paint(canvas);
+  }
+}
+
+class RenderSizedBox extends RenderProxyBox {
+  final sky.Size desiredSize;
+
+  RenderSizedBox(RenderBox child, [this.desiredSize = const sky.Size.infinite()])
+      : super(child);
+
+  BoxDimensions getIntrinsicDimensions(BoxConstraints constraints) {
+    return new BoxDimensions.withConstraints(constraints,
+                                             width: desiredSize.width,
+                                             height: desiredSize.height);
+  }
+
+  void performLayout() {
+    size = constraints.constrain(desiredSize);
+    child.layout(new BoxConstraints.tight(size));
+  }
+}
+
 class RenderPadding extends RenderBox with RenderNodeWithChildMixin<RenderBox> {
 
   RenderPadding(EdgeDims padding, RenderBox child) {
     assert(padding != null);
     this.padding = padding;
     this.child = child;
   }
 
   EdgeDims _padding;
   EdgeDims get padding => _padding;
@@ skipping 61 matching lines @@
 
   BoxDecoration _decoration;
   BoxDecoration get decoration => _decoration;
   void set decoration (BoxDecoration value) {
     if (value == _decoration)
       return;
     _decoration = value;
     markNeedsPaint();
   }
 
+  void performLayout() {
+    size = constraints.constrain(new sky.Size.infinite());
+  }
+
   void paint(RenderNodeDisplayList canvas) {
     assert(size.width != null);
     assert(size.height != null);
 
     if (_decoration == null)
       return;
 
     if (_decoration.backgroundColor != null) {
       sky.Paint paint = new sky.Paint()..color = _decoration.backgroundColor;
       canvas.drawRect(new sky.Rect.fromLTRB(0.0, 0.0, size.width, size.height), paint);
     }
   }
-
 }
 
 class RenderDecoratedCircle extends RenderDecoratedBox with RenderNodeWithChildMixin<RenderBox> {
   RenderDecoratedCircle({
     BoxDecoration decoration,
     RenderBox child
   }) : super(decoration) {
     this.child = child;
   }
 
@@ skipping 50 matching lines @@
       if (_orientation != null && child != null)
         child.rotate(oldAngle: _orientation, newAngle: constraints.orientation, time: timeForRotation);
       _orientation = constraints.orientation;
     }
     _size = new sky.Size(constraints.width, constraints.height);
     assert(_size.height < double.INFINITY);
     assert(_size.width < double.INFINITY);
   }
   void performLayout() {
     if (child != null) {
-      child.layout(new BoxConstraints.tight(width: width, height: height));
+      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, { sky.Point position }) {
@@ skipping 258 matching lines @@
 
   void hitTestChildren(HitTestResult result, { double x, double y }) {
     // defaultHitTestChildren(result, x: x, y: y);
   }
 
   void paint(RenderNodeDisplayList canvas) {
     super.paint(canvas);
     _layoutRoot.paint(canvas);
   }
 }