base/message_pump_aurax11.cc

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "base/message_pump_aurax11.h"
   6
   7 #include <glib.h>
   8 #include <X11/X.h>
   9 #include <X11/extensions/XInput2.h>
  10 #include <X11/XKBlib.h>
  11
  12 #include "base/basictypes.h"
  13 #include "base/message_loop.h"
  14
  15 namespace {
  16
  17 gboolean XSourcePrepare(GSource* source, gint* timeout_ms) {
  18   if (XPending(base::MessagePumpAuraX11::GetDefaultXDisplay()))
  19     *timeout_ms = 0;
  20   else
  21     *timeout_ms = -1;
  22   return FALSE;
  23 }
  24
  25 gboolean XSourceCheck(GSource* source) {
  26   return XPending(base::MessagePumpAuraX11::GetDefaultXDisplay());
  27 }
  28
  29 gboolean XSourceDispatch(GSource* source,
  30                          GSourceFunc unused_func,
  31                          gpointer data) {
  32   base::MessagePumpAuraX11* pump = static_cast<base::MessagePumpAuraX11*>(data);
  33   return pump->DispatchXEvents();
  34 }
  35
  36 GSourceFuncs XSourceFuncs = {
  37   XSourcePrepare,
  38   XSourceCheck,
  39   XSourceDispatch,
  40   NULL
  41 };
  42
  43 // The connection is essentially a global that's accessed through a static
  44 // method and destroyed whenever ~MessagePumpAuraX11() is called. We do this
  45 // for historical reasons so user code can call
  46 // MessagePumpForUI::GetDefaultXDisplay() where MessagePumpForUI is a typedef
  47 // to whatever type in the current build.
  48 //
  49 // TODO(erg): This can be changed to something more sane like
  50 // MessagePumpAuraX11::Current()->display() once MessagePumpGtk goes away.
  51 Display* g_xdisplay = NULL;
  52 int g_xinput_opcode = -1;
  53
  54 bool InitializeXInput2Internal() {
  55   Display* display = base::MessagePumpAuraX11::GetDefaultXDisplay();
  56   if (!display)
  57     return false;
  58
  59   int event, err;
  60
  61   int xiopcode;
  62   if (!XQueryExtension(display, "XInputExtension", &xiopcode, &event, &err)) {
  63     DVLOG(1) << "X Input extension not available.";
  64     return false;
  65   }
  66   g_xinput_opcode = xiopcode;
  67
  68 #if defined(USE_XI2_MT)
  69   // USE_XI2_MT also defines the required XI2 minor minimum version.
  70   int major = 2, minor = USE_XI2_MT;
  71 #else
  72   int major = 2, minor = 0;
  73 #endif
  74   if (XIQueryVersion(display, &major, &minor) == BadRequest) {
  75     DVLOG(1) << "XInput2 not supported in the server.";
  76     return false;
  77   }
  78 #if defined(USE_XI2_MT)
  79   if (major < 2 || (major == 2 && minor < USE_XI2_MT)) {
  80     DVLOG(1) << "XI version on server is " << major << "." << minor << ". "
  81             << "But 2." << USE_XI2_MT << " is required.";
  82     return false;
  83   }
  84 #endif
  85
  86   return true;
  87 }
  88
  89 Window FindEventTarget(const base::NativeEvent& xev) {
  90   Window target = xev->xany.window;
  91   if (xev->type == GenericEvent &&
  92       static_cast<XIEvent*>(xev->xcookie.data)->extension == g_xinput_opcode) {
  93     target = static_cast<XIDeviceEvent*>(xev->xcookie.data)->event;
  94   }
  95   return target;
  96 }
  97
  98 bool InitializeXInput2() {
  99   static bool xinput2_supported = InitializeXInput2Internal();
 100   return xinput2_supported;
 101 }
 102
 103 bool InitializeXkb() {
 104   Display* display = base::MessagePumpAuraX11::GetDefaultXDisplay();
 105   if (!display)
 106     return false;
 107
 108   int opcode, event, error;
 109   int major = XkbMajorVersion;
 110   int minor = XkbMinorVersion;
 111   if (!XkbQueryExtension(display, &opcode, &event, &error, &major, &minor)) {
 112     DVLOG(1) << "Xkb extension not available.";
 113     return false;
 114   }
 115
 116   // Ask the server not to send KeyRelease event when the user holds down a key.
 117   // crbug.com/138092
 118   Bool supported_return;
 119   if (!XkbSetDetectableAutoRepeat(display, True, &supported_return)) {
 120     DVLOG(1) << "XKB not supported in the server.";
 121     return false;
 122   }
 123
 124   return true;
 125 }
 126
 127 }  // namespace
 128
 129 namespace base {
 130
 131 MessagePumpAuraX11::MessagePumpAuraX11() : MessagePumpGlib(),
 132     x_source_(NULL) {
 133   InitializeXInput2();
 134   InitializeXkb();
 135   InitXSource();
 136
 137   // Can't put this in the initializer list because g_xdisplay may not exist
 138   // until after InitXSource().
 139   x_root_window_ = DefaultRootWindow(g_xdisplay);
 140 }
 141
 142 // static
 143 Display* MessagePumpAuraX11::GetDefaultXDisplay() {
 144   if (!g_xdisplay)
 145     g_xdisplay = XOpenDisplay(NULL);
 146   return g_xdisplay;
 147 }
 148
 149 // static
 150 bool MessagePumpAuraX11::HasXInput2() {
 151   return InitializeXInput2();
 152 }
 153
 154 // static
 155 MessagePumpAuraX11* MessagePumpAuraX11::Current() {
 156   MessageLoopForUI* loop = MessageLoopForUI::current();
 157   return static_cast<MessagePumpAuraX11*>(loop->pump_ui());
 158 }
 159
 160 void MessagePumpAuraX11::AddDispatcherForWindow(
 161     MessagePumpDispatcher* dispatcher,
 162     unsigned long xid) {
 163   dispatchers_.insert(std::make_pair(xid, dispatcher));
 164 }
 165
 166 void MessagePumpAuraX11::RemoveDispatcherForWindow(unsigned long xid) {
 167   dispatchers_.erase(xid);
 168 }
 169
 170 void MessagePumpAuraX11::AddDispatcherForRootWindow(
 171     MessagePumpDispatcher* dispatcher) {
 172   DCHECK(std::find(root_window_dispatchers_.begin(),
 173                    root_window_dispatchers_.end(),
 174                    dispatcher) ==
 175          root_window_dispatchers_.end());
 176   root_window_dispatchers_.push_back(dispatcher);
 177 }
 178
 179 void MessagePumpAuraX11::RemoveDispatcherForRootWindow(
 180     MessagePumpDispatcher* dispatcher) {
 181   root_window_dispatchers_.erase(
 182       std::remove(root_window_dispatchers_.begin(),
 183                   root_window_dispatchers_.end(),
 184                   dispatcher));
 185 }
 186
 187 bool MessagePumpAuraX11::DispatchXEvents() {
 188   Display* display = GetDefaultXDisplay();
 189   DCHECK(display);
 190   MessagePumpDispatcher* dispatcher =
 191       GetDispatcher() ? GetDispatcher() : this;
 192
 193   // In the general case, we want to handle all pending events before running
 194   // the tasks. This is what happens in the message_pump_glib case.
 195   while (XPending(display)) {
 196     XEvent xev;
 197     XNextEvent(display, &xev);
 198     if (dispatcher && ProcessXEvent(dispatcher, &xev))
 199       return TRUE;
 200   }
 201   return TRUE;
 202 }
 203
 204 void MessagePumpAuraX11::BlockUntilWindowMapped(unsigned long xid) {
 205   XEvent event;
 206
 207   Display* display = GetDefaultXDisplay();
 208   DCHECK(display);
 209
 210   MessagePumpDispatcher* dispatcher =
 211       GetDispatcher() ? GetDispatcher() : this;
 212
 213   do {
 214     // Block until there's a message of |event_mask| type on |w|. Then remove
 215     // it from the queue and stuff it in |event|.
 216     XWindowEvent(display, xid, StructureNotifyMask, &event);
 217     ProcessXEvent(dispatcher, &event);
 218   } while (event.type != MapNotify);
 219 }
 220
 221 MessagePumpAuraX11::~MessagePumpAuraX11() {
 222   g_source_destroy(x_source_);
 223   g_source_unref(x_source_);
 224   XCloseDisplay(g_xdisplay);
 225   g_xdisplay = NULL;
 226 }
 227
 228 void MessagePumpAuraX11::InitXSource() {
 229   // CHECKs are to help track down crbug.com/113106.
 230   CHECK(!x_source_);
 231   Display* display = GetDefaultXDisplay();
 232   CHECK(display) << "Unable to get connection to X server";
 233   x_poll_.reset(new GPollFD());
 234   CHECK(x_poll_.get());
 235   x_poll_->fd = ConnectionNumber(display);
 236   x_poll_->events = G_IO_IN;
 237
 238   x_source_ = g_source_new(&XSourceFuncs, sizeof(GSource));
 239   g_source_add_poll(x_source_, x_poll_.get());
 240   g_source_set_can_recurse(x_source_, TRUE);
 241   g_source_set_callback(x_source_, NULL, this, NULL);
 242   g_source_attach(x_source_, g_main_context_default());
 243 }
 244
 245 bool MessagePumpAuraX11::ProcessXEvent(MessagePumpDispatcher* dispatcher,
 246                                        XEvent* xev) {
 247   bool should_quit = false;
 248
 249   bool have_cookie = false;
 250   if (xev->type == GenericEvent &&
 251       XGetEventData(xev->xgeneric.display, &xev->xcookie)) {
 252     have_cookie = true;
 253   }
 254
 255   if (!WillProcessXEvent(xev)) {
 256     if (!dispatcher->Dispatch(xev)) {
 257       should_quit = true;
 258       Quit();
 259     }
 260     DidProcessXEvent(xev);
 261   }
 262
 263   if (have_cookie) {
 264     XFreeEventData(xev->xgeneric.display, &xev->xcookie);
 265   }
 266
 267   return should_quit;
 268 }
 269
 270 bool MessagePumpAuraX11::WillProcessXEvent(XEvent* xevent) {
 271   if (!observers().might_have_observers())
 272     return false;
 273   ObserverListBase<MessagePumpObserver>::Iterator it(observers());
 274   MessagePumpObserver* obs;
 275   while ((obs = it.GetNext()) != NULL) {
 276     if (obs->WillProcessEvent(xevent))
 277       return true;
 278   }
 279   return false;
 280 }
 281
 282 void MessagePumpAuraX11::DidProcessXEvent(XEvent* xevent) {
 283   FOR_EACH_OBSERVER(MessagePumpObserver, observers(), DidProcessEvent(xevent));
 284 }
 285
 286 MessagePumpDispatcher* MessagePumpAuraX11::GetDispatcherForXEvent(
 287     const base::NativeEvent& xev) const {
 288   ::Window x_window = FindEventTarget(xev);
 289   DispatchersMap::const_iterator it = dispatchers_.find(x_window);
 290   return it != dispatchers_.end() ? it->second : NULL;
 291 }
 292
 293 bool MessagePumpAuraX11::Dispatch(const base::NativeEvent& xev) {
 294   // MappingNotify events (meaning that the keyboard or pointer buttons have
 295   // been remapped) aren't associated with a window; send them to all
 296   // dispatchers.
 297   if (xev->type == MappingNotify) {
 298     for (DispatchersMap::const_iterator it = dispatchers_.begin();
 299          it != dispatchers_.end(); ++it) {
 300       it->second->Dispatch(xev);
 301     }
 302     return true;
 303   }
 304
 305   if (FindEventTarget(xev) == x_root_window_) {
 306     for (Dispatchers::const_iterator it = root_window_dispatchers_.begin();
 307          it != root_window_dispatchers_.end();
 308          ++it) {
 309       (*it)->Dispatch(xev);
 310     }
 311     return true;
 312   }
 313   MessagePumpDispatcher* dispatcher = GetDispatcherForXEvent(xev);
 314   return dispatcher ? dispatcher->Dispatch(xev) : true;
 315 }
 316
 317 }  // namespace base