Add @override annotation to known overriden methods

sky/sdk/lib/widgets/block_viewport.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 '../rendering/block.dart';
 import '../rendering/box.dart';
 import '../rendering/object.dart';
 import 'widget.dart';
 
 // return null if index is greater than index of last entry
 typedef Widget IndexedBuilder(int index);
 
 class _Key {
   const _Key(this.type, this.key);
   factory _Key.fromWidget(Widget widget) => new _Key(widget.runtimeType, widget.key);
   final Type type;
   final String key;
+
+  @override
   bool operator ==(other) => other is _Key && other.type == type && other.key == key;
+
+  @override
   int get hashCode => 373 * 37 * type.hashCode + key.hashCode;
 }
 
 class BlockViewport extends RenderObjectWrapper {
   BlockViewport({ this.builder, this.startOffset, this.token, String key })
     : super(key: key);
 
   IndexedBuilder builder;
   double startOffset;
   Object token;
 
+  @override
   RenderBlockViewport get root => super.root;
+
+  @override
   RenderBlockViewport createNode() => new RenderBlockViewport();
 
-  Map<_Key, Widget> _childrenByKey = new Map<_Key, Widget>();  
+  Map<_Key, Widget> _childrenByKey = new Map<_Key, Widget>();
 
   void walkChildren(WidgetTreeWalker walker) {
     for (Widget child in _childrenByKey.values)
       walker(child);
   }
 
   static const _omit = const Object(); // used as a slot when it's not yet time to attach the child
 
+  @override
   void insertChildRoot(RenderObjectWrapper child, dynamic slot) {
     if (slot == _omit)
       return;
     final root = this.root; // TODO(ianh): Remove this once the analyzer is cleverer
     assert(slot == null || slot is RenderObject);
     assert(root is ContainerRenderObjectMixin);
     root.add(child.root, before: slot);
     assert(root == this.root); // TODO(ianh): Remove this once the analyzer is cleverer
   }
 
   void detachChildRoot(RenderObjectWrapper child) {
     final root = this.root; // TODO(ianh): Remove this once the analyzer is cleverer
     assert(root is ContainerRenderObjectMixin);
     if (child.root.parent != root)
       return; // probably had slot == _omit when inserted
     root.remove(child.root);
     assert(root == this.root); // TODO(ianh): Remove this once the analyzer is cleverer
   }
 
+  @override
   void remove() {
     for (Widget child in _childrenByKey.values) {
       assert(child != null);
       removeChild(child);
     }
     super.remove();
   }
 
+  @override
   void didMount() {
     root.callback = layout;
     super.didMount();
   }
 
+  @override
   void didUnmount() {
     root.callback = null;
     super.didUnmount();
   }
 
   // _offsets contains the offsets of each child from the top of the
   // list up to the last one we've ever created, and the offset of the
   // end of the last one. If there's no children, then the only offset
   // is 0.0.
   List<double> _offsets = <double>[0.0];
 
   int _findIndexForOffsetBeforeOrAt(double offset) {
     int left = 0;
     int right = _offsets.length - 1;
     while (right >= left) {
       int middle = left + ((right - left) ~/ 2);
       if (_offsets[middle] < offset) {
         left = middle + 1;
       } else if (_offsets[middle] > offset) {
         right = middle - 1;
       } else {
         return middle;
       }
     }
     return right;
   }
 
   bool _dirty = false;
 
+  @override
   bool retainStatefulNodeIfPossible(BlockViewport newNode) {
     retainStatefulRenderObjectWrapper(newNode);
     if (startOffset != newNode.startOffset) {
       _dirty = true;
       startOffset = newNode.startOffset;
     }
     if (token != newNode.token || builder != newNode.builder) {
       _dirty = true;
       builder = newNode.builder;
       token = newNode.token;
       _offsets = <double>[0.0];
     }
     return true;
   }
 
+  @override
   void syncRenderObject(BlockViewport old) {
     super.syncRenderObject(old);
     if (_dirty)
       root.markNeedsLayout();
   }
 
   Widget _getWidget(int index, BoxConstraints innerConstraints) {
     LayoutCallbackBuilderHandle handle = enterLayoutCallbackBuilder();
     try {
       assert(index >= 0);
@@ skipping 122 matching lines @@
         index -= 1;
         Widget widget = builtChildren[index];
         if (widget.root.parent == root) {
           root.move(widget.root, before: nextSibling);
         } else {
           assert(widget.root.parent == null);
           root.add(widget.root, before: nextSibling);
         }
         widget.updateSlot(nextSibling);
         nextSibling = widget.root;
-      }      
+      }
     }
 
     _childrenByKey = newChildren;
   }
 
 }