Linux/ChromeOS Chromium style checker cleanup, chrome/ edition part 1.

chrome/test/base/ui_controls_aurax11.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 <X11/keysym.h>
 #include <X11/Xlib.h>
 
 // X macro fail.
 #if defined(RootWindow)
 #undef RootWindow
@@ skipping 69 matching lines @@
 class UIControlsX11 : public UIControlsAura {
  public:
   UIControlsX11(aura::RootWindow* root_window) : root_window_(root_window) {
   }
 
   virtual bool SendKeyPress(gfx::NativeWindow window,
                             ui::KeyboardCode key,
                             bool control,
                             bool shift,
                             bool alt,
-                            bool command) {
+                            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) {
+  virtual 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
     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);
     xevent.xkey.keycode =
         XKeysymToKeycode(base::MessagePumpAuraX11::GetDefaultXDisplay(),
                          ui::XKeysymForWindowsKeyCode(key, shift));
     root_window_->PostNativeEvent(&xevent);
 
     // Send key release events.
     xevent.xkey.type = KeyRelease;
     root_window_->PostNativeEvent(&xevent);
     if (alt)
       UnmaskAndSetKeycodeThenSend(&xevent, Mod1Mask, XK_Alt_L);
     if (shift)
       UnmaskAndSetKeycodeThenSend(&xevent, ShiftMask, XK_Shift_L);
     if (control)
       UnmaskAndSetKeycodeThenSend(&xevent, ControlMask, XK_Control_L);
     DCHECK(!xevent.xkey.state);
     RunClosureAfterAllPendingUIEvents(closure);
     return true;
   }
 
   // Simulate a mouse move. (x,y) are absolute screen coordinates.
-  virtual bool SendMouseMove(long x, long y) {
+  virtual bool SendMouseMove(long x, long y) OVERRIDE {
     return SendMouseMoveNotifyWhenDone(x, y, base::Closure());
   }
-  virtual bool SendMouseMoveNotifyWhenDone(long x,
-                                           long y,
-                                           const base::Closure& closure) {
+  virtual bool SendMouseMoveNotifyWhenDone(
+      long x,
+      long y,
+      const base::Closure& closure) OVERRIDE {
     XEvent xevent = {0};
     XMotionEvent* xmotion = &xevent.xmotion;
     xmotion->type = MotionNotify;
     gfx::Point point = ui::ConvertPointToPixel(
         root_window_->layer(),
         gfx::Point(static_cast<int>(x), static_cast<int>(y)));
     g_current_x = xmotion->x = point.x();
     g_current_y = xmotion->y = point.y();
     xmotion->state = button_down_mask;
     xmotion->same_screen = True;
     // RootWindow will take care of other necessary fields.
     root_window_->PostNativeEvent(&xevent);
     RunClosureAfterAllPendingUIEvents(closure);
     return true;
   }
-  virtual bool SendMouseEvents(MouseButton type, int state) {
+  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) {
+  virtual bool SendMouseEventsNotifyWhenDone(
+      MouseButton type,
+      int state,
+      const base::Closure& closure) OVERRIDE {
     XEvent xevent = {0};
     XButtonEvent* xbutton = &xevent.xbutton;
     DCHECK_NE(g_current_x, -1000);
     DCHECK_NE(g_current_y, -1000);
     xbutton->x = g_current_x;
     xbutton->y = g_current_y;
     xbutton->same_screen = True;
     switch (type) {
       case LEFT:
         xbutton->button = Button1;
@@ skipping 15 matching lines @@
       button_down_mask |= xbutton->state;
     }
     if (state & UP) {
       xevent.xbutton.type = ButtonRelease;
       root_window_->PostNativeEvent(&xevent);
       button_down_mask = (button_down_mask | xbutton->state) ^ xbutton->state;
     }
     RunClosureAfterAllPendingUIEvents(closure);
     return true;
   }
-  virtual bool SendMouseClick(MouseButton type) {
+  virtual bool SendMouseClick(MouseButton type) OVERRIDE {
     return SendMouseEvents(type, UP | DOWN);
   }
-  virtual void RunClosureAfterAllPendingUIEvents(const base::Closure& closure) {
+  virtual 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 = NULL;
       marker_event->xclient.window = None;
       marker_event->xclient.format = 8;
     }
@@ skipping 27 matching lines @@
   DISALLOW_COPY_AND_ASSIGN(UIControlsX11);
 };
 
 }  // namespace
 
 UIControlsAura* CreateUIControlsAura(aura::RootWindow* root_window) {
   return new UIControlsX11(root_window);
 }
 
 }  // namespace ui_controls