Standardize usage of virtual/override/final specifiers.

ash/test/test_session_state_animator.h

 // Copyright 2014 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_TEST_TEST_SESSION_STATE_ANIMATOR_H_
 #define ASH_TEST_TEST_SESSION_STATE_ANIMATOR_H_
 
 #include <map>
 #include <vector>
 
 #include "ash/ash_export.h"
 #include "ash/wm/session_state_animator.h"
 #include "base/basictypes.h"
 #include "base/time/time.h"
 
 namespace ash {
 namespace test {
 
 // A SessionStateAnimator that offers control over the lifetime of active
 // animations.
 // NOTE: The TestSessionStateAnimator limits each
 // SessionStateAnimator::Container to a single active animation at any one time.
 // If a new animation is started on a container the existing one will be
 // aborted.
 class TestSessionStateAnimator : public SessionStateAnimator {
  public:
   TestSessionStateAnimator();
-  virtual ~TestSessionStateAnimator();
+  ~TestSessionStateAnimator() override;
 
   int last_animation_epoch() {
     return last_animation_epoch_;
   }
 
   // Resets the current animation epoch back to 0 and aborts all currently
   // active animations.
   void ResetAnimationEpoch();
 
   // Advances all contained animations by the specified |duration|.  Any
@@ skipping 18 matching lines @@
 
   // Returns true if there is an animation active with |type| for all the given
   // containers specified by |container_mask|.
   bool AreContainersAnimated(int container_mask,
                              SessionStateAnimator::AnimationType type) const;
 
   // Returns the number of active animations.
   size_t GetAnimationCount() const;
 
   // ash::SessionStateAnimator:
-  virtual void StartAnimation(int container_mask,
-                              AnimationType type,
-                              AnimationSpeed speed) override;
-  virtual void StartAnimationWithCallback(
-      int container_mask,
-      AnimationType type,
-      AnimationSpeed speed,
-      base::Closure callback) override;
-  virtual AnimationSequence* BeginAnimationSequence(
-      base::Closure callback) override;
-  virtual bool IsBackgroundHidden() const override;
-  virtual void ShowBackground() override;
-  virtual void HideBackground() override;
+  void StartAnimation(int container_mask,
+                      AnimationType type,
+                      AnimationSpeed speed) override;
+  void StartAnimationWithCallback(int container_mask,
+                                  AnimationType type,
+                                  AnimationSpeed speed,
+                                  base::Closure callback) override;
+  AnimationSequence* BeginAnimationSequence(base::Closure callback) override;
+  bool IsBackgroundHidden() const override;
+  void ShowBackground() override;
+  void HideBackground() override;
 
  private:
   class AnimationSequence;
   friend class AnimationSequence;
 
   // Data structure to track the currently active animations and their
   // callbacks.
   struct ActiveAnimation {
     ActiveAnimation(
         int animation_epoch,
@@ skipping 67 matching lines @@
   // Tracks whether the background is hidden or not.
   bool is_background_hidden_;
 
   DISALLOW_COPY_AND_ASSIGN(TestSessionStateAnimator);
 };
 
 }  // namespace test
 }  // namespace ash
 
 #endif  // ASH_TEST_TEST_SESSION_STATE_ANIMATOR_H_