Standardize usage of virtual/override/final in ui/

ui/gfx/interpolated_transform.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 UI_GFX_INTERPOLATED_TRANSFORM_H_
 #define UI_GFX_INTERPOLATED_TRANSFORM_H_
 
 #include "base/basictypes.h"
 #include "base/memory/scoped_ptr.h"
 #include "ui/gfx/point.h"
@@ skipping 73 matching lines @@
 // Represents an animated rotation.
 //
 ///////////////////////////////////////////////////////////////////////////////
 class GFX_EXPORT InterpolatedRotation : public InterpolatedTransform {
  public:
   InterpolatedRotation(float start_degrees, float end_degrees);
   InterpolatedRotation(float start_degrees,
                        float end_degrees,
                        float start_time,
                        float end_time);
-  virtual ~InterpolatedRotation();
+  ~InterpolatedRotation() override;
 
  protected:
-  virtual gfx::Transform InterpolateButDoNotCompose(float t) const override;
+  gfx::Transform InterpolateButDoNotCompose(float t) const override;
 
  private:
   const float start_degrees_;
   const float end_degrees_;
 
   DISALLOW_COPY_AND_ASSIGN(InterpolatedRotation);
 };
 
 ///////////////////////////////////////////////////////////////////////////////
 // class InterpolatedAxisAngleRotation
 //
 // Represents an animated rotation.
 //
 ///////////////////////////////////////////////////////////////////////////////
 class GFX_EXPORT InterpolatedAxisAngleRotation : public InterpolatedTransform {
  public:
   InterpolatedAxisAngleRotation(const gfx::Vector3dF& axis,
                                 float start_degrees,
                                 float end_degrees);
   InterpolatedAxisAngleRotation(const gfx::Vector3dF& axis,
                                 float start_degrees,
                                 float end_degrees,
                                 float start_time,
                                 float end_time);
-  virtual ~InterpolatedAxisAngleRotation();
+  ~InterpolatedAxisAngleRotation() override;
 
  protected:
-  virtual gfx::Transform InterpolateButDoNotCompose(float t) const override;
+  gfx::Transform InterpolateButDoNotCompose(float t) const override;
 
  private:
   gfx::Vector3dF axis_;
   const float start_degrees_;
   const float end_degrees_;
 
   DISALLOW_COPY_AND_ASSIGN(InterpolatedAxisAngleRotation);
 };
 
 ///////////////////////////////////////////////////////////////////////////////
 // class InterpolatedScale
 //
 // Represents an animated scale.
 //
 ///////////////////////////////////////////////////////////////////////////////
 class GFX_EXPORT InterpolatedScale : public InterpolatedTransform {
  public:
   InterpolatedScale(float start_scale, float end_scale);
   InterpolatedScale(float start_scale, float end_scale,
                     float start_time, float end_time);
   InterpolatedScale(const gfx::Point3F& start_scale,
                     const gfx::Point3F& end_scale);
   InterpolatedScale(const gfx::Point3F& start_scale,
                     const gfx::Point3F& end_scale,
                     float start_time,
                     float end_time);
-  virtual ~InterpolatedScale();
+  ~InterpolatedScale() override;
 
  protected:
-  virtual gfx::Transform InterpolateButDoNotCompose(float t) const override;
+  gfx::Transform InterpolateButDoNotCompose(float t) const override;
 
  private:
   const gfx::Point3F start_scale_;
   const gfx::Point3F end_scale_;
 
   DISALLOW_COPY_AND_ASSIGN(InterpolatedScale);
 };
 
 class GFX_EXPORT InterpolatedTranslation : public InterpolatedTransform {
  public:
   InterpolatedTranslation(const gfx::Point& start_pos,
                           const gfx::Point& end_pos);
   InterpolatedTranslation(const gfx::Point& start_pos,
                           const gfx::Point& end_pos,
                           float start_time,
                           float end_time);
   InterpolatedTranslation(const gfx::Point3F& start_pos,
                           const gfx::Point3F& end_pos);
   InterpolatedTranslation(const gfx::Point3F& start_pos,
                           const gfx::Point3F& end_pos,
                           float start_time,
                           float end_time);
-  virtual ~InterpolatedTranslation();
+  ~InterpolatedTranslation() override;
 
  protected:
-  virtual gfx::Transform InterpolateButDoNotCompose(float t) const override;
+  gfx::Transform InterpolateButDoNotCompose(float t) const override;
 
  private:
   const gfx::Point3F start_pos_;
   const gfx::Point3F end_pos_;
 
   DISALLOW_COPY_AND_ASSIGN(InterpolatedTranslation);
 };
 
 ///////////////////////////////////////////////////////////////////////////////
 // class InterpolatedConstantTransform
 //
 // Represents a transform that is constant over time. This is only useful when
 // composed with other interpolated transforms.
 //
 // See InterpolatedTransformAboutPivot for an example of its usage.
 //
 ///////////////////////////////////////////////////////////////////////////////
 class GFX_EXPORT InterpolatedConstantTransform : public InterpolatedTransform {
  public:
   explicit InterpolatedConstantTransform(const gfx::Transform& transform);
-  virtual ~InterpolatedConstantTransform();
+  ~InterpolatedConstantTransform() override;
 
  protected:
-  virtual gfx::Transform InterpolateButDoNotCompose(float t) const override;
+  gfx::Transform InterpolateButDoNotCompose(float t) const override;
 
  private:
   const gfx::Transform transform_;
 
   DISALLOW_COPY_AND_ASSIGN(InterpolatedConstantTransform);
 };
 
 ///////////////////////////////////////////////////////////////////////////////
 // class InterpolatedTransformAboutPivot
 //
 // Represents an animated transform with a transformed origin. Essentially,
 // at each time, t, the interpolated transform is created by composing
 // P * T * P^-1 where P is a constant transform to the new origin.
 //
 ///////////////////////////////////////////////////////////////////////////////
 class GFX_EXPORT InterpolatedTransformAboutPivot
     : public InterpolatedTransform {
  public:
   // Takes ownership of the passed transform.
   InterpolatedTransformAboutPivot(const gfx::Point& pivot,
                                   InterpolatedTransform* transform);
 
   // Takes ownership of the passed transform.
   InterpolatedTransformAboutPivot(const gfx::Point& pivot,
                                   InterpolatedTransform* transform,
                                   float start_time,
                                   float end_time);
-  virtual ~InterpolatedTransformAboutPivot();
+  ~InterpolatedTransformAboutPivot() override;
 
  protected:
-  virtual gfx::Transform InterpolateButDoNotCompose(float t) const override;
+  gfx::Transform InterpolateButDoNotCompose(float t) const override;
 
  private:
   void Init(const gfx::Point& pivot, InterpolatedTransform* transform);
 
   scoped_ptr<InterpolatedTransform> transform_;
 
   DISALLOW_COPY_AND_ASSIGN(InterpolatedTransformAboutPivot);
 };
 
 class GFX_EXPORT InterpolatedMatrixTransform : public InterpolatedTransform {
  public:
   InterpolatedMatrixTransform(const gfx::Transform& start_transform,
                               const gfx::Transform& end_transform);
 
   InterpolatedMatrixTransform(const gfx::Transform& start_transform,
                               const gfx::Transform& end_transform,
                               float start_time,
                               float end_time);
 
-  virtual ~InterpolatedMatrixTransform();
+  ~InterpolatedMatrixTransform() override;
 
  protected:
-  virtual gfx::Transform InterpolateButDoNotCompose(float t) const override;
+  gfx::Transform InterpolateButDoNotCompose(float t) const override;
 
  private:
   void Init(const gfx::Transform& start_transform,
             const gfx::Transform& end_transform);
 
   gfx::DecomposedTransform start_decomp_;
   gfx::DecomposedTransform end_decomp_;
 };
 
 } // namespace ui
 
 #endif  // UI_GFX_INTERPOLATED_TRANSFORM_H_