Use the baseline information exposed by C++ to pipe baseline data through RenderBox.

sky/sdk/lib/rendering/flex.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 'box.dart';
 import 'object.dart';
 
 class FlexBoxParentData extends BoxParentData with ContainerParentDataMixin<RenderBox> {
@@ skipping 92 matching lines @@
       RenderBox child = firstChild;
       while (child != null) {
         int flex = _getFlex(child);
         totalFlex += flex;
         if (flex > 0) {
           double flexFraction = childSize(child, childConstraints) / _getFlex(child);
           maxFlexFractionSoFar = math.max(maxFlexFractionSoFar, flexFraction);
         } else {
           inflexibleSpace += childSize(child, childConstraints);
         }
+        assert(child.parentData is FlexBoxParentData);
         child = child.parentData.nextSibling;
       }
       double mainSize = maxFlexFractionSoFar * totalFlex + inflexibleSpace;
 
       // Ensure that we don't violate the given constraints with our result
       switch(_direction) {
         case FlexDirection.horizontal:
           return constraints.constrainWidth(mainSize);
         case FlexDirection.vertical:
           return constraints.constrainHeight(mainSize);
@@ skipping 42 matching lines @@
               case FlexDirection.vertical:
                 mainSize = child.getMaxIntrinsicHeight(childConstraints);
                 BoxConstraints heightConstraints = 
                   new BoxConstraints(minWidth: mainSize, maxWidth: mainSize);
                 crossSize = child.getMaxIntrinsicWidth(heightConstraints);
                 break;
           }
           inflexibleSpace += mainSize;
           maxCrossSize = math.max(maxCrossSize, crossSize);
         }
+        assert(child.parentData is FlexBoxParentData);
         child = child.parentData.nextSibling;
       }
 
       // Determine the spacePerFlex by allocating the remaining available space
       double spacePerFlex = (availableMainSpace - inflexibleSpace) / totalFlex;
 
       // Size remaining items, find the maximum cross size
       child = firstChild;
       while (child != null) {
         int flex = _getFlex(child);
         if (flex > 0) {
           double childMainSize = spacePerFlex * flex;
           double crossSize;
           switch (_direction) {
             case FlexDirection.horizontal:
               BoxConstraints childConstraints = 
                 new BoxConstraints(minWidth: childMainSize, maxWidth: childMainSize);
               crossSize = child.getMaxIntrinsicHeight(childConstraints);
               break;
             case FlexDirection.vertical:
               BoxConstraints childConstraints =
                 new BoxConstraints(minHeight: childMainSize, maxHeight: childMainSize);
               crossSize = child.getMaxIntrinsicWidth(childConstraints);
               break;
           }
           maxCrossSize = math.max(maxCrossSize, crossSize);
         }
+        assert(child.parentData is FlexBoxParentData);
         child = child.parentData.nextSibling;
       }
 
       // Ensure that we don't violate the given constraints with our result
       switch(_direction) {
         case FlexDirection.horizontal:
           return constraints.constrainHeight(maxCrossSize);
         case FlexDirection.vertical:
           return constraints.constrainWidth(maxCrossSize);
       }
@@ skipping 24 matching lines @@
     );
   }
 
   double getMaxIntrinsicHeight(BoxConstraints constraints) {
     return _getIntrinsicSize(
       constraints: constraints,
       sizingDirection: FlexDirection.vertical,
       childSize: (c, innerConstraints) => c.getMaxIntrinsicHeight(innerConstraints));
   }
 
+  double getDistanceToActualBaseline(TextBaseline baseline) {
+    assert(!needsLayout);
+    if (_direction == FlexDirection.horizontal)
+      return defaultGetDistanceToHighestActualBaseline(baseline);
+    return defaultGetDistanceToFirstActualBaseline(baseline);
+  }
+
   int _getFlex(RenderBox child) {
     assert(child.parentData is FlexBoxParentData);
     return child.parentData.flex != null ? child.parentData.flex : 0;
   }
 
   double _getCrossSize(RenderBox child) {
     return (_direction == FlexDirection.horizontal) ? child.size.height : child.size.width;
   }
 
   double _getMainSize(RenderBox child) {
     return (_direction == FlexDirection.horizontal) ? child.size.width : child.size.height;
   }
 
   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;
     int totalChildren = 0;
     assert(constraints != null);
     final double mainSize = (_direction == FlexDirection.horizontal) ? constraints.maxWidth : constraints.maxHeight;
     double crossSize = 0.0;  // This will be determined after laying out the children
     double freeSpace = mainSize;
     RenderBox child = firstChild;
     while (child != null) {
+      assert(child.parentData is FlexBoxParentData);
       totalChildren++;
       int flex = _getFlex(child);
       if (flex > 0) {
         totalFlex += child.parentData.flex;
       } else {
         BoxConstraints innerConstraints = new BoxConstraints(maxHeight: constraints.maxHeight,
                                                              maxWidth: constraints.maxWidth);
         child.layout(innerConstraints, parentUsesSize: true);
         freeSpace -= _getMainSize(child);
         crossSize = math.max(crossSize, _getCrossSize(child));
@@ skipping 19 matching lines @@
           case FlexDirection.vertical:
             innerConstraints = new BoxConstraints(minHeight: spaceForChild,
                                                   maxHeight: spaceForChild,
                                                   maxWidth: constraints.maxWidth);
             break;
         }
         child.layout(innerConstraints, parentUsesSize: true);
         usedSpace += _getMainSize(child);
         crossSize = math.max(crossSize, _getCrossSize(child));
       }
+      assert(child.parentData is FlexBoxParentData);
       child = child.parentData.nextSibling;
     }
 
     // Section 8.2: Axis Alignment using the justify-content property
     double remainingSpace = math.max(0.0, freeSpace - usedSpace);
     double leadingSpace;
     double betweenSpace;
     child = firstChild;
     switch (_justifyContent) {
       case FlexJustifyContent.flexStart:
@@ skipping 26 matching lines @@
       case FlexDirection.vertical:
         size = constraints.constrain(new Size(crossSize, mainSize));
         crossSize = size.width;
         break;
     }
 
     // Position elements. For now, center the flex items in the cross direction
     double childMainPosition = leadingSpace;
     child = firstChild;
     while (child != null) {
+      assert(child.parentData is FlexBoxParentData);
       double childCrossPosition;
       switch (_alignItems) {
         case FlexAlignItems.flexStart:
           childCrossPosition = 0.0;
           break;
         case FlexAlignItems.flexEnd:
           childCrossPosition = crossSize - _getCrossSize(child);
           break;
         case FlexAlignItems.center:
           childCrossPosition = crossSize / 2.0 - _getCrossSize(child) / 2.0;
@@ skipping 13 matching lines @@
   }
 
   void hitTestChildren(HitTestResult result, { Point position }) {
     defaultHitTestChildren(result, position: position);
   }
 
   void paint(RenderCanvas canvas) {
     defaultPaint(canvas);
   }
 }