Add @override annotation to known overriden methods

sky/sdk/lib/rendering/block.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 BlockParentData extends BoxParentData with ContainerParentDataMixin<RenderBox> { }
 
 abstract class RenderBlockBase extends RenderBox with ContainerRenderObjectMixin<RenderBox, BlockParentData>,
                                                       RenderBoxContainerDefaultsMixin<RenderBox, BlockParentData> {
 
   // lays out RenderBox children in a vertical stack
   // uses the maximum width provided by the parent
 
   RenderBlockBase({
     List<RenderBox> children
   }) {
     addAll(children);
   }
 
+  @override
   void setupParentData(RenderBox child) {
     if (child.parentData is! BlockParentData)
       child.parentData = new BlockParentData();
   }
 
   double _childrenHeight;
   double get childrenHeight => _childrenHeight;
 
+  @override
   void markNeedsLayout() {
     _childrenHeight = null;
     super.markNeedsLayout();
   }
 
+  @override
   void performLayout() {
     assert(constraints is BoxConstraints);
     double width = constraints.constrainWidth(constraints.maxWidth);
     BoxConstraints innerConstraints = new BoxConstraints.tightFor(width: width);
     double y = 0.0;
     RenderBox child = firstChild;
     while (child != null) {
       child.layout(innerConstraints, parentUsesSize: true);
       assert(child.parentData is BlockParentData);
       child.parentData.position = new Point(0.0, y);
       y += child.size.height;
       child = child.parentData.nextSibling;
     }
     _childrenHeight = y;
   }
 
 }
 
 class RenderBlock extends RenderBlockBase {
 
   // sizes itself to the height of its child stack
 
   RenderBlock({ List<RenderBox> children }) : super(children: children);
 
+  @override
   double getMinIntrinsicWidth(BoxConstraints constraints) {
     double width = 0.0;
     BoxConstraints innerConstraints = constraints.widthConstraints();
     RenderBox child = firstChild;
     while (child != null) {
       width = math.max(width, child.getMinIntrinsicWidth(innerConstraints));
       assert(child.parentData is BlockParentData);
       child = child.parentData.nextSibling;
     }
     return width;
   }
 
+  @override
   double getMaxIntrinsicWidth(BoxConstraints constraints) {
     double width = 0.0;
     BoxConstraints innerConstraints = constraints.widthConstraints();
     RenderBox child = firstChild;
     while (child != null) {
       width = math.max(width, child.getMaxIntrinsicWidth(innerConstraints));
       assert(child.parentData is BlockParentData);
       child = child.parentData.nextSibling;
     }
     return width;
   }
 
   double _getIntrinsicHeight(BoxConstraints constraints) {
     double height = 0.0;
     double width = constraints.constrainWidth(constraints.maxWidth);
     BoxConstraints innerConstraints = new BoxConstraints.tightFor(width: width);
     RenderBox child = firstChild;
     while (child != null) {
       double childHeight = child.getMinIntrinsicHeight(innerConstraints);
       assert(childHeight == child.getMaxIntrinsicHeight(innerConstraints));
       height += childHeight;
       assert(child.parentData is BlockParentData);
       child = child.parentData.nextSibling;
     }
     return height;
   }
 
+  @override
   double getMinIntrinsicHeight(BoxConstraints constraints) {
     return _getIntrinsicHeight(constraints);
   }
 
+  @override
   double getMaxIntrinsicHeight(BoxConstraints constraints) {
     return _getIntrinsicHeight(constraints);
   }
 
   double computeDistanceToActualBaseline(TextBaseline baseline) {
     return defaultComputeDistanceToFirstActualBaseline(baseline);
   }
 
   bool _hasVisualOverflow = false;
 
+  @override
   void performLayout() {
     super.performLayout();
     size = constraints.constrain(new Size(constraints.maxWidth, childrenHeight));
     assert(!size.isInfinite);
 
     // FIXME(eseidel): Block lays out its children with unconstrained height
     // yet itself remains constrained. Remember that our children wanted to
     // be taller than we are so we know to clip them (and not cause confusing
     // mismatch of painting vs. hittesting).
     _hasVisualOverflow = childrenHeight > size.height;
   }
 
+  @override
   void paint(PaintingCanvas canvas, Offset offset) {
     if (_hasVisualOverflow) {
       canvas.save();
       canvas.clipRect(offset & size);
     }
     defaultPaint(canvas, offset);
     if (_hasVisualOverflow) {
       canvas.restore();
     }
   }
@@ skipping 31 matching lines @@
   double _startOffset;
   double get startOffset => _startOffset;
   void set startOffset(double value) {
     if (value == _startOffset)
       return;
     _startOffset = value;
     if (!_inCallback)
       markNeedsPaint();
   }
 
+  @override
   double getMinIntrinsicWidth(BoxConstraints constraints) {
     return constraints.constrainWidth();
   }
 
+  @override
   double getMaxIntrinsicWidth(BoxConstraints constraints) {
     return constraints.constrainWidth();
   }
 
+  @override
   double getMinIntrinsicHeight(BoxConstraints constraints) {
     return constraints.constrainHeight();
   }
 
+  @override
   double getMaxIntrinsicHeight(BoxConstraints constraints) {
     return constraints.constrainHeight();
   }
 
   // We don't override computeDistanceToActualBaseline(), because we
   // want the default behaviour (returning null). Otherwise, as you
   // scroll the RenderBlockViewport, it would shift in its parent if
   // the parent was baseline-aligned, which makes no sense.
 
+  @override
   bool get sizedByParent => true;
 
+  @override
   void performResize() {
     size = constraints.biggest;
     assert(!size.isInfinite);
   }
 
   bool get debugDoesLayoutWithCallback => true;
+
+  @override
   void performLayout() {
     if (_callback != null) {
       try {
         _inCallback = true;
         invokeLayoutCallback(_callback);
       } finally {
         _inCallback = false;
       }
     }
     super.performLayout();
   }
 
+  @override
   void paint(PaintingCanvas canvas, Offset offset) {
     canvas.save();
     canvas.clipRect(offset & size);
     defaultPaint(canvas, offset.translate(0.0, startOffset));
     canvas.restore();
   }
 
+  @override
   void hitTestChildren(HitTestResult result, { Point position }) {
     defaultHitTestChildren(result, position: position + new Offset(0.0, -startOffset));
   }
 
 }