aura-x11: Make sure the events targetted for root-window reaches all the root-window dispatchers.

base/message_pump_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 "base/message_pump_aurax11.h"
 
 #include <glib.h>
+#include <X11/X.h>
 #include <X11/extensions/XInput2.h>
 #include <X11/XKBlib.h>
 
 #include "base/basictypes.h"
 #include "base/message_loop.h"
 
 namespace {
 
 gboolean XSourcePrepare(GSource* source, gint* timeout_ms) {
   if (XPending(base::MessagePumpAuraX11::GetDefaultXDisplay()))
@@ skipping 23 matching lines @@
 
 // The connection is essentially a global that's accessed through a static
 // method and destroyed whenever ~MessagePumpAuraX11() is called. We do this
 // for historical reasons so user code can call
 // MessagePumpForUI::GetDefaultXDisplay() where MessagePumpForUI is a typedef
 // to whatever type in the current build.
 //
 // TODO(erg): This can be changed to something more sane like
 // MessagePumpAuraX11::Current()->display() once MessagePumpGtk goes away.
 Display* g_xdisplay = NULL;
+int g_xinput_opcode = -1;
 
 bool InitializeXInput2Internal() {
   Display* display = base::MessagePumpAuraX11::GetDefaultXDisplay();
   if (!display)
     return false;
 
   int event, err;
 
   int xiopcode;
   if (!XQueryExtension(display, "XInputExtension", &xiopcode, &event, &err)) {
     DVLOG(1) << "X Input extension not available.";
     return false;
   }
+  g_xinput_opcode = xiopcode;
 
 #if defined(USE_XI2_MT)
   // USE_XI2_MT also defines the required XI2 minor minimum version.
   int major = 2, minor = USE_XI2_MT;
 #else
   int major = 2, minor = 0;
 #endif
   if (XIQueryVersion(display, &major, &minor) == BadRequest) {
     DVLOG(1) << "XInput2 not supported in the server.";
     return false;
   }
 #if defined(USE_XI2_MT)
   if (major < 2 || (major == 2 && minor < USE_XI2_MT)) {
     DVLOG(1) << "XI version on server is " << major << "." << minor << ". "
             << "But 2." << USE_XI2_MT << " is required.";
     return false;
   }
 #endif
 
   return true;
 }
 
+Window FindEventTarget(const base::NativeEvent& xev) {
+  Window target = xev->xany.window;
+  if (xev->type == GenericEvent &&
+      static_cast<XIEvent*>(xev->xcookie.data)->extension == g_xinput_opcode) {
+    target = static_cast<XIDeviceEvent*>(xev->xcookie.data)->event;
+  }
+  return target;
+}
+
 bool InitializeXInput2() {
   static bool xinput2_supported = InitializeXInput2Internal();
   return xinput2_supported;
 }
 
 bool InitializeXkb() {
   Display* display = base::MessagePumpAuraX11::GetDefaultXDisplay();
   if (!display)
     return false;
 
@@ skipping 170 matching lines @@
   }
   return false;
 }
 
 void MessagePumpAuraX11::DidProcessXEvent(XEvent* xevent) {
   FOR_EACH_OBSERVER(MessagePumpObserver, observers(), DidProcessEvent(xevent));
 }
 
 MessagePumpDispatcher* MessagePumpAuraX11::GetDispatcherForXEvent(
     const base::NativeEvent& xev) const {
-  ::Window x_window = xev->xany.window;
-  if (xev->type == GenericEvent) {
-    XIDeviceEvent* xievent = static_cast<XIDeviceEvent*>(xev->xcookie.data);
-    x_window = xievent->event;
-  }
+  ::Window x_window = FindEventTarget(xev);
   DispatchersMap::const_iterator it = dispatchers_.find(x_window);
   return it != dispatchers_.end() ? it->second : NULL;
 }
 
 bool MessagePumpAuraX11::Dispatch(const base::NativeEvent& xev) {
   // MappingNotify events (meaning that the keyboard or pointer buttons have
   // been remapped) aren't associated with a window; send them to all
   // dispatchers.
   if (xev->type == MappingNotify) {
     for (DispatchersMap::const_iterator it = dispatchers_.begin();
          it != dispatchers_.end(); ++it) {
       it->second->Dispatch(xev);
     }
     return true;
   }
-  if (xev->xany.window == x_root_window_) {
+
+  if (FindEventTarget(xev) == x_root_window_) {
     for (Dispatchers::const_iterator it = root_window_dispatchers_.begin();
          it != root_window_dispatchers_.end();
          ++it) {
       (*it)->Dispatch(xev);
     }
     return true;
   }
   MessagePumpDispatcher* dispatcher = GetDispatcherForXEvent(xev);
   return dispatcher ? dispatcher->Dispatch(xev) : true;
 }
 
 }  // namespace base