replace OVERRIDE and FINAL with override and final in ui/

ui/aura/test/ui_controls_factory_aurax11.cc

 // Copyright 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 <X11/keysym.h>
 #include <X11/Xlib.h>
 
 #include "base/bind.h"
 #include "base/logging.h"
 #include "ui/aura/client/screen_position_client.h"
@@ skipping 37 matching lines @@
 class UIControlsX11 : public UIControlsAura {
  public:
   UIControlsX11(WindowTreeHost* host) : host_(host) {
   }
 
   virtual bool SendKeyPress(gfx::NativeWindow window,
                             ui::KeyboardCode key,
                             bool control,
                             bool shift,
                             bool alt,
-                            bool command) OVERRIDE {
+                            bool command) override {
     return SendKeyPressNotifyWhenDone(
         window, key, control, shift, alt, command, base::Closure());
   }
   virtual bool SendKeyPressNotifyWhenDone(
       gfx::NativeWindow window,
       ui::KeyboardCode key,
       bool control,
       bool shift,
       bool alt,
       bool command,
-      const base::Closure& closure) OVERRIDE {
+      const base::Closure& closure) override {
     XEvent xevent = {0};
     xevent.xkey.type = KeyPress;
     if (control)
       SetKeycodeAndSendThenMask(&xevent, XK_Control_L, ControlMask);
     if (shift)
       SetKeycodeAndSendThenMask(&xevent, XK_Shift_L, ShiftMask);
     if (alt)
       SetKeycodeAndSendThenMask(&xevent, XK_Alt_L, Mod1Mask);
     if (command)
       SetKeycodeAndSendThenMask(&xevent, XK_Meta_L, Mod4Mask);
@@ skipping 11 matching lines @@
       UnmaskAndSetKeycodeThenSend(&xevent, ShiftMask, XK_Shift_L);
     if (control)
       UnmaskAndSetKeycodeThenSend(&xevent, ControlMask, XK_Control_L);
     if (command)
       UnmaskAndSetKeycodeThenSend(&xevent, Mod4Mask, XK_Meta_L);
     DCHECK(!xevent.xkey.state);
     RunClosureAfterAllPendingUIEvents(closure);
     return true;
   }
 
-  virtual bool SendMouseMove(long screen_x, long screen_y) OVERRIDE {
+  virtual bool SendMouseMove(long screen_x, long screen_y) override {
     return SendMouseMoveNotifyWhenDone(screen_x, screen_y, base::Closure());
   }
   virtual bool SendMouseMoveNotifyWhenDone(
       long screen_x,
       long screen_y,
-      const base::Closure& closure) OVERRIDE {
+      const base::Closure& closure) override {
     gfx::Point root_location(screen_x, screen_y);
     aura::client::ScreenPositionClient* screen_position_client =
         aura::client::GetScreenPositionClient(host_->window());
     if (screen_position_client) {
       screen_position_client->ConvertPointFromScreen(host_->window(),
                                                      &root_location);
     }
     gfx::Point root_current_location =
         QueryLatestMousePositionRequestInHost(host_);
     host_->ConvertPointFromHost(&root_current_location);
 
     if (root_location != root_current_location && button_down_mask == 0) {
       // Move the cursor because EnterNotify/LeaveNotify are generated with the
       // current mouse position as a result of XGrabPointer()
       host_->window()->MoveCursorTo(root_location);
     } else {
       XEvent xevent = {0};
       XMotionEvent* xmotion = &xevent.xmotion;
       xmotion->type = MotionNotify;
       xmotion->x = root_location.x();
       xmotion->y = root_location.y();
       xmotion->state = button_down_mask;
       xmotion->same_screen = True;
       // WindowTreeHost will take care of other necessary fields.
       host_->PostNativeEvent(&xevent);
     }
     RunClosureAfterAllPendingUIEvents(closure);
     return true;
   }
-  virtual bool SendMouseEvents(MouseButton type, int state) OVERRIDE {
+  virtual bool SendMouseEvents(MouseButton type, int state) override {
     return SendMouseEventsNotifyWhenDone(type, state, base::Closure());
   }
   virtual bool SendMouseEventsNotifyWhenDone(
       MouseButton type,
       int state,
-      const base::Closure& closure) OVERRIDE {
+      const base::Closure& closure) override {
     XEvent xevent = {0};
     XButtonEvent* xbutton = &xevent.xbutton;
     gfx::Point mouse_loc = aura::Env::GetInstance()->last_mouse_location();
     aura::client::ScreenPositionClient* screen_position_client =
           aura::client::GetScreenPositionClient(host_->window());
     if (screen_position_client) {
       screen_position_client->ConvertPointFromScreen(host_->window(),
                                                      &mouse_loc);
     }
     xbutton->x = mouse_loc.x();
@@ skipping 20 matching lines @@
       button_down_mask |= xbutton->state;
     }
     if (state & UP) {
       xevent.xbutton.type = ButtonRelease;
       host_->PostNativeEvent(&xevent);
       button_down_mask = (button_down_mask | xbutton->state) ^ xbutton->state;
     }
     RunClosureAfterAllPendingUIEvents(closure);
     return true;
   }
-  virtual bool SendMouseClick(MouseButton type) OVERRIDE {
+  virtual bool SendMouseClick(MouseButton type) override {
     return SendMouseEvents(type, UP | DOWN);
   }
   virtual void RunClosureAfterAllPendingUIEvents(
-      const base::Closure& closure) OVERRIDE {
+      const base::Closure& closure) override {
     if (closure.is_null())
       return;
     static XEvent* marker_event = NULL;
     if (!marker_event) {
       marker_event = new XEvent();
       marker_event->xclient.type = ClientMessage;
       marker_event->xclient.display = NULL;
       marker_event->xclient.window = None;
       marker_event->xclient.format = 8;
     }
@@ skipping 26 matching lines @@
 };
 
 }  // namespace
 
 UIControlsAura* CreateUIControlsAura(WindowTreeHost* host) {
   return new UIControlsX11(host);
 }
 
 }  // namespace test
 }  // namespace aura