Standardize usage of virtual/override/final specifiers.

ui/wm/core/window_animations.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 "ui/wm/core/window_animations.h"
 
 #include <math.h>
 
 #include <algorithm>
 #include <vector>
@@ skipping 45 matching lines @@
 // deleted, and b) to ensure that the animation is visible even if the
 // window gets restacked below other windows when focus or activation
 // changes.
 // The subclass will determine when the animation is completed.
 class HidingWindowAnimationObserverBase : public aura::WindowObserver {
  public:
   explicit HidingWindowAnimationObserverBase(aura::Window* window)
       : window_(window) {
     window_->AddObserver(this);
   }
-  virtual ~HidingWindowAnimationObserverBase() {
+  ~HidingWindowAnimationObserverBase() override {
     if (window_)
       window_->RemoveObserver(this);
   }
 
   // aura::WindowObserver:
-  virtual void OnWindowDestroying(aura::Window* window) override {
+  void OnWindowDestroying(aura::Window* window) override {
     DCHECK_EQ(window, window_);
     WindowInvalid();
   }
 
-  virtual void OnWindowDestroyed(aura::Window* window) override {
+  void OnWindowDestroyed(aura::Window* window) override {
     DCHECK_EQ(window, window_);
     WindowInvalid();
   }
 
   // Detach the current layers and create new layers for |window_|.
   // Stack the original layers above |window_| and its transient
   // children.  If the window has transient children, the original
   // layers will be moved above the top most transient child so that
   // activation change does not put the window above the animating
   // layer.
@@ skipping 70 matching lines @@
 
 // A HidingWindowAnimationObserver that deletes observer and detached
 // layers upon the completion of the implicit animation.
 class ImplicitHidingWindowAnimationObserver
     : public HidingWindowAnimationObserverBase,
       public ui::ImplicitAnimationObserver {
  public:
   ImplicitHidingWindowAnimationObserver(
       aura::Window* window,
       ui::ScopedLayerAnimationSettings* settings);
-  virtual ~ImplicitHidingWindowAnimationObserver() {}
+  ~ImplicitHidingWindowAnimationObserver() override {}
 
   // ui::ImplicitAnimationObserver:
-  virtual void OnImplicitAnimationsCompleted() override;
+  void OnImplicitAnimationsCompleted() override;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(ImplicitHidingWindowAnimationObserver);
 };
 
 namespace {
 
 const int kDefaultAnimationDurationForMenuMS = 150;
 
 const float kWindowAnimation_HideOpacity = 0.f;
@@ skipping 211 matching lines @@
 }
 
 // A HidingWindowAnimationObserver that deletes observer and detached
 // layers when the last_sequence has been completed or aborted.
 class RotateHidingWindowAnimationObserver
     : public HidingWindowAnimationObserverBase,
       public ui::LayerAnimationObserver {
  public:
   explicit RotateHidingWindowAnimationObserver(aura::Window* window)
       : HidingWindowAnimationObserverBase(window) {}
-  virtual ~RotateHidingWindowAnimationObserver() {}
+  ~RotateHidingWindowAnimationObserver() override {}
 
   // Destroys itself after |last_sequence| ends or is aborted. Does not take
   // ownership of |last_sequence|, which should not be NULL.
   void SetLastSequence(ui::LayerAnimationSequence* last_sequence) {
     last_sequence->AddObserver(this);
   }
 
   // ui::LayerAnimationObserver:
-  virtual void OnLayerAnimationEnded(
-      ui::LayerAnimationSequence* sequence) override {
+  void OnLayerAnimationEnded(ui::LayerAnimationSequence* sequence) override {
     OnAnimationCompleted();
   }
-  virtual void OnLayerAnimationAborted(
-      ui::LayerAnimationSequence* sequence) override {
+  void OnLayerAnimationAborted(ui::LayerAnimationSequence* sequence) override {
     OnAnimationCompleted();
   }
-  virtual void OnLayerAnimationScheduled(
+  void OnLayerAnimationScheduled(
       ui::LayerAnimationSequence* sequence) override {}
 
  private:
   DISALLOW_COPY_AND_ASSIGN(RotateHidingWindowAnimationObserver);
 };
 
 void AddLayerAnimationsForRotate(aura::Window* window, bool show) {
   if (show)
     window->layer()->SetOpacity(kWindowAnimation_HideOpacity);
 
@@ skipping 232 matching lines @@
   // being accessed via Remote Desktop.
   if (ui::ScopedAnimationDurationScaleMode::duration_scale_mode() ==
       ui::ScopedAnimationDurationScaleMode::NON_ZERO_DURATION)
     return false;
 
   // Let the user decide whether or not to play the animation.
   return !gfx::Animation::ShouldRenderRichAnimation();
 }
 
 }  // namespace wm