Add @override annotation to known overriden methods

sky/sdk/lib/widgets/tabs.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 'package:sky/animation/generators.dart';
 import 'package:sky/animation/mechanics.dart';
 import 'package:sky/animation/scroll_behavior.dart';
 import 'package:sky/painting/text_style.dart';
@@ skipping 70 matching lines @@
 
   bool _scrollable;
   bool get scrollable => _scrollable;
   void set scrollable(bool value) {
     if (_scrollable != value) {
       _scrollable = value;
       markNeedsLayout();
     }
   }
 
+  @override
   void setupParentData(RenderBox child) {
     if (child.parentData is! TabBarParentData)
       child.parentData = new TabBarParentData();
   }
 
+  @override
   double getMinIntrinsicWidth(BoxConstraints constraints) {
     BoxConstraints widthConstraints =
         new BoxConstraints(maxWidth: constraints.maxWidth, maxHeight: constraints.maxHeight);
 
     double maxWidth = 0.0;
     RenderBox child = firstChild;
     while (child != null) {
       maxWidth = math.max(maxWidth, child.getMinIntrinsicWidth(widthConstraints));
       assert(child.parentData is TabBarParentData);
       child = child.parentData.nextSibling;
     }
     double width = scrollable ? maxWidth : maxWidth * childCount;
     return constraints.constrainWidth(width);
   }
 
+  @override
   double getMaxIntrinsicWidth(BoxConstraints constraints) {
     BoxConstraints widthConstraints =
         new BoxConstraints(maxWidth: constraints.maxWidth, maxHeight: constraints.maxHeight);
 
     double maxWidth = 0.0;
     RenderBox child = firstChild;
     while (child != null) {
       maxWidth = math.max(maxWidth, child.getMaxIntrinsicWidth(widthConstraints));
       assert(child.parentData is TabBarParentData);
       child = child.parentData.nextSibling;
     }
     double width = scrollable ? maxWidth : maxWidth * childCount;
     return constraints.constrainWidth(width);
   }
 
   double get _tabBarHeight {
     return (textAndIcons ? _kTextAndIconTabHeight : _kTabHeight) + _kTabIndicatorHeight;
   }
 
   double _getIntrinsicHeight(BoxConstraints constraints) => constraints.constrainHeight(_tabBarHeight);
 
+  @override
   double getMinIntrinsicHeight(BoxConstraints constraints) => _getIntrinsicHeight(constraints);
 
+  @override
   double getMaxIntrinsicHeight(BoxConstraints constraints) => _getIntrinsicHeight(constraints);
 
   void layoutFixedWidthTabs() {
     double tabWidth = size.width / childCount;
     BoxConstraints tabConstraints =
       new BoxConstraints.tightFor(width: tabWidth, height: size.height);
     double x = 0.0;
     RenderBox child = firstChild;
     while (child != null) {
       child.layout(tabConstraints);
@@ skipping 40 matching lines @@
       }
       assert(childIndex == widths.length);
     }
     if (size != layoutSize || widths != layoutWidths) {
       layoutSize = size;
       layoutWidths = widths;
       onLayoutChanged(layoutSize, layoutWidths);
     }
   }
 
+  @override
   void performLayout() {
     assert(constraints is BoxConstraints);
 
     size = constraints.constrain(new Size(constraints.maxWidth, _tabBarHeight));
     assert(!size.isInfinite);
 
     if (childCount == 0)
       return;
 
     if (scrollable)
       layoutScrollableTabs();
     else
       layoutFixedWidthTabs();
 
     if (onLayoutChanged != null)
       reportLayoutChangedIfNeeded();
   }
 
+  @override
   void hitTestChildren(HitTestResult result, { Point position }) {
     defaultHitTestChildren(result, position: position);
   }
 
   void _paintIndicator(PaintingCanvas canvas, RenderBox selectedTab, Offset offset) {
     if (indicatorColor == null)
       return;
 
     var size = new Size(selectedTab.size.width, _kTabIndicatorHeight);
     var point = new Point(
       selectedTab.parentData.position.x,
       _tabBarHeight - _kTabIndicatorHeight
     );
     Rect rect = (point + offset) & size;
     canvas.drawRect(rect, new Paint()..color = indicatorColor);
   }
 
