Standardize usage of virtual/override/final specifiers.

ash/shelf/shelf_view.h

 // 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.
 
 #ifndef ASH_SHELF_SHELF_VIEW_H_
 #define ASH_SHELF_SHELF_VIEW_H_
 
 #include <utility>
 #include <vector>
 
@@ skipping 45 matching lines @@
                              public views::ButtonListener,
                              public ShelfButtonHost,
                              public views::ContextMenuController,
                              public views::FocusTraversable,
                              public views::BoundsAnimatorObserver,
                              public app_list::ApplicationDragAndDropHost {
  public:
   ShelfView(ShelfModel* model,
             ShelfDelegate* delegate,
             ShelfLayoutManager* manager);
-  virtual ~ShelfView();
+  ~ShelfView() override;
 
   ShelfTooltipManager* tooltip_manager() { return tooltip_.get(); }
 
   ShelfLayoutManager* shelf_layout_manager() { return layout_manager_; }
 
   ShelfModel* model() { return model_; }
 
   void Init();
 
   void OnShelfAlignmentChanged();
@@ skipping 28 matching lines @@
   // There are thin gaps between launcher buttons but the tooltip shouldn't hide
   // in the gaps, but the tooltip should hide if the mouse moved totally outside
   // of the buttons area.
   bool ShouldHideTooltip(const gfx::Point& cursor_location);
 
   // Returns rectangle bounding all visible launcher items. Used screen
   // coordinate system.
   gfx::Rect GetVisibleItemsBoundsInScreen();
 
   // Overridden from FocusTraversable:
-  virtual views::FocusSearch* GetFocusSearch() override;
-  virtual FocusTraversable* GetFocusTraversableParent() override;
-  virtual View* GetFocusTraversableParentView() override;
+  views::FocusSearch* GetFocusSearch() override;
+  FocusTraversable* GetFocusTraversableParent() override;
+  View* GetFocusTraversableParentView() override;
 
   // Overridden from app_list::ApplicationDragAndDropHost:
-  virtual void CreateDragIconProxy(
-      const gfx::Point& location_in_screen_coordinates,
-      const gfx::ImageSkia& icon,
-      views::View* replaced_view,
-      const gfx::Vector2d& cursor_offset_from_center,
-      float scale_factor) override;
-  virtual void UpdateDragIconProxy(
+  void CreateDragIconProxy(const gfx::Point& location_in_screen_coordinates,
+                           const gfx::ImageSkia& icon,
+                           views::View* replaced_view,
+                           const gfx::Vector2d& cursor_offset_from_center,
+                           float scale_factor) override;
+  void UpdateDragIconProxy(
       const gfx::Point& location_in_screen_coordinates) override;
-  virtual void DestroyDragIconProxy() override;
-  virtual bool StartDrag(
-      const std::string& app_id,
-      const gfx::Point& location_in_screen_coordinates) override;
-  virtual bool Drag(const gfx::Point& location_in_screen_coordinates) override;
-  virtual void EndDrag(bool cancel) override;
+  void DestroyDragIconProxy() override;
+  bool StartDrag(const std::string& app_id,
+                 const gfx::Point& location_in_screen_coordinates) override;
+  bool Drag(const gfx::Point& location_in_screen_coordinates) override;
+  void EndDrag(bool cancel) override;
 
   // Return the view model for test purposes.
   const views::ViewModel* view_model_for_test() const {
     return view_model_.get();
   }
 
  private:
   friend class ash::test::ShelfViewTestAPI;
 
   class FadeOutAnimationDelegate;
@@ skipping 94 matching lines @@
   // Invoked after the fading out animation for item deletion is ended.
   void OnFadeOutAnimationEnded();
 
   // Fade in last visible item.
   void StartFadeInLastVisibleItem();
 
   // Updates the visible range of overflow items in |overflow_view|.
   void UpdateOverflowRange(ShelfView* overflow_view) const;
 
   // Overridden from views::View:
-  virtual gfx::Size GetPreferredSize() const override;
-  virtual void OnBoundsChanged(const gfx::Rect& previous_bounds) override;
-  virtual FocusTraversable* GetPaneFocusTraversable() override;
-  virtual void GetAccessibleState(ui::AXViewState* state) override;
+  gfx::Size GetPreferredSize() const override;
+  void OnBoundsChanged(const gfx::Rect& previous_bounds) override;
+  FocusTraversable* GetPaneFocusTraversable() override;
+  void GetAccessibleState(ui::AXViewState* state) override;
 
   // Overridden from ui::EventHandler:
-  virtual void OnGestureEvent(ui::GestureEvent* event) override;
+  void OnGestureEvent(ui::GestureEvent* event) override;
 
   // Overridden from ShelfModelObserver:
-  virtual void ShelfItemAdded(int model_index) override;
-  virtual void ShelfItemRemoved(int model_index, ShelfID id) override;
-  virtual void ShelfItemChanged(int model_index,
-                                const ShelfItem& old_item) override;
-  virtual void ShelfItemMoved(int start_index, int target_index) override;
-  virtual void ShelfStatusChanged() override;
+  void ShelfItemAdded(int model_index) override;
+  void ShelfItemRemoved(int model_index, ShelfID id) override;
+  void ShelfItemChanged(int model_index, const ShelfItem& old_item) override;
+  void ShelfItemMoved(int start_index, int target_index) override;
+  void ShelfStatusChanged() override;
 
   // Overridden from ShelfButtonHost:
-  virtual void PointerPressedOnButton(views::View* view,
-                                      Pointer pointer,
-                                      const ui::LocatedEvent& event) override;
-  virtual void PointerDraggedOnButton(views::View* view,
-                                      Pointer pointer,
-                                      const ui::LocatedEvent& event) override;
-  virtual void PointerReleasedOnButton(views::View* view,
-                                       Pointer pointer,
-                                       bool canceled) override;
-  virtual void MouseMovedOverButton(views::View* view) override;
-  virtual void MouseEnteredButton(views::View* view) override;
-  virtual void MouseExitedButton(views::View* view) override;
-  virtual base::string16 GetAccessibleName(const views::View* view) override;
+  void PointerPressedOnButton(views::View* view,
+                              Pointer pointer,
+                              const ui::LocatedEvent& event) override;
+  void PointerDraggedOnButton(views::View* view,
+                              Pointer pointer,
+                              const ui::LocatedEvent& event) override;
+  void PointerReleasedOnButton(views::View* view,
+                               Pointer pointer,
+                               bool canceled) override;
+  void MouseMovedOverButton(views::View* view) override;
+  void MouseEnteredButton(views::View* view) override;
+  void MouseExitedButton(views::View* view) override;
+  base::string16 GetAccessibleName(const views::View* view) override;
 
   // Overridden from views::ButtonListener:
-  virtual void ButtonPressed(views::Button* sender,
-                             const ui::Event& event) override;
+  void ButtonPressed(views::Button* sender, const ui::Event& event) override;
 
   // Show the list of all running items for this |item|. It will return true
   // when the menu was shown and false if there were no possible items to
   // choose from. |source| specifies the view which is responsible for showing
   // the menu, and the bubble will point towards it.
   // The |event_flags| are the flags of the event which triggered this menu.
   bool ShowListMenuForView(const ShelfItem& item,
                            views::View* source,
                            const ui::Event& event);
 
   // Overridden from views::ContextMenuController:
-  virtual void ShowContextMenuForView(views::View* source,
-                                      const gfx::Point& point,
-                                      ui::MenuSourceType source_type) override;
+  void ShowContextMenuForView(views::View* source,
+                              const gfx::Point& point,
+                              ui::MenuSourceType source_type) override;
 
   // Show either a context or normal click menu of given |menu_model|.
   // If |context_menu| is set, the displayed menu is a context menu and not
   // a menu listing one or more running applications.
   // The |click_point| is only used for |context_menu|'s.
   void ShowMenu(ui::MenuModel* menu_model,
                 views::View* source,
                 const gfx::Point& click_point,
                 bool context_menu,
                 ui::MenuSourceType source_type);
 
   // Overridden from views::BoundsAnimatorObserver:
-  virtual void OnBoundsAnimatorProgressed(
-      views::BoundsAnimator* animator) override;
-  virtual void OnBoundsAnimatorDone(views::BoundsAnimator* animator) override;
+  void OnBoundsAnimatorProgressed(views::BoundsAnimator* animator) override;
+  void OnBoundsAnimatorDone(views::BoundsAnimator* animator) override;
 
   // Returns false if the click which closed the previous menu is the click
   // which triggered this event.
   bool IsUsableEvent(const ui::Event& event);
 
   // Convenience accessor to model_->items().
   const ShelfItem* ShelfItemForView(const views::View* view) const;
 
   // Returns true if a tooltip should be shown for |view|.
   bool ShouldShowTooltipForView(const views::View* view) const;
@@ skipping 118 matching lines @@
 
   // True when ripped item from overflow bubble is entered into Shelf.
   bool dragged_off_from_overflow_to_shelf_;
 
   DISALLOW_COPY_AND_ASSIGN(ShelfView);
 };
 
 }  // namespace ash
 
 #endif  // ASH_SHELF_SHELF_VIEW_H_