Standardize usage of virtual/override/final specifiers.

ui/views/test/ui_controls_factory_desktop_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>
 
 // X macro fail.
 #if defined(RootWindow)
 #undef RootWindow
@@ skipping 50 matching lines @@
             -100, -100, 10, 10,  // x, y, width, height
             0,                   // border width
             CopyFromParent,      // depth
             InputOnly,
             CopyFromParent,      // visual
             0,
             NULL)) {
     XStoreName(x_display_, x_window_, "Chromium UIControlsDesktopX11 Window");
   }
 
-  virtual ~UIControlsDesktopX11() {
-    XDestroyWindow(x_display_, x_window_);
-  }
+  ~UIControlsDesktopX11() override { XDestroyWindow(x_display_, x_window_); }
 
-  virtual bool SendKeyPress(gfx::NativeWindow window,
-                            ui::KeyboardCode key,
-                            bool control,
-                            bool shift,
-                            bool alt,
-                            bool command) override {
+  bool SendKeyPress(gfx::NativeWindow window,
+                    ui::KeyboardCode key,
+                    bool control,
+                    bool shift,
+                    bool alt,
+                    bool command) override {
     DCHECK(!command);  // No command key on Aura
     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 {
+  bool SendKeyPressNotifyWhenDone(gfx::NativeWindow window,
+                                  ui::KeyboardCode key,
+                                  bool control,
+                                  bool shift,
+                                  bool alt,
+                                  bool command,
+                                  const base::Closure& closure) override {
     DCHECK(!command);  // No command key on Aura
 
     aura::WindowTreeHost* host = window->GetHost();
 
     XEvent xevent = {0};
     xevent.xkey.type = KeyPress;
     if (control) {
       SetKeycodeAndSendThenMask(host, &xevent, XK_Control_L, ControlMask);
     }
     if (shift)
@@ skipping 13 matching lines @@
     if (shift)
       UnmaskAndSetKeycodeThenSend(host, &xevent, ShiftMask, XK_Shift_L);
     if (control) {
       UnmaskAndSetKeycodeThenSend(host, &xevent, ControlMask, XK_Control_L);
     }
     DCHECK(!xevent.xkey.state);
     RunClosureAfterAllPendingUIEvents(closure);
     return true;
   }
 
-  virtual bool SendMouseMove(long screen_x, long screen_y) override {
+  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 {
+  bool SendMouseMoveNotifyWhenDone(long screen_x,
+                                   long screen_y,
+                                   const base::Closure& closure) override {
     gfx::Point screen_location(screen_x, screen_y);
     gfx::Point root_location = screen_location;
     aura::Window* root_window = RootWindowForPoint(screen_location);
 
     aura::client::ScreenPositionClient* screen_position_client =
           aura::client::GetScreenPositionClient(root_window);
     if (screen_position_client) {
       screen_position_client->ConvertPointFromScreen(root_window,
                                                      &root_location);
     }
@@ skipping 14 matching lines @@
       xmotion->x = root_location.x();
       xmotion->y = root_location.y();
       xmotion->state = button_down_mask;
       xmotion->same_screen = True;
       // RootWindow will take care of other necessary fields.
       host->PostNativeEvent(&xevent);
     }
     RunClosureAfterAllPendingUIEvents(closure);
     return true;
   }
-  virtual bool SendMouseEvents(MouseButton type, int state) override {
+  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 {
+  bool SendMouseEventsNotifyWhenDone(MouseButton type,
+                                     int state,
+                                     const base::Closure& closure) override {
     XEvent xevent = {0};
     XButtonEvent* xbutton = &xevent.xbutton;
     gfx::Point mouse_loc = aura::Env::GetInstance()->last_mouse_location();
     aura::Window* root_window = RootWindowForPoint(mouse_loc);
     aura::client::ScreenPositionClient* screen_position_client =
           aura::client::GetScreenPositionClient(root_window);
     if (screen_position_client)
       screen_position_client->ConvertPointFromScreen(root_window, &mouse_loc);
     xbutton->x = mouse_loc.x();
     xbutton->y = mouse_loc.y();
@@ skipping 19 matching lines @@
       button_down_mask |= xbutton->state;
     }
     if (state & UP) {
       xevent.xbutton.type = ButtonRelease;
       root_window->GetHost()->PostNativeEvent(&xevent);
       button_down_mask = (button_down_mask | xbutton->state) ^ xbutton->state;
     }
     RunClosureAfterAllPendingUIEvents(closure);
     return true;
   }
-  virtual bool SendMouseClick(MouseButton type) override {
+  bool SendMouseClick(MouseButton type) override {
     return SendMouseEvents(type, UP | DOWN);
   }
-  virtual void RunClosureAfterAllPendingUIEvents(
+  void RunClosureAfterAllPendingUIEvents(
       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 = x_display_;
       marker_event->xclient.window = x_window_;
       marker_event->xclient.format = 8;
@@ skipping 55 matching lines @@
 
 UIControlsAura* CreateUIControlsDesktopAura() {
   // The constructor of UIControlsDesktopX11 needs X11 connection to be
   // initialized.
   gfx::InitializeThreadedX11();
   return new UIControlsDesktopX11();
 }
 
 }  // namespace test
 }  // namespace views