x11: Prefer using ui::GetXDisplay() over getting the Display from the X11 message-pump.

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>
 
 // X macro fail.
 #if defined(RootWindow)
 #undef RootWindow
 #endif
 
 #include "base/logging.h"
-#include "base/message_loop/message_pump_x11.h"
 #include "ui/aura/client/screen_position_client.h"
 #include "ui/aura/env.h"
 #include "ui/aura/root_window.h"
 #include "ui/aura/test/ui_controls_factory_aura.h"
 #include "ui/base/keycodes/keyboard_code_conversion_x.h"
 #include "ui/base/test/ui_controls_aura.h"
+#include "ui/base/x/x11_util.h"
 #include "ui/compositor/dip_util.h"
 
 namespace aura {
 namespace test {
 namespace {
 
 using ui_controls::DOWN;
 using ui_controls::LEFT;
 using ui_controls::MIDDLE;
 using ui_controls::MouseButton;
@@ skipping 35 matching lines @@
   }
 
  private:
   base::Closure closure_;
   EventWaiterMatcher matcher_;
   DISALLOW_COPY_AND_ASSIGN(EventWaiter);
 };
 
 // Returns atom that indidates that the XEvent is marker event.
 Atom MarkerEventAtom() {
-  return XInternAtom(base::MessagePumpX11::GetDefaultXDisplay(),
-                     "marker_event",
-                     False);
+  return XInternAtom(ui::GetXDisplay(), "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();
 }
 
 class UIControlsX11 : public UIControlsAura {
  public:
@@ skipping 21 matching lines @@
     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::MessagePumpX11::GetDefaultXDisplay(),
+        XKeysymToKeycode(ui::GetXDisplay(),
                          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);
@@ skipping 89 matching lines @@
     }
     marker_event->xclient.message_type = MarkerEventAtom();
     root_window_->PostNativeEvent(marker_event);
     new EventWaiter(closure, &Matcher);
   }
  private:
   void SetKeycodeAndSendThenMask(XEvent* xevent,
                                  KeySym keysym,
                                  unsigned int mask) {
     xevent->xkey.keycode =
-        XKeysymToKeycode(base::MessagePumpX11::GetDefaultXDisplay(),
-                         keysym);
+        XKeysymToKeycode(ui::GetXDisplay(), keysym);
     root_window_->PostNativeEvent(xevent);
     xevent->xkey.state |= mask;
   }
 
   void UnmaskAndSetKeycodeThenSend(XEvent* xevent,
                                    unsigned int mask,
                                    KeySym keysym) {
     xevent->xkey.state ^= mask;
     xevent->xkey.keycode =
-        XKeysymToKeycode(base::MessagePumpX11::GetDefaultXDisplay(),
-                         keysym);
+        XKeysymToKeycode(ui::GetXDisplay(), keysym);
     root_window_->PostNativeEvent(xevent);
   }
 
   aura::RootWindow* root_window_;
 
   DISALLOW_COPY_AND_ASSIGN(UIControlsX11);
 };
 
 }  // namespace
 
 UIControlsAura* CreateUIControlsAura(aura::RootWindow* root_window) {
   return new UIControlsX11(root_window);
 }
 
 }  // namespace test
 }  // namespace aura