replace OVERRIDE and FINAL with override and final in ui/

ui/views/widget/desktop_aura/desktop_native_widget_aura.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/views/widget/desktop_aura/desktop_native_widget_aura.h"
 
 #include "base/bind.h"
 #include "base/debug/trace_event.h"
 #include "ui/aura/client/aura_constants.h"
 #include "ui/aura/client/cursor_client.h"
@@ skipping 100 matching lines @@
 
     aura::Window* native_window =
         top_level_handler->top_level_widget_->GetNativeView();
     child_window->AddObserver(top_level_handler);
     native_window->AddObserver(top_level_handler);
     top_level_handler->child_window_ = child_window;
     return native_window;
   }
 
   // aura::WindowObserver overrides
-  virtual void OnWindowDestroying(aura::Window* window) OVERRIDE {
+  virtual void OnWindowDestroying(aura::Window* window) override {
     window->RemoveObserver(this);
 
     // If the widget is being destroyed by the OS then we should not try and
     // destroy it again.
     if (top_level_widget_ &&
         window == top_level_widget_->GetNativeView()) {
       top_level_widget_ = NULL;
       return;
     }
 
     if (top_level_widget_) {
       DCHECK(top_level_widget_->GetNativeView());
       top_level_widget_->GetNativeView()->RemoveObserver(this);
       // When we receive a notification that the child of the window created
       // above is being destroyed we go ahead and initiate the destruction of
       // the corresponding widget.
       top_level_widget_->Close();
       top_level_widget_ = NULL;
     }
     delete this;
   }
 
   virtual void OnWindowBoundsChanged(aura::Window* window,
                                      const gfx::Rect& old_bounds,
-                                     const gfx::Rect& new_bounds) OVERRIDE {
+                                     const gfx::Rect& new_bounds) override {
     if (top_level_widget_ && window == child_window_)
       top_level_widget_->SetSize(new_bounds.size());
   }
 
  private:
   DesktopNativeWidgetTopLevelHandler()
       : top_level_widget_(NULL),
         child_window_(NULL) {}
 
   virtual ~DesktopNativeWidgetTopLevelHandler() {}
@@ skipping 12 matching lines @@
       : root_window_(root_window) {
     aura::client::SetWindowTreeClient(root_window_, this);
   }
   virtual ~DesktopNativeWidgetAuraWindowTreeClient() {
     aura::client::SetWindowTreeClient(root_window_, NULL);
   }
 
   // Overridden from client::WindowTreeClient:
   virtual aura::Window* GetDefaultParent(aura::Window* context,
                                          aura::Window* window,
-                                         const gfx::Rect& bounds) OVERRIDE {
+                                         const gfx::Rect& bounds) override {
     bool is_fullscreen = window->GetProperty(aura::client::kShowStateKey) ==
         ui::SHOW_STATE_FULLSCREEN;
     bool is_menu = window->type() == ui::wm::WINDOW_TYPE_MENU;
 
     if (is_fullscreen || is_menu) {
       bool root_is_always_on_top = false;
       internal::NativeWidgetPrivate* native_widget =
           DesktopNativeWidgetAura::ForWindow(root_window_);
       if (native_widget)
         root_is_always_on_top = native_widget->IsAlwaysOnTop();
@@ skipping 11 matching lines @@
 };
 
 }  // namespace
 
 class FocusManagerEventHandler : public ui::EventHandler {
  public:
   FocusManagerEventHandler(DesktopNativeWidgetAura* desktop_native_widget_aura)
       : desktop_native_widget_aura_(desktop_native_widget_aura) {}
 
   // Implementation of ui::EventHandler:
-  virtual void OnKeyEvent(ui::KeyEvent* event) OVERRIDE {
+  virtual void OnKeyEvent(ui::KeyEvent* event) override {
     Widget* widget = desktop_native_widget_aura_->GetWidget();
     if (widget && widget->GetFocusManager()->GetFocusedView() &&
         !widget->GetFocusManager()->OnKeyEvent(*event)) {
       event->SetHandled();
     }
   }
 
  private:
   DesktopNativeWidgetAura* desktop_native_widget_aura_;
 
   DISALLOW_COPY_AND_ASSIGN(FocusManagerEventHandler);
 };
 
 class RootWindowDestructionObserver : public aura::WindowObserver {
  public:
   explicit RootWindowDestructionObserver(DesktopNativeWidgetAura* parent)
     : parent_(parent) {}
   virtual ~RootWindowDestructionObserver() {}
 
  private:
   // Overridden from aura::WindowObserver:
-  virtual void OnWindowDestroyed(aura::Window* window) OVERRIDE {
+  virtual void OnWindowDestroyed(aura::Window* window) override {
     parent_->RootWindowDestroyed();
     window->RemoveObserver(this);
     delete this;
   }
 
   DesktopNativeWidgetAura* parent_;
 
   DISALLOW_COPY_AND_ASSIGN(RootWindowDestructionObserver);
 };
 
@@ skipping 967 matching lines @@
   if (cursor_reference_count_ == 0) {
     // We are the last DesktopNativeWidgetAura instance, and we are responsible
     // for cleaning up |cursor_manager_|.
     delete cursor_manager_;
     native_cursor_manager_ = NULL;
     cursor_manager_ = NULL;
   }
 }
 
 }  // namespace views