anchor.diff:        ourDimensions = new BoxDimensions.withConstraints(constraints, width: 0.0, height: 0.0);
       } else {
         assert(child is RenderSector);
  -      assert(child.parentData is SectorParentData);
         assert(!constraints.isInfinite);
         double maxChildDeltaRadius = math.min(constraints.maxWidth, constraints.maxHeight) / 2.0 - innerRadius;
  -      child.layout(new SectorConstraints(maxDeltaRadius: maxChildDeltaRadius), innerRadius, relayoutSubtreeRoot: relayoutSubtreeRoot);
  +      assert(child.parentData is SectorParentData);
  +      child.parentData.radius = innerRadius;
  +      child.parentData.theta = 0.0;
  +      child.layout(new SectorConstraints(maxDeltaRadius: maxChildDeltaRadius), relayoutSubtreeRoot: relayoutSubtreeRoot);
         double dimension = (innerRadius + child.deltaRadius) * 2.0;
         ourDimensions = new BoxDimensions.withConstraints(constraints, width: dimension, height: dimension);
       }
       width = ourDimensions.width;
       height = ourDimensions.height;
  -    print("adapter is: ${width}x${height}");
       layoutDone();
     }
   
  
positive.code:   sky.view.setBeginFrameCallback(beginFrame);
  
    var rootCircle = new RenderSectorRing(padding: 10.0);
    rootCircle.add(new RenderSolidColor(0xFF00FF00));
    rootCircle.add(new RenderSolidColor(0xFF0000FF));
  
    var root = new RenderBoxToRenderSectorAdapter(innerRadius: 50.0, child: rootCircle);
    renderView = new RenderView(root: root);
    renderView.layout(newWidth: sky.view.width, newHeight: sky.view.height);
  
    sky.view.scheduleFrame();
    print("window is ${sky.view.width}x${sky.view.height}");
  }
  
negative.code:   // paint origin is 0,0 of our circle
    // each sector then knows how to paint itself at its location
    void paint(RenderNodeDisplayList canvas) {
      // TODO(ianh): avoid code duplication
      super.paint(canvas);
      RenderSector child = firstChild;
      while (child != null) {
        assert(child.parentData is SectorChildListParentData);
        canvas.paintChild(child, 0.0, 0.0);
        child = child.parentData.nextSibling;
      }
    }
  
  }
  
  class RenderSectorSlice extends RenderDecoratedSector with ContainerRenderNodeMixin<RenderSector, SectorChildListParentData> {
    // lays out RenderSector children in a stack
  
    RenderSectorSlice({
      BoxDecoration decoration,
      double deltaTheta: kTwoPi,
      double padding: 0.0
    }) : super(decoration), _padding = padding, _desiredDeltaTheta = deltaTheta;
  
    double _desiredDeltaTheta;
    double get desiredDeltaTheta => _desiredDeltaTheta;
    void set desiredDeltaTheta(double value) {
      assert(value != null);
      if (_desiredDeltaTheta != value) {
        _desiredDeltaTheta = value;
        markNeedsLayout();
      }
    }
  
    double _padding;
    double get padding => _padding;
    void set padding(double value) {
      // TODO(ianh): avoid code duplication
      assert(value != null);
      if (_padding != value) {
        _padding = value;
        markNeedsLayout();
      }
    }
  
    void setParentData(RenderNode child) {
      // TODO(ianh): avoid code duplication
      if (child.parentData is! SectorChildListParentData)
        child.parentData = new SectorChildListParentData();
    }
  
    SectorDimensions getIntrinsicDimensions(SectorConstraints constraints, double radius) {
      assert(this.parentData is SectorParentData);
      double paddingTheta = math.atan(padding / this.parentData.radius);
      double outerDeltaTheta = constraints.constrainDeltaTheta(desiredDeltaTheta);
      double innerDeltaTheta = outerDeltaTheta - paddingTheta * 2.0;
      double childRadius = this.parentData.radius + padding;
      double remainingDeltaRadius = constraints.maxDeltaRadius - (padding * 2.0);
      RenderSector child = firstChild;
      while (child != null) {
        SectorConstraints innerConstraints = new SectorConstraints(
          maxDeltaRadius: remainingDeltaRadius,
          maxDeltaTheta: innerDeltaTheta
        );
        SectorDimensions childDimensions = child.getIntrinsicDimensions(innerConstraints, childRadius);
        childRadius += childDimensions.deltaRadius;
        remainingDeltaRadius -= childDimensions.deltaRadius;
        assert(child.parentData is SectorChildListParentData);
        child = child.parentData.nextSibling;
        childRadius += padding;
        remainingDeltaRadius -= padding;
      }
      return new SectorDimensions.withConstraints(constraints,
                                                  deltaRadius: childRadius - this.parentData.radius,
                                                  deltaTheta: outerDeltaTheta);
    }
  
    SectorConstraints _constraints;
    void layout(SectorConstraints constraints, { RenderNode relayoutSubtreeRoot }) {
      if (relayoutSubtreeRoot != null)
        saveRelayoutSubtreeRoot(relayoutSubtreeRoot);
      relayoutSubtreeRoot = relayoutSubtreeRoot == null ? this : relayoutSubtreeRoot;
      deltaTheta = constraints.constrainDeltaTheta(desiredDeltaTheta);
      assert(deltaTheta <= kTwoPi);
      _constraints = constraints;
      internalLayout(relayoutSubtreeRoot);
    }
  
    void relayout() {
      // TODO(ianh): avoid code duplication
      assert(parentData is SectorParentData);
      internalLayout(this);
    }
  
    void internalLayout(RenderNode relayoutSubtreeRoot) {
      assert(this.parentData is SectorParentData);
      double paddingTheta = math.atan(padding / this.parentData.radius);
      double innerTheta = this.parentData.theta + paddingTheta;
      double innerDeltaTheta = deltaTheta - paddingTheta * 2.0;
      double childRadius = this.parentData.radius + padding;
      double remainingDeltaRadius = _constraints.maxDeltaRadius - (padding * 2.0);
      RenderSector child = firstChild;
      while (child != null) {
        SectorConstraints innerConstraints = new SectorConstraints(
          maxDeltaRadius: remainingDeltaRadius,
          maxDeltaTheta: innerDeltaTheta
        );
        child.parentData.theta = innerTheta;
        child.parentData.radius = childRadius;
        child.layout(innerConstraints);
        childRadius += child.deltaRadius;
        remainingDeltaRadius -= child.deltaRadius;
        assert(child.parentData is SectorChildListParentData);
        child = child.parentData.nextSibling;
        childRadius += padding;
        remainingDeltaRadius -= padding;
      }
      deltaRadius = childRadius - this.parentData.radius;
    }
  
    // TODO(ianh): hit testing et al is pending on adam's patch
  
    // paint origin is 0,0 of our circle
    // each sector then knows how to paint itself at its location
    void paint(RenderNodeDisplayList canvas) {
      // TODO(ianh): avoid code duplication
      super.paint(canvas);
      RenderSector child = firstChild;
      while (child != null) {
  