+  @override
   void paint(PaintingCanvas canvas, Offset offset) {
     if (backgroundColor != null) {
-      double width = layoutWidths != null 
+      double width = layoutWidths != null
         ? layoutWidths.reduce((sum, width) => sum + width)
         : size.width;
       Rect rect = offset & new Size(width, size.height);
       canvas.drawRect(rect, new Paint()..color = backgroundColor);
     }
 
     int index = 0;
     RenderBox child = firstChild;
     while (child != null) {
       assert(child.parentData is TabBarParentData);
       canvas.paintChild(child, child.parentData.position + offset);
       if (index++ == selectedIndex)
         _paintIndicator(canvas, child, offset);
       child = child.parentData.nextSibling;
     }
   }
 }
 
 class TabBarWrapper extends MultiChildRenderObjectWrapper {
   TabBarWrapper({
     List<Widget> children,
     this.selectedIndex,
     this.backgroundColor,
     this.indicatorColor,
     this.textAndIcons,
     this.scrollable: false,
     this.onLayoutChanged,
-    String key 
+    String key
   }) : super(key: key, children: children);
 
   final int selectedIndex;
   final Color backgroundColor;
   final Color indicatorColor;
-  final bool textAndIcons; 
+  final bool textAndIcons;
   final bool scrollable;
   final LayoutChanged onLayoutChanged;
 
+  @override
   RenderTabBar get root => super.root;
+
+  @override
   RenderTabBar createNode() => new RenderTabBar(onLayoutChanged);
 
+  @override
   void syncRenderObject(Widget old) {
     super.syncRenderObject(old);
     root.selectedIndex = selectedIndex;
     root.backgroundColor = backgroundColor;
     root.indicatorColor = indicatorColor;
     root.textAndIcons = textAndIcons;
     root.scrollable = scrollable;
     root.onLayoutChanged = onLayoutChanged;
   }
 }
@@ skipping 21 matching lines @@
     assert(label.text != null);
     TextStyle textStyle = Theme.of(this).toolbarText.button.merge(_kTabTextStyle);
     return new Text(label.text, style: textStyle);
   }
 
   Widget _buildLabelIcon() {
     assert(label.icon != null);
     return new Icon(type: label.icon, size: _kTabIconSize);
   }
 
