replace OVERRIDE and FINAL with override and final in ash/

ash/shelf/shelf_view.cc

 // Copyright (c) 2012 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.
 
 #include "ash/shelf/shelf_view.h"
 
 #include <algorithm>
 
 #include "ash/ash_constants.h"
 #include "ash/ash_switches.h"
@@ skipping 123 matching lines @@
   DISALLOW_COPY_AND_ASSIGN(BoundsAnimatorDisabler);
 };
 
 // The MenuModelAdapter gets slightly changed to adapt the menu appearance to
 // our requirements.
 class ShelfMenuModelAdapter : public views::MenuModelAdapter {
  public:
   explicit ShelfMenuModelAdapter(ShelfMenuModel* menu_model);
 
   // views::MenuModelAdapter:
-  virtual const gfx::FontList* GetLabelFontList(int command_id) const OVERRIDE;
-  virtual bool IsCommandEnabled(int id) const OVERRIDE;
+  virtual const gfx::FontList* GetLabelFontList(int command_id) const override;
+  virtual bool IsCommandEnabled(int id) const override;
   virtual void GetHorizontalIconMargins(int id,
                                         int icon_size,
                                         int* left_margin,
-                                        int* right_margin) const OVERRIDE;
+                                        int* right_margin) const override;
   virtual bool GetForegroundColor(int command_id,
                                   bool is_hovered,
-                                  SkColor* override_color) const OVERRIDE;
+                                  SkColor* override_color) const override;
   virtual bool GetBackgroundColor(int command_id,
                                   bool is_hovered,
-                                  SkColor* override_color) const OVERRIDE;
-  virtual int GetMaxWidthForMenu(views::MenuItemView* menu) OVERRIDE;
-  virtual bool ShouldReserveSpaceForSubmenuIndicator() const OVERRIDE;
+                                  SkColor* override_color) const override;
+  virtual int GetMaxWidthForMenu(views::MenuItemView* menu) override;
+  virtual bool ShouldReserveSpaceForSubmenuIndicator() const override;
 
  private:
   ShelfMenuModel* menu_model_;
 
   DISALLOW_COPY_AND_ASSIGN(ShelfMenuModelAdapter);
 };
 
 ShelfMenuModelAdapter::ShelfMenuModelAdapter(ShelfMenuModel* menu_model)
     : MenuModelAdapter(menu_model),
       menu_model_(menu_model) {
@@ skipping 59 matching lines @@
         view_model_(view_model) {}
   virtual ~ShelfFocusSearch() {}
 
   // views::FocusSearch overrides:
   virtual View* FindNextFocusableView(
       View* starting_view,
       bool reverse,
       Direction direction,
       bool check_starting_view,
       views::FocusTraversable** focus_traversable,
-      View** focus_traversable_view) OVERRIDE {
+      View** focus_traversable_view) override {
     int index = view_model_->GetIndexOfView(starting_view);
     if (index == -1)
       return view_model_->view_at(0);
 
     if (reverse) {
       --index;
       if (index < 0)
         index = view_model_->view_size() - 1;
     } else {
       ++index;
@@ skipping 10 matching lines @@
 };
 
 // AnimationDelegate used when inserting a new item. This steadily increases the
 // opacity of the layer as the animation progress.
 class FadeInAnimationDelegate : public gfx::AnimationDelegate {
  public:
   explicit FadeInAnimationDelegate(views::View* view) : view_(view) {}
   virtual ~FadeInAnimationDelegate() {}
 
   // AnimationDelegate overrides:
-  virtual void AnimationProgressed(const Animation* animation) OVERRIDE {
+  virtual void AnimationProgressed(const Animation* animation) override {
     view_->layer()->SetOpacity(animation->GetCurrentValue());
     view_->layer()->ScheduleDraw();
   }
-  virtual void AnimationEnded(const Animation* animation) OVERRIDE {
+  virtual void AnimationEnded(const Animation* animation) override {
     view_->layer()->SetOpacity(1.0f);
     view_->layer()->ScheduleDraw();
   }
-  virtual void AnimationCanceled(const Animation* animation) OVERRIDE {
+  virtual void AnimationCanceled(const Animation* animation) override {
     view_->layer()->SetOpacity(1.0f);
     view_->layer()->ScheduleDraw();
   }
 
  private:
   views::View* view_;
 
   DISALLOW_COPY_AND_ASSIGN(FadeInAnimationDelegate);
 };
 
@@ skipping 27 matching lines @@
 // AnimationDelegate used when deleting an item. This steadily decreased the
 // opacity of the layer as the animation progress.
 class ShelfView::FadeOutAnimationDelegate : public gfx::AnimationDelegate {
  public:
   FadeOutAnimationDelegate(ShelfView* host, views::View* view)
       : shelf_view_(host),
         view_(view) {}
   virtual ~FadeOutAnimationDelegate() {}
 
   // AnimationDelegate overrides:
-  virtual void AnimationProgressed(const Animation* animation) OVERRIDE {
+  virtual void AnimationProgressed(const Animation* animation) override {
     view_->layer()->SetOpacity(1 - animation->GetCurrentValue());
     view_->layer()->ScheduleDraw();
   }
-  virtual void AnimationEnded(const Animation* animation) OVERRIDE {
+  virtual void AnimationEnded(const Animation* animation) override {
     shelf_view_->OnFadeOutAnimationEnded();
   }
-  virtual void AnimationCanceled(const Animation* animation) OVERRIDE {
+  virtual void AnimationCanceled(const Animation* animation) override {
   }
 
  private:
   ShelfView* shelf_view_;
   scoped_ptr<views::View> view_;
 
   DISALLOW_COPY_AND_ASSIGN(FadeOutAnimationDelegate);
 };
 
 // AnimationDelegate used to trigger fading an element in. When an item is
 // inserted this delegate is attached to the animation that expands the size of
 // the item.  When done it kicks off another animation to fade the item in.
 class ShelfView::StartFadeAnimationDelegate : public gfx::AnimationDelegate {
  public:
   StartFadeAnimationDelegate(ShelfView* host,
                              views::View* view)
       : shelf_view_(host),
         view_(view) {}
   virtual ~StartFadeAnimationDelegate() {}
 
   // AnimationDelegate overrides:
-  virtual void AnimationEnded(const Animation* animation) OVERRIDE {
+  virtual void AnimationEnded(const Animation* animation) override {
     shelf_view_->FadeIn(view_);
   }
-  virtual void AnimationCanceled(const Animation* animation) OVERRIDE {
+  virtual void AnimationCanceled(const Animation* animation) override {
     view_->layer()->SetOpacity(1.0f);
   }
 
  private:
   ShelfView* shelf_view_;
   views::View* view_;
 
   DISALLOW_COPY_AND_ASSIGN(StartFadeAnimationDelegate);
 };
 
@@ skipping 1560 matching lines @@
       distance = bounds.x() - coordinate.x();
       break;
     case SHELF_ALIGNMENT_TOP:
       distance = coordinate.y() - bounds.bottom();
       break;
   }
   return distance > 0 ? distance : 0;
 }
 
 }  // namespace ash