Add @override annotation to known overriden methods

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> {
   int flex;
 
+  @override
   void merge(FlexBoxParentData other) {
     if (other.flex != null)
       flex = other.flex;
     super.merge(other);
   }
 
+  @override
   String toString() => '${super.toString()}; flex=$flex';
 }
 
 enum FlexDirection { horizontal, vertical }
 
 enum FlexJustifyContent {
   flexStart,
   flexEnd,
   center,
   spaceBetween,
@@ skipping 38 matching lines @@
 
   FlexAlignItems _alignItems;
   FlexAlignItems get alignItems => _alignItems;
   void set alignItems (FlexAlignItems value) {
     if (_alignItems != value) {
       _alignItems = value;
       markNeedsLayout();
     }
   }
 
+  @override
   void setupParentData(RenderBox child) {
     if (child.parentData is! FlexBoxParentData)
       child.parentData = new FlexBoxParentData();
   }
 
   double _getIntrinsicSize({ BoxConstraints constraints,
                              FlexDirection sizingDirection,
                              _ChildSizingFunction childSize }) {
     // http://www.w3.org/TR/2015/WD-css-flexbox-1-20150514/#intrinsic-sizes
     if (_direction == sizingDirection) {
@@ skipping 65 matching lines @@
       RenderBox child = firstChild;
       while (child != null) {
         int flex = _getFlex(child);
         totalFlex += flex;
         double mainSize;
         double crossSize;
         if (flex == 0) {
           switch (_direction) {
               case FlexDirection.horizontal:
                 mainSize = child.getMaxIntrinsicWidth(childConstraints);
-                BoxConstraints widthConstraints = 
+                BoxConstraints widthConstraints =
                   new BoxConstraints(minWidth: mainSize, maxWidth: mainSize);
                 crossSize = child.getMaxIntrinsicHeight(widthConstraints);
                 break;
               case FlexDirection.vertical:
                 mainSize = child.getMaxIntrinsicHeight(childConstraints);
-                BoxConstraints heightConstraints = 
+                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 = 
+              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);
       }
     }
   }
 
+  @override
   double getMinIntrinsicWidth(BoxConstraints constraints) {
     return _getIntrinsicSize(
       constraints: constraints,
       sizingDirection: FlexDirection.horizontal,
       childSize: (c, innerConstraints) => c.getMinIntrinsicWidth(innerConstraints)
     );
   }
 
+  @override
   double getMaxIntrinsicWidth(BoxConstraints constraints) {
     return _getIntrinsicSize(
       constraints: constraints,
       sizingDirection: FlexDirection.horizontal,
       childSize: (c, innerConstraints) => c.getMaxIntrinsicWidth(innerConstraints)
     );
   }
 
+  @override
   double getMinIntrinsicHeight(BoxConstraints constraints) {
     return _getIntrinsicSize(
       constraints: constraints,
       sizingDirection: FlexDirection.vertical,
       childSize: (c, innerConstraints) => c.getMinIntrinsicHeight(innerConstraints)
     );
   }
 
+  @override
   double getMaxIntrinsicHeight(BoxConstraints constraints) {
     return _getIntrinsicSize(
       constraints: constraints,
       sizingDirection: FlexDirection.vertical,
       childSize: (c, innerConstraints) => c.getMaxIntrinsicHeight(innerConstraints));
   }
 
+  @override
   double computeDistanceToActualBaseline(TextBaseline baseline) {
     if (_direction == FlexDirection.horizontal)
       return defaultComputeDistanceToHighestActualBaseline(baseline);
     return defaultComputeDistanceToFirstActualBaseline(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;
   }
 
+  @override
   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;
@@ skipping 104 matching lines @@
           break;
         case FlexDirection.vertical:
           child.parentData.position = new Point(childCrossPosition, childMainPosition);
           break;
       }
       childMainPosition += _getMainSize(child) + betweenSpace;
       child = child.parentData.nextSibling;
     }
   }
 
+  @override
   void hitTestChildren(HitTestResult result, { Point position }) {
     defaultHitTestChildren(result, position: position);
   }
 
+  @override
   void paint(PaintingCanvas canvas, Offset offset) {
     defaultPaint(canvas, offset);
   }
 }