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

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 207 matching lines @@
 class BoxParentData extends ParentData {
   Point _position = Point.origin;
   Point get position => _position;
   void set position(Point value) {
     assert(RenderObject.debugDoingLayout);
     _position = value;
   }
   String toString() => 'position=$position';
 }
 
+enum TextBaseline { alphabetic, ideographic }
+
 abstract class RenderBox extends RenderObject {
 
   void setParentData(RenderObject child) {
     if (child.parentData is! BoxParentData)
       child.parentData = new BoxParentData();
   }
 
   // getMinIntrinsicWidth() should return the minimum width that this box could
   // be without failing to render its contents within itself.
   double getMinIntrinsicWidth(BoxConstraints constraints) {
@@ skipping 14 matching lines @@
 
   // getMaxIntrinsicHeight should return the smallest height beyond which
   // increasing the height never decreases the width.
   // If the layout algorithm used is width-in-height-out, i.e. the height
   // depends on the width and not vice versa, then this will return the same
   // as getMinIntrinsicHeight().
   double getMaxIntrinsicHeight(BoxConstraints constraints) {
     return constraints.constrainHeight(0.0);
   }
 
+  // getDistanceToBaseline() 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. This is used by
+  // certain layout models to align adjacent boxes on a common
+  // baseline, regardless of padding, font size differences, etc. If
+  // there is no baseline, then it should return the distance from the
+  // y-coordinate of the position of the box to the y-coordinate of
+  // the bottom of the box, i.e., the height of the box.
+  // Only call this after layout has been performed.
+  double getDistanceToBaseline(TextBaseline baseline) {
+    assert(!needsLayout);
+    double result = getDistanceToActualBaseline(baseline);
+    if (result == null)
+      return size.height;
+    return result;
+  }
+  // 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;
   }
@@ skipping 69 matching lines @@
       return child.getMinIntrinsicHeight(constraints);
     return super.getMinIntrinsicHeight(constraints);
   }
 
   double getMaxIntrinsicHeight(BoxConstraints constraints) {
     if (child != null)
       return child.getMaxIntrinsicHeight(constraints);
     return super.getMaxIntrinsicHeight(constraints);
   }
 
+  double getDistanceToActualBaseline(TextBaseline baseline) {
+    if (child != null)
+      return child.getDistanceToActualBaseline(baseline);
+    return super.getDistanceToActualBaseline(baseline);
+  }
+
   void performLayout() {
     if (child != null) {
       child.layout(constraints, parentUsesSize: true);
       size = child.size;
     } else {
       performResize();
     }
   }
 
   void hitTestChildren(HitTestResult result, { Point position }) {
@@ skipping 217 matching lines @@
 
   RenderShiftedBox(RenderBox child) {
     this.child = child;
   }
 
   void paint(RenderCanvas canvas) {
     if (child != null)
       canvas.paintChild(child, child.parentData.position);
   }
 
+  double getDistanceToActualBaseline(TextBaseline baseline) {
+    double result;
+    if (child != null) {
+      assert(!needsLayout);
+      result = child.getDistanceToActualBaseline(baseline);
+      assert(child.parentData is BoxParentData);
+      if (result != null)
+        result += child.parentData.position.y;
+    } else {
+      result = super.getDistanceToActualBaseline(baseline);
+    }
+    return result;
+  }
+
   void hitTestChildren(HitTestResult result, { Point position }) {
     if (child != null) {
       assert(child.parentData is BoxParentData);
       Rect childBounds = new Rect.fromPointAndSize(child.parentData.position, child.size);
       if (childBounds.contains(position)) {
         child.hitTest(result, position: new Point(position.x - child.parentData.position.x,
                                                       position.y - child.parentData.position.y));
       }
     }
   }
@@ skipping 484 matching lines @@
       RenderObject.debugDoingPaint = false;
       sky.tracing.end('RenderView.paintFrame');
     }
   }
 
 }
 
 // DEFAULT BEHAVIORS FOR RENDERBOX CONTAINERS
 abstract class RenderBoxContainerDefaultsMixin<ChildType extends RenderBox, ParentDataType extends ContainerParentDataMixin<ChildType>> implements ContainerRenderObjectMixin<ChildType, ParentDataType> {
 
+  double defaultGetDistanceToFirstActualBaseline(TextBaseline baseline) {
+    assert(!needsLayout);
+    RenderBox child = firstChild;
+    while (child != null) {
+      assert(child.parentData is ParentDataType);
+      double result = child.getDistanceToActualBaseline(baseline);
+      if (result != null)
+        return result + child.parentData.position.y;
+      child = child.parentData.nextSibling;
+    }
+    return null;
+  }
+
+  double defaultGetDistanceToHighestActualBaseline(TextBaseline baseline) {
+    assert(!needsLayout);
+    double result;
+    RenderBox child = firstChild;
+    while (child != null) {
+      assert(child.parentData is ParentDataType);
+      double candidate = child.getDistanceToActualBaseline(baseline);
+      if (candidate != null) {
+        candidate += child.parentData.position.x;
+        if (result != null)
+          result = math.min(result, candidate);
+        else
+          result = candidate;
+      }
+      child = child.parentData.nextSibling;
+    }
+    return result;
+  }
+
   void defaultHitTestChildren(HitTestResult result, { Point position }) {
     // the x, y parameters have the top left of the node's box as the origin
     ChildType child = lastChild;
     while (child != null) {
       assert(child.parentData is ParentDataType);
       Rect childBounds = new Rect.fromPointAndSize(child.parentData.position, child.size);
       if (childBounds.contains(position)) {
         if (child.hitTest(result, position: new Point(position.x - child.parentData.position.x,
                                                           position.y - child.parentData.position.y)))
           break;
       }
       child = child.parentData.previousSibling;
     }
   }
 
   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;
     }
   }
 }