Standardize usage of virtual/override/final in ui/

ui/compositor/scoped_layer_animation_settings.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/scoped_layer_animation_settings.h"
 
 #include "ui/compositor/layer.h"
 #include "ui/compositor/layer_animation_observer.h"
 #include "ui/compositor/layer_animation_sequence.h"
 #include "ui/compositor/layer_animator.h"
 
 namespace {
 
 const int kDefaultTransitionDurationMs = 200;
 
 }  // namespace
 
 namespace ui {
 
 // InvertingObserver -----------------------------------------------------------
 class InvertingObserver : public ImplicitAnimationObserver {
   public:
     InvertingObserver()
       : base_layer_(NULL) {
     }
 
-    virtual ~InvertingObserver() {}
+    ~InvertingObserver() override {}
 
     void SetLayer(Layer* base_layer) { base_layer_ = base_layer; }
 
     Layer* layer() { return base_layer_; }
 
     void AddInverselyAnimatedLayer(Layer* inverse_layer) {
       inverse_layers_.push_back(inverse_layer);
     }
 
-    virtual void OnImplicitAnimationsCompleted() override {}
+    void OnImplicitAnimationsCompleted() override {}
 
-    virtual void OnLayerAnimationScheduled(
-        LayerAnimationSequence* sequence) override {
+    void OnLayerAnimationScheduled(LayerAnimationSequence* sequence) override {
       DCHECK(base_layer_  != NULL)
         << "Must set base layer with ScopedLayerAnimationSettings::"
         << "SetInverslyAnimatedBaseLayer";
       gfx::Transform base_transform = base_layer_->transform();
       scoped_ptr<LayerAnimationElement> inverse = GetInverseElement(sequence,
           base_transform);
 
       for (std::vector<Layer*>::const_iterator i =
           inverse_layers_.begin(); i != inverse_layers_.end(); ++i) {
         (*i)->GetAnimator()->StartAnimation(new LayerAnimationSequence(
@@ skipping 103 matching lines @@
   }
   inverse_observer_->SetLayer(base);
 }
 
 void ScopedLayerAnimationSettings::AddInverselyAnimatedLayer(
     Layer* inverse_layer) {
   inverse_observer_->AddInverselyAnimatedLayer(inverse_layer);
 }
 
 }  // namespace ui