Standardize usage of virtual/override/final specifiers.

ash/wm/dock/docked_window_layout_manager.h

 // Copyright (c) 2013 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_WM_DOCK_DOCKED_WINDOW_LAYOUT_MANAGER_H_
 #define ASH_WM_DOCK_DOCKED_WINDOW_LAYOUT_MANAGER_H_
 
 #include "ash/ash_export.h"
 #include "ash/shelf/shelf_layout_manager_observer.h"
 #include "ash/shell_observer.h"
@@ skipping 65 matching lines @@
       public wm::WindowStateObserver {
  public:
   // Maximum width of the docked windows area.
   static const int kMaxDockWidth;
 
   // Minimum width of the docked windows area.
   static const int kMinDockWidth;
 
   DockedWindowLayoutManager(aura::Window* dock_container,
                             WorkspaceController* workspace_controller);
-  virtual ~DockedWindowLayoutManager();
+  ~DockedWindowLayoutManager() override;
 
   // Disconnects observers before container windows get destroyed.
   void Shutdown();
 
   // Management of the observer list.
   virtual void AddObserver(DockedWindowLayoutManagerObserver* observer);
   virtual void RemoveObserver(DockedWindowLayoutManagerObserver* observer);
 
   // Called by a DockedWindowResizer to update which window is being dragged.
   // Starts observing the window unless it is a child.
@@ skipping 44 matching lines @@
   // Returns last known coordinates of |dragged_window_| after Relayout.
   const gfx::Rect dragged_bounds() const { return dragged_bounds_;}
 
   // Returns true if currently dragged window is docked at the screen edge.
   bool is_dragged_window_docked() const { return is_dragged_window_docked_; }
 
   // Updates docked layout when shelf bounds change.
   void OnShelfBoundsChanged();
 
   // SnapLayoutManager:
-  virtual void OnWindowResized() override;
-  virtual void OnWindowAddedToLayout(aura::Window* child) override;
-  virtual void OnWillRemoveWindowFromLayout(aura::Window* child) override {}
-  virtual void OnWindowRemovedFromLayout(aura::Window* child) override;
-  virtual void OnChildWindowVisibilityChanged(aura::Window* child,
-                                              bool visibile) override;
-  virtual void SetChildBounds(aura::Window* child,
-                              const gfx::Rect& requested_bounds) override;
+  void OnWindowResized() override;
+  void OnWindowAddedToLayout(aura::Window* child) override;
+  void OnWillRemoveWindowFromLayout(aura::Window* child) override {}
+  void OnWindowRemovedFromLayout(aura::Window* child) override;
+  void OnChildWindowVisibilityChanged(aura::Window* child,
+                                      bool visibile) override;
+  void SetChildBounds(aura::Window* child,
+                      const gfx::Rect& requested_bounds) override;
 
   // ash::ShellObserver:
-  virtual void OnDisplayWorkAreaInsetsChanged() override;
-  virtual void OnFullscreenStateChanged(bool is_fullscreen,
-                                        aura::Window* root_window) override;
-  virtual void OnShelfAlignmentChanged(aura::Window* root_window) override;
+  void OnDisplayWorkAreaInsetsChanged() override;
+  void OnFullscreenStateChanged(bool is_fullscreen,
+                                aura::Window* root_window) override;
+  void OnShelfAlignmentChanged(aura::Window* root_window) override;
 
   // ShelfLayoutManagerObserver:
-  virtual void OnBackgroundUpdated(
-      ShelfBackgroundType background_type,
-      BackgroundAnimatorChangeType change_type) override;
+  void OnBackgroundUpdated(ShelfBackgroundType background_type,
+                           BackgroundAnimatorChangeType change_type) override;
 
   // wm::WindowStateObserver:
-  virtual void OnPreWindowStateTypeChange(
-      wm::WindowState* window_state,
-      wm::WindowStateType old_type) override;
+  void OnPreWindowStateTypeChange(wm::WindowState* window_state,
+                                  wm::WindowStateType old_type) override;
 
   // aura::WindowObserver:
-  virtual void OnWindowBoundsChanged(aura::Window* window,
-                                     const gfx::Rect& old_bounds,
-                                     const gfx::Rect& new_bounds) override;
-  virtual void OnWindowVisibilityChanging(aura::Window* window,
-                                          bool visible) override;
-  virtual void OnWindowDestroying(aura::Window* window) override;
+  void OnWindowBoundsChanged(aura::Window* window,
+                             const gfx::Rect& old_bounds,
+                             const gfx::Rect& new_bounds) override;
+  void OnWindowVisibilityChanging(aura::Window* window, bool visible) override;
+  void OnWindowDestroying(aura::Window* window) override;
 
   // aura::client::ActivationChangeObserver:
-  virtual void OnWindowActivated(aura::Window* gained_active,
-                                 aura::Window* lost_active) override;
+  void OnWindowActivated(aura::Window* gained_active,
+                         aura::Window* lost_active) override;
 
  private:
   class ShelfWindowObserver;
   friend class DockedWindowLayoutManagerTest;
   friend class DockedWindowResizerTest;
 
   // Width of the gap between the docked windows and a workspace.
   static const int kMinDockGap;
 
   // Ideal (starting) width of the dock.
@@ skipping 62 matching lines @@
   // Updates |docked_bounds_| and workspace insets when bounds of docked windows
   // area change. Passing |reason| to observers allows selectively skipping
   // notifications.
   void UpdateDockBounds(DockedWindowLayoutManagerObserver::Reason reason);
 
   // Called whenever the window stacking order needs to be updated (e.g. focus
   // changes or a window is moved).
   void UpdateStacking(aura::Window* active_window);
 
   // keyboard::KeyboardControllerObserver:
-  virtual void OnKeyboardBoundsChanging(
-      const gfx::Rect& keyboard_bounds) override;
+  void OnKeyboardBoundsChanging(const gfx::Rect& keyboard_bounds) override;
 
   // Parent window associated with this layout manager.
   aura::Window* dock_container_;
   // Protect against recursive calls to Relayout().
   bool in_layout_;
 
   // A window that is being dragged (whether docked or not).
   // Windows are tracked by docked layout manager only if they are docked;
   // however we need to know if a window is being dragged in order to avoid
   // positioning it or even considering it for layout.
@@ skipping 48 matching lines @@
 
   // Observers of dock bounds changes.
   ObserverList<DockedWindowLayoutManagerObserver> observer_list_;
 
   DISALLOW_COPY_AND_ASSIGN(DockedWindowLayoutManager);
 };
 
 }  // namespace ash
 
 #endif  // ASH_WM_DOCK_DOCKED_WINDOW_LAYOUT_MANAGER_H_