aura: Remove WindowTreeHost::PostNativeEvent().

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
 #endif
 
 #include "base/bind.h"
 #include "base/logging.h"
 #include "ui/aura/client/screen_position_client.h"
 #include "ui/aura/env.h"
 #include "ui/aura/test/aura_test_utils.h"
 #include "ui/aura/test/ui_controls_factory_aura.h"
+#include "ui/aura/test/x11_event_sender.h"
 #include "ui/aura/window_event_dispatcher.h"
 #include "ui/base/test/ui_controls_aura.h"
 #include "ui/base/x/x11_util.h"
 #include "ui/compositor/dip_util.h"
 #include "ui/events/keycodes/keyboard_code_conversion_x.h"
 #include "ui/events/test/platform_event_waiter.h"
 #include "ui/gfx/x/x11_connection.h"
 #include "ui/views/widget/desktop_aura/desktop_window_tree_host_x11.h"
 
 namespace views {
@@ skipping 68 matching lines @@
     if (control) {
       SetKeycodeAndSendThenMask(host, &xevent, XK_Control_L, ControlMask);
     }
     if (shift)
       SetKeycodeAndSendThenMask(host, &xevent, XK_Shift_L, ShiftMask);
     if (alt)
       SetKeycodeAndSendThenMask(host, &xevent, XK_Alt_L, Mod1Mask);
     xevent.xkey.keycode =
         XKeysymToKeycode(x_display_,
                          ui::XKeysymForWindowsKeyCode(key, shift));
-    host->PostNativeEvent(&xevent);
+    aura::test::PostEventToWindowTreeHost(xevent, host);
 
     // Send key release events.
     xevent.xkey.type = KeyRelease;
-    host->PostNativeEvent(&xevent);
+    aura::test::PostEventToWindowTreeHost(xevent, host);
     if (alt)
       UnmaskAndSetKeycodeThenSend(host, &xevent, Mod1Mask, XK_Alt_L);
     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;
@@ skipping 27 matching lines @@
       root_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;
       // RootWindow will take care of other necessary fields.
-      host->PostNativeEvent(&xevent);
+      aura::test::PostEventToWindowTreeHost(xevent, host);
     }
     RunClosureAfterAllPendingUIEvents(closure);
     return true;
   }
   bool SendMouseEvents(MouseButton type, int state) override {
     return SendMouseEventsNotifyWhenDone(type, state, base::Closure());
   }
   bool SendMouseEventsNotifyWhenDone(MouseButton type,
                                      int state,
                                      const base::Closure& closure) override {
@@ skipping 18 matching lines @@
         xbutton->state = Button2Mask;
         break;
       case RIGHT:
         xbutton->button = Button3;
         xbutton->state = Button3Mask;
         break;
     }
     // RootWindow will take care of other necessary fields.
     if (state & DOWN) {
       xevent.xbutton.type = ButtonPress;
-      root_window->GetHost()->PostNativeEvent(&xevent);
+      aura::test::PostEventToWindowTreeHost(xevent, root_window->GetHost());
       button_down_mask |= xbutton->state;
     }
     if (state & UP) {
       xevent.xbutton.type = ButtonRelease;
-      root_window->GetHost()->PostNativeEvent(&xevent);
+      aura::test::PostEventToWindowTreeHost(xevent, root_window->GetHost());
       button_down_mask = (button_down_mask | xbutton->state) ^ xbutton->state;
     }
     RunClosureAfterAllPendingUIEvents(closure);
     return true;
   }
   bool SendMouseClick(MouseButton type) override {
     return SendMouseEvents(type, UP | DOWN);
   }
   void RunClosureAfterAllPendingUIEvents(
       const base::Closure& closure) override {
@@ skipping 30 matching lines @@
     NOTREACHED() << "Coulding find RW for " << point.ToString() << " among "
                  << windows.size() << " RWs.";
     return NULL;
   }
 
   void SetKeycodeAndSendThenMask(aura::WindowTreeHost* host,
                                  XEvent* xevent,
                                  KeySym keysym,
                                  unsigned int mask) {
     xevent->xkey.keycode = XKeysymToKeycode(x_display_, keysym);
-    host->PostNativeEvent(xevent);
+    aura::test::PostEventToWindowTreeHost(*xevent, host);
     xevent->xkey.state |= mask;
   }
 
   void UnmaskAndSetKeycodeThenSend(aura::WindowTreeHost* host,
                                    XEvent* xevent,
                                    unsigned int mask,
                                    KeySym keysym) {
     xevent->xkey.state ^= mask;
     xevent->xkey.keycode = XKeysymToKeycode(x_display_, keysym);
-    host->PostNativeEvent(xevent);
+    aura::test::PostEventToWindowTreeHost(*xevent, host);
   }
 
   // Our X11 state.
   Display* x_display_;
   ::Window x_root_window_;
 
   // Input-only window used for events.
   ::Window x_window_;
 
   DISALLOW_COPY_AND_ASSIGN(UIControlsDesktopX11);
 };
 
 }  // namespace
 
 UIControlsAura* CreateUIControlsDesktopAura() {
   // The constructor of UIControlsDesktopX11 needs X11 connection to be
   // initialized.
   gfx::InitializeThreadedX11();
   return new UIControlsDesktopX11();
 }
 
 }  // namespace test
 }  // namespace views