replace OVERRIDE and FINAL with override and final in ui/

ui/compositor/layer_animation_element.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/compositor/layer_animation_element.h"
 
 #include "base/compiler_specific.h"
 #include "cc/animation/animation.h"
 #include "cc/animation/animation_id_provider.h"
 #include "ui/compositor/float_animation_curve_adapter.h"
@@ skipping 17 matching lines @@
 
 // Pause -----------------------------------------------------------------------
 class Pause : public LayerAnimationElement {
  public:
   Pause(AnimatableProperties properties, base::TimeDelta duration)
       : LayerAnimationElement(properties, duration) {
   }
   virtual ~Pause() {}
 
  private:
-  virtual void OnStart(LayerAnimationDelegate* delegate) OVERRIDE {}
+  virtual void OnStart(LayerAnimationDelegate* delegate) override {}
   virtual bool OnProgress(double t,
-                          LayerAnimationDelegate* delegate) OVERRIDE {
+                          LayerAnimationDelegate* delegate) override {
     return false;
   }
-  virtual void OnGetTarget(TargetValue* target) const OVERRIDE {}
-  virtual void OnAbort(LayerAnimationDelegate* delegate) OVERRIDE {}
+  virtual void OnGetTarget(TargetValue* target) const override {}
+  virtual void OnAbort(LayerAnimationDelegate* delegate) override {}
 
   DISALLOW_COPY_AND_ASSIGN(Pause);
 };
 
 // TransformTransition ---------------------------------------------------------
 
 class TransformTransition : public LayerAnimationElement {
  public:
     TransformTransition(const gfx::Transform& target, base::TimeDelta duration)
       : LayerAnimationElement(TRANSFORM, duration),
         target_(target) {
   }
   virtual ~TransformTransition() {}
 
  protected:
-  virtual void OnStart(LayerAnimationDelegate* delegate) OVERRIDE {
+  virtual void OnStart(LayerAnimationDelegate* delegate) override {
     start_ = delegate->GetTransformForAnimation();
   }
 
-  virtual bool OnProgress(double t, LayerAnimationDelegate* delegate) OVERRIDE {
+  virtual bool OnProgress(double t, LayerAnimationDelegate* delegate) override {
     delegate->SetTransformFromAnimation(
         gfx::Tween::TransformValueBetween(t, start_, target_));
     return true;
   }
 
-  virtual void OnGetTarget(TargetValue* target) const OVERRIDE {
+  virtual void OnGetTarget(TargetValue* target) const override {
     target->transform = target_;
   }
 
-  virtual void OnAbort(LayerAnimationDelegate* delegate) OVERRIDE {}
+  virtual void OnAbort(LayerAnimationDelegate* delegate) override {}
 
  private:
   gfx::Transform start_;
   const gfx::Transform target_;
 
   DISALLOW_COPY_AND_ASSIGN(TransformTransition);
 };
 
 // InterpolatedTransformTransition ---------------------------------------------
 
 class InterpolatedTransformTransition : public LayerAnimationElement {
  public:
   InterpolatedTransformTransition(InterpolatedTransform* interpolated_transform,
                                   base::TimeDelta duration)
       : LayerAnimationElement(TRANSFORM, duration),
         interpolated_transform_(interpolated_transform) {
   }
   virtual ~InterpolatedTransformTransition() {}
 
  protected:
-  virtual void OnStart(LayerAnimationDelegate* delegate) OVERRIDE {
+  virtual void OnStart(LayerAnimationDelegate* delegate) override {
   }
 
-  virtual bool OnProgress(double t, LayerAnimationDelegate* delegate) OVERRIDE {
+  virtual bool OnProgress(double t, LayerAnimationDelegate* delegate) override {
     delegate->SetTransformFromAnimation(
         interpolated_transform_->Interpolate(static_cast<float>(t)));
     return true;
   }
 
-  virtual void OnGetTarget(TargetValue* target) const OVERRIDE {
+  virtual void OnGetTarget(TargetValue* target) const override {
     target->transform = interpolated_transform_->Interpolate(1.0f);
   }
 
-  virtual void OnAbort(LayerAnimationDelegate* delegate) OVERRIDE {}
+  virtual void OnAbort(LayerAnimationDelegate* delegate) override {}
 
  private:
   scoped_ptr<InterpolatedTransform> interpolated_transform_;
 
   DISALLOW_COPY_AND_ASSIGN(InterpolatedTransformTransition);
 };
 
 // BoundsTransition ------------------------------------------------------------
 
 class BoundsTransition : public LayerAnimationElement {
  public:
   BoundsTransition(const gfx::Rect& target, base::TimeDelta duration)
       : LayerAnimationElement(BOUNDS, duration),
         target_(target) {
   }
   virtual ~BoundsTransition() {}
 
  protected:
-  virtual void OnStart(LayerAnimationDelegate* delegate) OVERRIDE {
+  virtual void OnStart(LayerAnimationDelegate* delegate) override {
     start_ = delegate->GetBoundsForAnimation();
   }
 
-  virtual bool OnProgress(double t, LayerAnimationDelegate* delegate) OVERRIDE {
+  virtual bool OnProgress(double t, LayerAnimationDelegate* delegate) override {
     delegate->SetBoundsFromAnimation(
         gfx::Tween::RectValueBetween(t, start_, target_));
     return true;
   }
 
-  virtual void OnGetTarget(TargetValue* target) const OVERRIDE {
+  virtual void OnGetTarget(TargetValue* target) const override {
     target->bounds = target_;
   }
 
-  virtual void OnAbort(LayerAnimationDelegate* delegate) OVERRIDE {}
+  virtual void OnAbort(LayerAnimationDelegate* delegate) override {}
 
  private:
   gfx::Rect start_;
   const gfx::Rect target_;
 
   DISALLOW_COPY_AND_ASSIGN(BoundsTransition);
 };
 
 // OpacityTransition -----------------------------------------------------------
 
 class OpacityTransition : public LayerAnimationElement {
  public:
   OpacityTransition(float target, base::TimeDelta duration)
       : LayerAnimationElement(OPACITY, duration),
         start_(0.0f),
         target_(target) {
   }
   virtual ~OpacityTransition() {}
 
  protected:
-  virtual void OnStart(LayerAnimationDelegate* delegate) OVERRIDE {
+  virtual void OnStart(LayerAnimationDelegate* delegate) override {
     start_ = delegate->GetOpacityForAnimation();
   }
 
-  virtual bool OnProgress(double t, LayerAnimationDelegate* delegate) OVERRIDE {
+  virtual bool OnProgress(double t, LayerAnimationDelegate* delegate) override {
     delegate->SetOpacityFromAnimation(
         gfx::Tween::FloatValueBetween(t, start_, target_));
     return true;
   }
 
-  virtual void OnGetTarget(TargetValue* target) const OVERRIDE {
+  virtual void OnGetTarget(TargetValue* target) const override {
     target->opacity = target_;
   }
 
-  virtual void OnAbort(LayerAnimationDelegate* delegate) OVERRIDE {}
+  virtual void OnAbort(LayerAnimationDelegate* delegate) override {}
 
  private:
   float start_;
   const float target_;
 
   DISALLOW_COPY_AND_ASSIGN(OpacityTransition);
 };
 
 // VisibilityTransition --------------------------------------------------------
 
 class VisibilityTransition : public LayerAnimationElement {
  public:
   VisibilityTransition(bool target, base::TimeDelta duration)
       : LayerAnimationElement(VISIBILITY, duration),
         start_(false),
         target_(target) {
   }
   virtual ~VisibilityTransition() {}
 
  protected:
-  virtual void OnStart(LayerAnimationDelegate* delegate) OVERRIDE {
+  virtual void OnStart(LayerAnimationDelegate* delegate) override {
     start_ = delegate->GetVisibilityForAnimation();
   }
 
-  virtual bool OnProgress(double t, LayerAnimationDelegate* delegate) OVERRIDE {
+  virtual bool OnProgress(double t, LayerAnimationDelegate* delegate) override {
     delegate->SetVisibilityFromAnimation(t == 1.0 ? target_ : start_);
     return t == 1.0;
   }
 
-  virtual void OnGetTarget(TargetValue* target) const OVERRIDE {
+  virtual void OnGetTarget(TargetValue* target) const override {
     target->visibility = target_;
   }
 
-  virtual void OnAbort(LayerAnimationDelegate* delegate) OVERRIDE {}
+  virtual void OnAbort(LayerAnimationDelegate* delegate) override {}
 
  private:
   bool start_;
   const bool target_;
 
   DISALLOW_COPY_AND_ASSIGN(VisibilityTransition);
 };
 
 // BrightnessTransition --------------------------------------------------------
 
 class BrightnessTransition : public LayerAnimationElement {
  public:
   BrightnessTransition(float target, base::TimeDelta duration)
       : LayerAnimationElement(BRIGHTNESS, duration),
         start_(0.0f),
         target_(target) {
   }
   virtual ~BrightnessTransition() {}
 
  protected:
-  virtual void OnStart(LayerAnimationDelegate* delegate) OVERRIDE {
+  virtual void OnStart(LayerAnimationDelegate* delegate) override {
     start_ = delegate->GetBrightnessForAnimation();
   }
 
-  virtual bool OnProgress(double t, LayerAnimationDelegate* delegate) OVERRIDE {
+  virtual bool OnProgress(double t, LayerAnimationDelegate* delegate) override {
     delegate->SetBrightnessFromAnimation(
         gfx::Tween::FloatValueBetween(t, start_, target_));
     return true;
   }
 
-  virtual void OnGetTarget(TargetValue* target) const OVERRIDE {
+  virtual void OnGetTarget(TargetValue* target) const override {
     target->brightness = target_;
   }
 
-  virtual void OnAbort(LayerAnimationDelegate* delegate) OVERRIDE {}
+  virtual void OnAbort(LayerAnimationDelegate* delegate) override {}
 
  private:
   float start_;
   const float target_;
 
   DISALLOW_COPY_AND_ASSIGN(BrightnessTransition);
 };
 
 // GrayscaleTransition ---------------------------------------------------------
 
 class GrayscaleTransition : public LayerAnimationElement {
  public:
   GrayscaleTransition(float target, base::TimeDelta duration)
       : LayerAnimationElement(GRAYSCALE, duration),
         start_(0.0f),
         target_(target) {
   }
   virtual ~GrayscaleTransition() {}
 
  protected:
-  virtual void OnStart(LayerAnimationDelegate* delegate) OVERRIDE {
+  virtual void OnStart(LayerAnimationDelegate* delegate) override {
     start_ = delegate->GetGrayscaleForAnimation();
   }
 
-  virtual bool OnProgress(double t, LayerAnimationDelegate* delegate) OVERRIDE {
+  virtual bool OnProgress(double t, LayerAnimationDelegate* delegate) override {
     delegate->SetGrayscaleFromAnimation(
         gfx::Tween::FloatValueBetween(t, start_, target_));
     return true;
   }
 
-  virtual void OnGetTarget(TargetValue* target) const OVERRIDE {
+  virtual void OnGetTarget(TargetValue* target) const override {
     target->grayscale = target_;
   }
 
-  virtual void OnAbort(LayerAnimationDelegate* delegate) OVERRIDE {}
+  virtual void OnAbort(LayerAnimationDelegate* delegate) override {}
 
  private:
   float start_;
   const float target_;
 
   DISALLOW_COPY_AND_ASSIGN(GrayscaleTransition);
 };
 
 // ColorTransition -------------------------------------------------------------
 
 class ColorTransition : public LayerAnimationElement {
  public:
   ColorTransition(SkColor target, base::TimeDelta duration)
       : LayerAnimationElement(COLOR, duration),
         start_(SK_ColorBLACK),
         target_(target) {
   }
   virtual ~ColorTransition() {}
 
  protected:
-  virtual void OnStart(LayerAnimationDelegate* delegate) OVERRIDE {
+  virtual void OnStart(LayerAnimationDelegate* delegate) override {
     start_ = delegate->GetColorForAnimation();
   }
 
-  virtual bool OnProgress(double t, LayerAnimationDelegate* delegate) OVERRIDE {
+  virtual bool OnProgress(double t, LayerAnimationDelegate* delegate) override {
     delegate->SetColorFromAnimation(
         gfx::Tween::ColorValueBetween(t, start_, target_));
     return true;
   }
 
-  virtual void OnGetTarget(TargetValue* target) const OVERRIDE {
+  virtual void OnGetTarget(TargetValue* target) const override {
     target->color = target_;
   }
 
-  virtual void OnAbort(LayerAnimationDelegate* delegate) OVERRIDE {}
+  virtual void OnAbort(LayerAnimationDelegate* delegate) override {}
 
  private:
   SkColor start_;
   const SkColor target_;
 
   DISALLOW_COPY_AND_ASSIGN(ColorTransition);
 };
 
 // ThreadedLayerAnimationElement -----------------------------------------------
 
 class ThreadedLayerAnimationElement : public LayerAnimationElement {
  public:
   ThreadedLayerAnimationElement(AnimatableProperties properties,
                                 base::TimeDelta duration)
       : LayerAnimationElement(properties, duration) {
   }
   virtual ~ThreadedLayerAnimationElement() {}
 
-  virtual bool IsThreaded() const OVERRIDE {
+  virtual bool IsThreaded() const override {
     return (duration() != base::TimeDelta());
   }
 
  protected:
   explicit ThreadedLayerAnimationElement(const LayerAnimationElement& element)
     : LayerAnimationElement(element) {
   }
 
   virtual bool OnProgress(double t,
-                          LayerAnimationDelegate* delegate) OVERRIDE {
+                          LayerAnimationDelegate* delegate) override {
     if (t < 1.0)
       return false;
 
     if (Started()) {
       delegate->RemoveThreadedAnimation(animation_id());
     }
 
     OnEnd(delegate);
     return true;
   }
 
-  virtual void OnAbort(LayerAnimationDelegate* delegate) OVERRIDE {
+  virtual void OnAbort(LayerAnimationDelegate* delegate) override {
     if (delegate && Started()) {
       delegate->RemoveThreadedAnimation(animation_id());
     }
   }
 
   virtual void RequestEffectiveStart(
-      LayerAnimationDelegate* delegate) OVERRIDE {
+      LayerAnimationDelegate* delegate) override {
     DCHECK(animation_group_id());
     if (duration() == base::TimeDelta()) {
       set_effective_start_time(requested_start_time());
       return;
     }
     set_effective_start_time(base::TimeTicks());
     scoped_ptr<cc::Animation> animation = CreateCCAnimation();
     animation->set_needs_synchronized_start_time(true);
     delegate->AddThreadedAnimation(animation.Pass());
   }
@@ skipping 11 matching lines @@
 class ThreadedOpacityTransition : public ThreadedLayerAnimationElement {
  public:
   ThreadedOpacityTransition(float target, base::TimeDelta duration)
       : ThreadedLayerAnimationElement(OPACITY, duration),
         start_(0.0f),
         target_(target) {
   }
   virtual ~ThreadedOpacityTransition() {}
 
  protected:
-  virtual void OnStart(LayerAnimationDelegate* delegate) OVERRIDE {
+  virtual void OnStart(LayerAnimationDelegate* delegate) override {
     start_ = delegate->GetOpacityForAnimation();
   }
 
-  virtual void OnAbort(LayerAnimationDelegate* delegate) OVERRIDE {
+  virtual void OnAbort(LayerAnimationDelegate* delegate) override {
     if (delegate && Started()) {
       ThreadedLayerAnimationElement::OnAbort(delegate);
       delegate->SetOpacityFromAnimation(gfx::Tween::FloatValueBetween(
           gfx::Tween::CalculateValue(tween_type(), last_progressed_fraction()),
               start_,
               target_));
     }
   }
 
-  virtual void OnEnd(LayerAnimationDelegate* delegate) OVERRIDE {
+  virtual void OnEnd(LayerAnimationDelegate* delegate) override {
     delegate->SetOpacityFromAnimation(target_);
   }
 
-  virtual scoped_ptr<cc::Animation> CreateCCAnimation() OVERRIDE {
+  virtual scoped_ptr<cc::Animation> CreateCCAnimation() override {
     scoped_ptr<cc::AnimationCurve> animation_curve(
         new FloatAnimationCurveAdapter(tween_type(),
                                        start_,
                                        target_,
                                        duration()));
     scoped_ptr<cc::Animation> animation(
         cc::Animation::Create(animation_curve.Pass(),
                               animation_id(),
                               animation_group_id(),
                               cc::Animation::Opacity));
     return animation.Pass();
   }
 
-  virtual void OnGetTarget(TargetValue* target) const OVERRIDE {
+  virtual void OnGetTarget(TargetValue* target) const override {
     target->opacity = target_;
   }
 
  private:
   float start_;
   const float target_;
 
   DISALLOW_COPY_AND_ASSIGN(ThreadedOpacityTransition);
 };
 
 // ThreadedTransformTransition -------------------------------------------------
 
 class ThreadedTransformTransition : public ThreadedLayerAnimationElement {
  public:
   ThreadedTransformTransition(const gfx::Transform& target,
                               base::TimeDelta duration)
       : ThreadedLayerAnimationElement(TRANSFORM, duration),
         target_(target) {
   }
   virtual ~ThreadedTransformTransition() {}
 
  protected:
-  virtual void OnStart(LayerAnimationDelegate* delegate) OVERRIDE {
+  virtual void OnStart(LayerAnimationDelegate* delegate) override {
     start_ = delegate->GetTransformForAnimation();
   }
 
-  virtual void OnAbort(LayerAnimationDelegate* delegate) OVERRIDE {
+  virtual void OnAbort(LayerAnimationDelegate* delegate) override {
     if (delegate && Started()) {
       ThreadedLayerAnimationElement::OnAbort(delegate);
       delegate->SetTransformFromAnimation(gfx::Tween::TransformValueBetween(
           gfx::Tween::CalculateValue(tween_type(), last_progressed_fraction()),
           start_,
           target_));
     }
   }
 
-  virtual void OnEnd(LayerAnimationDelegate* delegate) OVERRIDE {
+  virtual void OnEnd(LayerAnimationDelegate* delegate) override {
     delegate->SetTransformFromAnimation(target_);
   }
 
-  virtual scoped_ptr<cc::Animation> CreateCCAnimation() OVERRIDE {
+  virtual scoped_ptr<cc::Animation> CreateCCAnimation() override {
     scoped_ptr<cc::AnimationCurve> animation_curve(
         new TransformAnimationCurveAdapter(tween_type(),
                                            start_,
                                            target_,
                                            duration()));
     scoped_ptr<cc::Animation> animation(
         cc::Animation::Create(animation_curve.Pass(),
                               animation_id(),
                               animation_group_id(),
                               cc::Animation::Transform));
     return animation.Pass();
   }
 
-  virtual void OnGetTarget(TargetValue* target) const OVERRIDE {
+  virtual void OnGetTarget(TargetValue* target) const override {
     target->transform = target_;
   }
 
  private:
   gfx::Transform start_;
   const gfx::Transform target_;
 
   DISALLOW_COPY_AND_ASSIGN(ThreadedTransformTransition);
 };
 
@@ skipping 12 matching lines @@
   virtual ~InverseTransformTransition() {}
 
   static InverseTransformTransition* Clone(const LayerAnimationElement* other) {
     const InverseTransformTransition* other_inverse =
       CheckAndCast<const InverseTransformTransition*>(other);
     return new InverseTransformTransition(
         other_inverse->base_transform_, other_inverse->uninverted_transition_);
   }
 
  protected:
-  virtual void OnStart(LayerAnimationDelegate* delegate) OVERRIDE {
+  virtual void OnStart(LayerAnimationDelegate* delegate) override {
     gfx::Transform start(delegate->GetTransformForAnimation());
     effective_start_ = base_transform_ * start;
 
     TargetValue target;
     uninverted_transition_->GetTargetValue(&target);
     base_target_ = target.transform;
 
     set_tween_type(uninverted_transition_->tween_type());
 
     TransformAnimationCurveAdapter base_curve(tween_type(),
                                               base_transform_,
                                               base_target_,
                                               duration());
 
     animation_curve_.reset(new InverseTransformCurveAdapter(
         base_curve, start, duration()));
     computed_target_transform_ = ComputeWithBaseTransform(effective_start_,
                                                           base_target_);
   }
 
-  virtual void OnAbort(LayerAnimationDelegate* delegate) OVERRIDE {
+  virtual void OnAbort(LayerAnimationDelegate* delegate) override {
     if (delegate && Started()) {
       ThreadedLayerAnimationElement::OnAbort(delegate);
       delegate->SetTransformFromAnimation(ComputeCurrentTransform());
     }
   }
 
-  virtual void OnEnd(LayerAnimationDelegate* delegate) OVERRIDE {
+  virtual void OnEnd(LayerAnimationDelegate* delegate) override {
     delegate->SetTransformFromAnimation(computed_target_transform_);
   }
 
-  virtual scoped_ptr<cc::Animation> CreateCCAnimation() OVERRIDE {
+  virtual scoped_ptr<cc::Animation> CreateCCAnimation() override {
     scoped_ptr<cc::Animation> animation(
         cc::Animation::Create(animation_curve_->Clone(),
                               animation_id(),
                               animation_group_id(),
                               cc::Animation::Transform));
     return animation.Pass();
   }
 
-  virtual void OnGetTarget(TargetValue* target) const OVERRIDE {
+  virtual void OnGetTarget(TargetValue* target) const override {
     target->transform = computed_target_transform_;
   }
 
  private:
   gfx::Transform ComputeCurrentTransform() const {
     gfx::Transform base_current = gfx::Tween::TransformValueBetween(
         gfx::Tween::CalculateValue(tween_type(), last_progressed_fraction()),
         base_transform_,
         base_target_);
     return ComputeWithBaseTransform(effective_start_, base_current);
@@ skipping 278 matching lines @@
 }
 
 // static
 LayerAnimationElement* LayerAnimationElement::CreateColorElement(
     SkColor color,
     base::TimeDelta duration) {
   return new ColorTransition(color, duration);
 }
 
 }  // namespace ui