Revert 113177 - process all ui events before posting closure because menu depends on ui events to...

chrome/browser/automation/ui_controls_aurax11.cc

 // Copyright (c) 2011 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 "chrome/browser/automation/ui_controls.h"
 
 #include <X11/keysym.h>
 #include <X11/Xlib.h>
 
 #include "base/callback.h"
@@ skipping 52 matching lines @@
                      "marker_event",
                      False);
 }
 
 // Returns true when the event is a marker event.
 bool Matcher(const base::NativeEvent& event) {
   return event->xany.type == ClientMessage &&
       event->xclient.message_type == MarkerEventAtom();
 }
 
+void RunClosureAfterEvents(const base::Closure closure) {
+  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;
+  }
+  marker_event->xclient.message_type = MarkerEventAtom();
+  aura::Desktop::GetInstance()->PostNativeEvent(marker_event);
+  new EventWaiter(closure, &Matcher);
+}
+
 }  // namespace
 
 namespace ui_controls {
 
 bool SendKeyPress(gfx::NativeWindow window,
                   ui::KeyboardCode key,
                   bool control,
                   bool shift,
                   bool alt,
                   bool command) {
@@ skipping 27 matching lines @@
                                 const base::Closure& closure) {
   DCHECK(!command);  // No command key on Aura
   XEvent xevent = {0};
   xevent.xkey.type = KeyPress;
   if (control)
     SetMaskAndKeycodeThenSend(&xevent, ControlMask, XK_Control_L);
   if (shift)
     SetMaskAndKeycodeThenSend(&xevent, ShiftMask, XK_Shift_L);
   if (alt)
     SetMaskAndKeycodeThenSend(&xevent, Mod1Mask, XK_Alt_L);
-  xevent.xkey.keycode = ui::XKeysymForWindowsKeyCode(key, shift);
+  xevent.xkey.keycode =
+      XKeysymToKeycode(base::MessagePumpX::GetDefaultXDisplay(),
+                       ui::XKeysymForWindowsKeyCode(key, shift));
   aura::Desktop::GetInstance()->PostNativeEvent(&xevent);
 
   // Send key release events.
   xevent.xkey.type = KeyRelease;
   aura::Desktop::GetInstance()->PostNativeEvent(&xevent);
   if (alt)
     SetKeycodeAndSendThenUnmask(&xevent, Mod1Mask, XK_Alt_L);
   if (shift)
     SetKeycodeAndSendThenUnmask(&xevent, ShiftMask, XK_Shift_L);
   if (control)
     SetKeycodeAndSendThenUnmask(&xevent, ControlMask, XK_Control_L);
   DCHECK(!xevent.xkey.state);
-  RunClosureAfterAllPendingUIEvents(closure);
+  RunClosureAfterEvents(closure);
   return true;
 }
 
 bool SendMouseMove(long x, long y) {
   return SendMouseMoveNotifyWhenDone(x, y, base::Closure());
 }
 
 bool SendMouseMoveNotifyWhenDone(long x, long y, const base::Closure& closure) {
   XEvent xevent = {0};
   XMotionEvent* xmotion = &xevent.xmotion;
   xmotion->type = MotionNotify;
   g_current_x = xmotion->x = x;
   g_current_y = xmotion->y = y;
   xmotion->same_screen = True;
   // Desktop will take care of other necessary fields.
   aura::Desktop::GetInstance()->PostNativeEvent(&xevent);
-  RunClosureAfterAllPendingUIEvents(closure);
+  RunClosureAfterEvents(closure);
   return false;
 }
 
 bool SendMouseEvents(MouseButton type, int state) {
   return SendMouseEventsNotifyWhenDone(type, state, base::Closure());
 }
 
 bool SendMouseEventsNotifyWhenDone(MouseButton type,
                                    int state,
                                    const base::Closure& closure) {
@@ skipping 22 matching lines @@
 
   aura::Desktop* desktop = aura::Desktop::GetInstance();
   if (state & DOWN) {
     xevent.xbutton.type = ButtonPress;
     desktop->PostNativeEvent(&xevent);
   }
   if (state & UP) {
     xevent.xbutton.type = ButtonRelease;
     desktop->PostNativeEvent(&xevent);
   }
-  RunClosureAfterAllPendingUIEvents(closure);
+  RunClosureAfterEvents(closure);
   return false;
 }
 
 bool SendMouseClick(MouseButton type) {
   return SendMouseEvents(type, UP | DOWN);
 }
 
 void MoveMouseToCenterAndPress(views::View* view, MouseButton button,
                                int state, const base::Closure& closure) {
   DCHECK(view);
   DCHECK(view->GetWidget());
   gfx::Point view_center(view->width() / 2, view->height() / 2);
   views::View::ConvertPointToScreen(view, &view_center);
   SendMouseMove(view_center.x(), view_center.y());
   SendMouseEventsNotifyWhenDone(button, state, closure);
 }
 
-void RunClosureAfterAllPendingUIEvents(const base::Closure& closure) {
-  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;
-  }
-  marker_event->xclient.message_type = MarkerEventAtom();
-  aura::Desktop::GetInstance()->PostNativeEvent(marker_event);
-  new EventWaiter(closure, &Matcher);
-}
-
 }  // namespace ui_controls