Standardize usage of virtual/override/final specifiers.

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 void GetHorizontalIconMargins(int id,
-                                        int icon_size,
-                                        int* left_margin,
-                                        int* right_margin) const override;
-  virtual bool GetForegroundColor(int command_id,
-                                  bool is_hovered,
-                                  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;
+  const gfx::FontList* GetLabelFontList(int command_id) const override;
+  bool IsCommandEnabled(int id) const override;
+  void GetHorizontalIconMargins(int id,
+                                int icon_size,
+                                int* left_margin,
+                                int* right_margin) const override;
+  bool GetForegroundColor(int command_id,
+                          bool is_hovered,
+                          SkColor* override_color) const override;
+  bool GetBackgroundColor(int command_id,
+                          bool is_hovered,
+                          SkColor* override_color) const override;
+  int GetMaxWidthForMenu(views::MenuItemView* menu) override;
+  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 50 matching lines @@
   return false;
 }
 
 // Custom FocusSearch used to navigate the shelf in the order items are in
 // the ViewModel.
 class ShelfFocusSearch : public views::FocusSearch {
  public:
   explicit ShelfFocusSearch(views::ViewModel* view_model)
       : FocusSearch(NULL, true, true),
         view_model_(view_model) {}
-  virtual ~ShelfFocusSearch() {}
+  ~ShelfFocusSearch() override {}
 
   // 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* FindNextFocusableView(View* starting_view,
+                              bool reverse,
+                              Direction direction,
+                              bool check_starting_view,
+                              views::FocusTraversable** focus_traversable,
+                              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;
       if (index >= view_model_->view_size())
         index = 0;
     }
     return view_model_->view_at(index);
   }
 
  private:
   views::ViewModel* view_model_;
 
   DISALLOW_COPY_AND_ASSIGN(ShelfFocusSearch);
 };
 
 // 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() {}
+  ~FadeInAnimationDelegate() override {}
 
   // AnimationDelegate overrides:
-  virtual void AnimationProgressed(const Animation* animation) override {
+  void AnimationProgressed(const Animation* animation) override {
     view_->layer()->SetOpacity(animation->GetCurrentValue());
     view_->layer()->ScheduleDraw();
   }
-  virtual void AnimationEnded(const Animation* animation) override {
+  void AnimationEnded(const Animation* animation) override {
     view_->layer()->SetOpacity(1.0f);
     view_->layer()->ScheduleDraw();
   }
-  virtual void AnimationCanceled(const Animation* animation) override {
+  void AnimationCanceled(const Animation* animation) override {
     view_->layer()->SetOpacity(1.0f);
     view_->layer()->ScheduleDraw();
   }
 
  private:
   views::View* view_;
 
   DISALLOW_COPY_AND_ASSIGN(FadeInAnimationDelegate);
 };
 
@@ skipping 24 matching lines @@
 
 }  // namespace
 
 // 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() {}
+  ~FadeOutAnimationDelegate() override {}
 
   // AnimationDelegate overrides:
-  virtual void AnimationProgressed(const Animation* animation) override {
+  void AnimationProgressed(const Animation* animation) override {
     view_->layer()->SetOpacity(1 - animation->GetCurrentValue());
     view_->layer()->ScheduleDraw();
   }
-  virtual void AnimationEnded(const Animation* animation) override {
+  void AnimationEnded(const Animation* animation) override {
     shelf_view_->OnFadeOutAnimationEnded();
   }
-  virtual void AnimationCanceled(const Animation* animation) override {
-  }
+  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() {}
+  ~StartFadeAnimationDelegate() override {}
 
   // AnimationDelegate overrides:
-  virtual void AnimationEnded(const Animation* animation) override {
+  void AnimationEnded(const Animation* animation) override {
     shelf_view_->FadeIn(view_);
   }
-  virtual void AnimationCanceled(const Animation* animation) override {
+  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