+  @override
   Widget build() {
     Widget labelContents;
     if (label.icon == null) {
       labelContents = _buildLabelText();
     } else if (label.text == null) {
       labelContents = _buildLabelIcon();
     } else {
       labelContents = new Flex(
         <Widget>[
           new Container(
             child: _buildLabelIcon(),
             margin: const EdgeDims.only(bottom: 10.0)
           ),
           _buildLabelText()
-        ], 
+        ],
         justifyContent: FlexJustifyContent.center,
         alignItems: FlexAlignItems.center,
         direction: FlexDirection.vertical
       );
     }
 
     Widget highlightedLabel = new Opacity(
-      child: labelContents, 
+      child: labelContents,
       opacity: selected ? 1.0 : 0.7
     );
 
     Container centeredLabel = new Container(
       child: new Center(child: highlightedLabel),
       constraints: new BoxConstraints(minWidth: _kMinTabWidth),
       padding: _kTabLabelPadding
     );
 
     return new InkWell(child: centeredLabel);
   }
 }
 
 class TabBarScrollBehavior extends ScrollBehavior {
   TabBarScrollBehavior({ this.maxScrollOffset: 0.0 });
 
   double maxScrollOffset;
 
+  @override
   Simulation release(Particle particle) {
     if (particle.velocity == 0.0 || particle.position < 0.0 || particle.position >= maxScrollOffset)
       return null;
 
     System system = new ParticleInBoxWithFriction(
       particle: particle,
       friction: _kTabBarScrollFriction,
       box: new ClosedBox(min: 0.0, max: maxScrollOffset));
     return new Simulation(system, terminationCondition: () => particle.position == 0.0);
   }
 
+  @override
   double applyCurve(double scrollOffset, double scrollDelta) {
     return (scrollOffset + scrollDelta).clamp(0.0, maxScrollOffset);
   }
 }
 
 class TabBar extends Scrollable {
   TabBar({
     String key,
     this.labels,
     this.selectedIndex: 0,
     this.onChanged,
     this.scrollable: false
   }) : super(key: key, direction: ScrollDirection.horizontal);
 
   Iterable<TabLabel> labels;
   int selectedIndex;
   SelectedIndexChanged onChanged;
   bool scrollable;
 
+  @override
   void syncFields(TabBar source) {
     super.syncFields(source);
     labels = source.labels;
     selectedIndex = source.selectedIndex;
     onChanged = source.onChanged;
     scrollable = source.scrollable;
     if (!scrollable)
       scrollTo(0.0);
   }
 
+  @override
   ScrollBehavior createScrollBehavior() => new TabBarScrollBehavior();
+
+  @override
   TabBarScrollBehavior get scrollBehavior => super.scrollBehavior;
 
   void _handleTap(int tabIndex) {
     if (tabIndex != selectedIndex && onChanged != null)
       onChanged(tabIndex);
   }
 
   Widget _toTab(TabLabel label, int tabIndex) {
     Tab tab = new Tab(
       label: label,
@@ skipping 11 matching lines @@
 
   void _layoutChanged(Size tabBarSize, List<double> tabWidths) {
     setState(() {
       _tabBarSize = tabBarSize;
       _tabWidths = tabWidths;
       scrollBehavior.maxScrollOffset =
         _tabWidths.reduce((sum, width) => sum + width) - _tabBarSize.width;
     });
   }
 
+  @override
   Widget buildContent() {
     assert(labels != null && labels.isNotEmpty);
     List<Widget> tabs = <Widget>[];
     bool textAndIcons = false;
     int tabIndex = 0;
     for (TabLabel label in labels) {
       tabs.add(_toTab(label, tabIndex++));
       if (label.text != null && label.icon != null)
         textAndIcons = true;
     }
 
     Color backgroundColor = Theme.of(this).primaryColor;
     Color indicatorColor = Theme.of(this).accentColor;
     if (indicatorColor == backgroundColor) {
       indicatorColor = colors.White;
     }
 
     TabBarWrapper tabBarWrapper = new TabBarWrapper(
-      children: tabs, 
+      children: tabs,
       selectedIndex: selectedIndex,
       backgroundColor: backgroundColor,
       indicatorColor: indicatorColor,
       textAndIcons: textAndIcons,
       scrollable: scrollable,
       onLayoutChanged: scrollable ? _layoutChanged : null
     );
 
     Matrix4 transform = new Matrix4.identity();
     transform.translate(-scrollOffset, 0.0);
@@ skipping 27 matching lines @@
   final List<TabNavigatorView> views;
   final int selectedIndex;
   final SelectedIndexChanged onChanged;
   final bool scrollable;
 
   void _handleSelectedIndexChanged(int tabIndex) {
     if (onChanged != null)
       onChanged(tabIndex);
   }
 
+  @override
   Widget build() {
     assert(views != null && views.isNotEmpty);
     assert(selectedIndex >= 0 && selectedIndex < views.length);
 
     TabBar tabBar = new TabBar(
       labels: views.map((view) => view.label),
       onChanged: _handleSelectedIndexChanged,
       selectedIndex: selectedIndex,
       scrollable: scrollable
     );
 
     Widget content = views[selectedIndex].buildContent();
     return new Flex([tabBar, new Flexible(child: content)],
       direction: FlexDirection.vertical
     );
   }
 }