replace OVERRIDE and FINAL with override and final in ui/

ui/compositor/layer_animator_unittest.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_animator.h"
 
 #include "base/basictypes.h"
 #include "base/compiler_specific.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/strings/stringprintf.h"
@@ skipping 62 matching lines @@
   }
 
   bool WasAnimationCompletedForProperty(
       LayerAnimationElement::AnimatableProperty property) const {
     return ImplicitAnimationObserver::WasAnimationCompletedForProperty(
         property);
   }
 
  private:
   // ImplicitAnimationObserver implementation
-  virtual void OnImplicitAnimationsCompleted() OVERRIDE {
+  virtual void OnImplicitAnimationsCompleted() override {
     animations_completed_ = true;
   }
 
-  virtual bool RequiresNotificationWhenAnimatorDestroyed() const OVERRIDE {
+  virtual bool RequiresNotificationWhenAnimatorDestroyed() const override {
     return notify_when_animator_destructed_;
   }
 
   bool animations_completed_;
   bool notify_when_animator_destructed_;
 
   DISALLOW_COPY_AND_ASSIGN(TestImplicitAnimationObserver);
 };
 
 // When notified that an animation has ended, stops all other animations.
 class DeletingLayerAnimationObserver : public LayerAnimationObserver {
  public:
   DeletingLayerAnimationObserver(LayerAnimator* animator)
     : animator_(animator) {
   }
 
   virtual void OnLayerAnimationEnded(
-      LayerAnimationSequence* sequence) OVERRIDE {
+      LayerAnimationSequence* sequence) override {
     animator_->StopAnimating();
   }
 
   virtual void OnLayerAnimationAborted(
-      LayerAnimationSequence* sequence) OVERRIDE {
+      LayerAnimationSequence* sequence) override {
     animator_->StopAnimating();
   }
 
   virtual void OnLayerAnimationScheduled(
-      LayerAnimationSequence* sequence) OVERRIDE {
+      LayerAnimationSequence* sequence) override {
   }
 
  private:
   LayerAnimator* animator_;
 
   DISALLOW_COPY_AND_ASSIGN(DeletingLayerAnimationObserver);
 };
 
 class LayerAnimatorDestructionObserver {
  public:
@@ skipping 25 matching lines @@
   }
 
  protected:
   virtual ~TestLayerAnimator() {
     if (destruction_observer_) {
       destruction_observer_->NotifyAnimatorDeleted();
     }
   }
 
   virtual void ProgressAnimation(LayerAnimationSequence* sequence,
-                                 base::TimeTicks now) OVERRIDE {
+                                 base::TimeTicks now) override {
     EXPECT_TRUE(HasAnimation(sequence));
     LayerAnimator::ProgressAnimation(sequence, now);
   }
 
  private:
   LayerAnimatorDestructionObserver* destruction_observer_;
 
   DISALLOW_COPY_AND_ASSIGN(TestLayerAnimator);
 };
 
@@ skipping 1769 matching lines @@
 // callback triggered by the animation progress.
 TEST(LayerAnimatorTest, CallbackDeletesAnimationInProgress) {
 
   class TestLayerAnimationDeletingDelegate : public TestLayerAnimationDelegate {
    public:
     TestLayerAnimationDeletingDelegate(LayerAnimator* animator, int max_width)
       : animator_(animator),
         max_width_(max_width) {
     }
 
-    virtual void SetBoundsFromAnimation(const gfx::Rect& bounds) OVERRIDE {
+    virtual void SetBoundsFromAnimation(const gfx::Rect& bounds) override {
       TestLayerAnimationDelegate::SetBoundsFromAnimation(bounds);
       if (bounds.width() > max_width_)
         animator_->StopAnimating();
     }
    private:
     LayerAnimator* animator_;
     int max_width_;
     // Allow copy and assign.
   };
 
@@ skipping 313 matching lines @@
 
   bool delete_on_animation_scheduled() const {
     return delete_on_animation_scheduled_;
   }
   void set_delete_on_animation_scheduled(bool enabled) {
     delete_on_animation_scheduled_ = enabled;
   }
 
   // LayerAnimationObserver implementation.
   virtual void OnLayerAnimationEnded(
-      LayerAnimationSequence* sequence) OVERRIDE {
+      LayerAnimationSequence* sequence) override {
     if (delete_on_animation_ended_)
       delete this;
   }
 
   virtual void OnLayerAnimationAborted(
-      LayerAnimationSequence* sequence) OVERRIDE {
+      LayerAnimationSequence* sequence) override {
     if (delete_on_animation_aborted_)
       delete this;
   }
 
   virtual void OnLayerAnimationScheduled(
-      LayerAnimationSequence* sequence) OVERRIDE {
+      LayerAnimationSequence* sequence) override {
     if (delete_on_animation_scheduled_)
       delete this;
   }
 
 private:
   scoped_ptr<AnimatorOwner> animator_owner_;
   bool delete_on_animation_ended_;
   bool delete_on_animation_aborted_;
   bool delete_on_animation_scheduled_;
   bool* was_deleted_;
@@ skipping 193 matching lines @@
     << child.GetTargetTransform().ToString();
 
 }
 
 class CollectionLayerAnimationDelegate : public TestLayerAnimationDelegate {
  public:
   CollectionLayerAnimationDelegate() : collection(NULL) {}
   virtual ~CollectionLayerAnimationDelegate() {}
 
   // LayerAnimationDelegate:
-  virtual LayerAnimatorCollection* GetLayerAnimatorCollection() OVERRIDE {
+  virtual LayerAnimatorCollection* GetLayerAnimatorCollection() override {
     return &collection;
   }
 
  private:
   LayerAnimatorCollection collection;
 };
 
 TEST(LayerAnimatorTest, LayerAnimatorCollectionTickTime) {
   Layer layer;
   LayerAnimator* animator = layer.GetAnimator();
@@ skipping 92 matching lines @@
 
   root_2.Add(&layer);
   EXPECT_FALSE(compositor_1->layer_animator_collection()->HasActiveAnimators());
   EXPECT_TRUE(compositor_2->layer_animator_collection()->HasActiveAnimators());
   host_2.reset();
   host_1.reset();
   TerminateContextFactoryForTests();
 }
 
 }  // namespace ui