replace OVERRIDE and FINAL with override and final in ui/

ui/keyboard/keyboard_controller.cc

 // Copyright (c) 2013 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/keyboard/keyboard_controller.h"
 
 #include <set>
 
 #include "base/bind.h"
 #include "base/command_line.h"
@@ skipping 44 matching lines @@
                             keyboard::KeyboardControllerProxy* proxy)
       : wm::MaskedWindowTargeter(container),
         proxy_(proxy) {
   }
 
   virtual ~KeyboardContainerTargeter() {}
 
  private:
   // wm::MaskedWindowTargeter:
   virtual bool GetHitTestMask(aura::Window* window,
-                              gfx::Path* mask) const OVERRIDE {
+                              gfx::Path* mask) const override {
     if (proxy_ && !proxy_->HasKeyboardWindow())
       return true;
     gfx::Rect keyboard_bounds = proxy_ ? proxy_->GetKeyboardWindow()->bounds() :
         keyboard::DefaultKeyboardBoundsFromWindowBounds(window->bounds());
     mask->addRect(RectToSkRect(keyboard_bounds));
     return true;
   }
 
   keyboard::KeyboardControllerProxy* proxy_;
 
   DISALLOW_COPY_AND_ASSIGN(KeyboardContainerTargeter);
 };
 
 // The KeyboardWindowDelegate makes sure the keyboard-window does not get focus.
 // This is necessary to make sure that the synthetic key-events reach the target
 // window.
 // The delegate deletes itself when the window is destroyed.
 class KeyboardWindowDelegate : public aura::WindowDelegate {
  public:
   explicit KeyboardWindowDelegate(keyboard::KeyboardControllerProxy* proxy)
       : proxy_(proxy) {}
   virtual ~KeyboardWindowDelegate() {}
 
  private:
   // Overridden from aura::WindowDelegate:
-  virtual gfx::Size GetMinimumSize() const OVERRIDE { return gfx::Size(); }
-  virtual gfx::Size GetMaximumSize() const OVERRIDE { return gfx::Size(); }
+  virtual gfx::Size GetMinimumSize() const override { return gfx::Size(); }
+  virtual gfx::Size GetMaximumSize() const override { return gfx::Size(); }
   virtual void OnBoundsChanged(const gfx::Rect& old_bounds,
-                               const gfx::Rect& new_bounds) OVERRIDE {
+                               const gfx::Rect& new_bounds) override {
     bounds_ = new_bounds;
   }
-  virtual gfx::NativeCursor GetCursor(const gfx::Point& point) OVERRIDE {
+  virtual gfx::NativeCursor GetCursor(const gfx::Point& point) override {
     return gfx::kNullCursor;
   }
-  virtual int GetNonClientComponent(const gfx::Point& point) const OVERRIDE {
+  virtual int GetNonClientComponent(const gfx::Point& point) const override {
     return HTNOWHERE;
   }
   virtual bool ShouldDescendIntoChildForEventHandling(
       aura::Window* child,
-      const gfx::Point& location) OVERRIDE {
+      const gfx::Point& location) override {
     return true;
   }
-  virtual bool CanFocus() OVERRIDE { return false; }
-  virtual void OnCaptureLost() OVERRIDE {}
-  virtual void OnPaint(gfx::Canvas* canvas) OVERRIDE {}
-  virtual void OnDeviceScaleFactorChanged(float device_scale_factor) OVERRIDE {}
-  virtual void OnWindowDestroying(aura::Window* window) OVERRIDE {}
-  virtual void OnWindowDestroyed(aura::Window* window) OVERRIDE { delete this; }
-  virtual void OnWindowTargetVisibilityChanged(bool visible) OVERRIDE {}
-  virtual bool HasHitTestMask() const OVERRIDE {
+  virtual bool CanFocus() override { return false; }
+  virtual void OnCaptureLost() override {}
+  virtual void OnPaint(gfx::Canvas* canvas) override {}
+  virtual void OnDeviceScaleFactorChanged(float device_scale_factor) override {}
+  virtual void OnWindowDestroying(aura::Window* window) override {}
+  virtual void OnWindowDestroyed(aura::Window* window) override { delete this; }
+  virtual void OnWindowTargetVisibilityChanged(bool visible) override {}
+  virtual bool HasHitTestMask() const override {
     return !proxy_ || proxy_->HasKeyboardWindow();
   }
-  virtual void GetHitTestMask(gfx::Path* mask) const OVERRIDE {
+  virtual void GetHitTestMask(gfx::Path* mask) const override {
     if (proxy_ && !proxy_->HasKeyboardWindow())
       return;
     gfx::Rect keyboard_bounds = proxy_ ? proxy_->GetKeyboardWindow()->bounds() :
         keyboard::DefaultKeyboardBoundsFromWindowBounds(bounds_);
     mask->addRect(RectToSkRect(keyboard_bounds));
   }
 
   gfx::Rect bounds_;
   keyboard::KeyboardControllerProxy* proxy_;
 
@@ skipping 35 matching lines @@
 // Observer for both keyboard show and hide animations. It should be owned by
 // KeyboardController.
 class CallbackAnimationObserver : public ui::LayerAnimationObserver {
  public:
   CallbackAnimationObserver(ui::LayerAnimator* animator,
                             base::Callback<void(void)> callback);
   virtual ~CallbackAnimationObserver();
 
  private:
   // Overridden from ui::LayerAnimationObserver:
-  virtual void OnLayerAnimationEnded(ui::LayerAnimationSequence* seq) OVERRIDE;
+  virtual void OnLayerAnimationEnded(ui::LayerAnimationSequence* seq) override;
   virtual void OnLayerAnimationAborted(
-      ui::LayerAnimationSequence* seq) OVERRIDE;
+      ui::LayerAnimationSequence* seq) override;
   virtual void OnLayerAnimationScheduled(
-      ui::LayerAnimationSequence* seq) OVERRIDE {}
+      ui::LayerAnimationSequence* seq) override {}
 
   ui::LayerAnimator* animator_;
   base::Callback<void(void)> callback_;
 
   DISALLOW_COPY_AND_ASSIGN(CallbackAnimationObserver);
 };
 
 CallbackAnimationObserver::CallbackAnimationObserver(
     ui::LayerAnimator* animator, base::Callback<void(void)> callback)
     : animator_(animator), callback_(callback) {
@@ skipping 13 matching lines @@
 
 void CallbackAnimationObserver::OnLayerAnimationAborted(
     ui::LayerAnimationSequence* seq) {
   animator_->RemoveObserver(this);
 }
 
 class WindowBoundsChangeObserver : public aura::WindowObserver {
  public:
   virtual void OnWindowBoundsChanged(aura::Window* window,
                                      const gfx::Rect& old_bounds,
-                                     const gfx::Rect& new_bounds) OVERRIDE;
-  virtual void OnWindowDestroyed(aura::Window* window) OVERRIDE;
+                                     const gfx::Rect& new_bounds) override;
+  virtual void OnWindowDestroyed(aura::Window* window) override;
 
   void AddObservedWindow(aura::Window* window);
   void RemoveAllObservedWindows();
 
  private:
   std::set<aura::Window*> observed_windows_;
 };
 
 void WindowBoundsChangeObserver::OnWindowBoundsChanged(aura::Window* window,
     const gfx::Rect& old_bounds, const gfx::Rect& new_bounds) {
@@ skipping 354 matching lines @@
   proxy_->HideKeyboardContainer(container_.get());
 }
 
 void KeyboardController::AddBoundsChangedObserver(aura::Window* window) {
   aura::Window* target_window = GetFrameWindow(window);
   if (target_window)
     window_bounds_observer_->AddObservedWindow(target_window);
 }
 
 }  // namespace keyboard