aura: Make sure the root-window retains the X events it was already listening for.

ui/aura/root_window_host_linux.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 "ui/aura/root_window_host_linux.h"
 
 #include <X11/cursorfont.h>
 #include <X11/extensions/Xfixes.h>
 #include <X11/extensions/XInput2.h>
 #include <X11/extensions/Xrandr.h>
@@ skipping 51 matching lines @@
 const char kRootWindowHostLinuxKey[] = "__AURA_ROOT_WINDOW_HOST_LINUX__";
 
 const char* kAtomsToCache[] = {
   "WM_DELETE_WINDOW",
   "_NET_WM_PING",
   "_NET_WM_PID",
   "WM_S0",
   NULL
 };
 
+::Window FindEventTarget(const base::NativeEvent& xev) {
+  ::Window target = xev->xany.window;
+  if (xev->type == GenericEvent)
+    target = static_cast<XIDeviceEvent*>(xev->xcookie.data)->event;
+  return target;
+}
+
 // The events reported for slave devices can have incorrect information for some
 // fields. This utility function is used to check for such inconsistencies.
 void CheckXEventForConsistency(XEvent* xevent) {
 #if defined(USE_XI2_MT) && !defined(NDEBUG)
   static bool expect_master_event = false;
   static XIDeviceEvent slave_event;
   static gfx::Point slave_location;
   static int slave_button;
 
   // Note: If an event comes from a slave pointer device, then it will be
@@ skipping 119 matching lines @@
         // This isn't an event we want so free its cookie data.
         XFreeEventData(display, &next_event.xcookie);
       }
     }
     break;
   }
   return num_coalesed;
 }
 
 void SelectEventsForRootWindow() {
+  Display* display = ui::GetXDisplay();
+  ::Window root_window = ui::GetX11RootWindow();
+
+  // Receive resize events for the root-window so |x_root_bounds_| can be
+  // updated.
+  XWindowAttributes attr;
+  XGetWindowAttributes(display, root_window, &attr);
+  if (!(attr.your_event_mask & StructureNotifyMask)) {
+    XSelectInput(display, root_window,
+                 StructureNotifyMask | attr.your_event_mask);
+  }
+
   XIEventMask evmask;
   unsigned char mask[XIMaskLen(XI_LASTEVENT)] = {};
   memset(mask, 0, sizeof(mask));
 
   XISetMask(mask, XI_HierarchyChanged);
 
   XISetMask(mask, XI_KeyPress);
   XISetMask(mask, XI_KeyRelease);
 
 #if defined(USE_XI2_MT)
   XISetMask(mask, XI_TouchBegin);
   XISetMask(mask, XI_TouchUpdate);
   XISetMask(mask, XI_TouchEnd);
 #endif
   XISetMask(mask, XI_ButtonPress);
   XISetMask(mask, XI_ButtonRelease);
   XISetMask(mask, XI_Motion);
 
   evmask.deviceid = XIAllDevices;
   evmask.mask_len = sizeof(mask);
   evmask.mask = mask;
 
-  Display* display = ui::GetXDisplay();
-  ::Window root_window = ui::GetX11RootWindow();
   XISelectEvents(display, root_window, &evmask, 1);
-
-  // Receive resize events for the root-window so |x_root_bounds_| can be
-  // updated.
-  XSelectInput(display, root_window, StructureNotifyMask);
 }
 
 // We emulate Windows' WM_KEYDOWN and WM_CHAR messages.  WM_CHAR events are only
 // generated for certain keys; see
 // http://msdn.microsoft.com/en-us/library/windows/desktop/ms646268.aspx.  Per
 // discussion on http://crbug.com/108480, char events should furthermore not be
 // generated for Tab, Escape, and Backspace.
 bool ShouldSendCharEventForKeyboardCode(ui::KeyboardCode keycode) {
   if ((keycode >= ui::VKEY_0 && keycode <= ui::VKEY_9) ||
       (keycode >= ui::VKEY_A && keycode <= ui::VKEY_Z) ||
@@ skipping 165 matching lines @@
   XDestroyWindow(xdisplay_, xwindow_);
 
   XFreeCursor(xdisplay_, invisible_cursor_);
 }
 
 bool RootWindowHostLinux::Dispatch(const base::NativeEvent& event) {
   XEvent* xev = event;
 
   CheckXEventForConsistency(xev);
 
+  if (FindEventTarget(event) == x_root_window_)
+    return DispatchEventForRootWindow(event);
+
   switch (xev->type) {
     case EnterNotify: {
       ui::MouseEvent mouseenter_event(xev);
       delegate_->OnHostMouseEvent(&mouseenter_event);
       break;
     }
     case Expose:
       delegate_->AsRootWindow()->ScheduleFullDraw();
       break;
     case KeyPress: {
@@ skipping 23 matching lines @@
     case ButtonRelease: {
       ui::MouseEvent mouseev(xev);
       delegate_->OnHostMouseEvent(&mouseev);
       break;
     }
     case FocusOut:
       if (xev->xfocus.mode != NotifyGrab)
         delegate_->OnHostLostCapture();
       break;
     case ConfigureNotify: {
-      if (xev->xconfigure.window == xwindow_) {
-        DCHECK_EQ(xwindow_, xev->xconfigure.event);
-        // It's possible that the X window may be resized by some other means
-        // than from within aura (e.g. the X window manager can change the
-        // size). Make sure the root window size is maintained properly.
-        gfx::Rect bounds(xev->xconfigure.x, xev->xconfigure.y,
-            xev->xconfigure.width, xev->xconfigure.height);
-        bool size_changed = bounds_.size() != bounds.size();
-        bool origin_changed = bounds_.origin() != bounds.origin();
-        bounds_ = bounds;
-        // Always update barrier and mouse location because |bounds_| might
-        // have already been updated in |SetBounds|.
-        if (pointer_barriers_.get()) {
-          UnConfineCursor();
-          RootWindow* root = delegate_->AsRootWindow();
-          client::ScreenPositionClient* client =
-              client::GetScreenPositionClient(root);
-          if (client) {
-            gfx::Point p = gfx::Screen::GetCursorScreenPoint();
-            client->ConvertPointFromScreen(root, &p);
-            if (root->ContainsPoint(p)) {
-              root->ConvertPointToNativeScreen(&p);
-              XWarpPointer(
-                  xdisplay_, None, x_root_window_, 0, 0, 0, 0, p.x(), p.y());
-            }
+      DCHECK_EQ(xwindow_, xev->xconfigure.event);
+      DCHECK_EQ(xwindow_, xev->xconfigure.window);
+      // It's possible that the X window may be resized by some other means
+      // than from within aura (e.g. the X window manager can change the
+      // size). Make sure the root window size is maintained properly.
+      gfx::Rect bounds(xev->xconfigure.x, xev->xconfigure.y,
+          xev->xconfigure.width, xev->xconfigure.height);
+      bool size_changed = bounds_.size() != bounds.size();
+      bool origin_changed = bounds_.origin() != bounds.origin();
+      bounds_ = bounds;
+      // Always update barrier and mouse location because |bounds_| might
+      // have already been updated in |SetBounds|.
+      if (pointer_barriers_.get()) {
+        UnConfineCursor();
+        RootWindow* root = delegate_->AsRootWindow();
+        client::ScreenPositionClient* client =
+            client::GetScreenPositionClient(root);
+        if (client) {
+          gfx::Point p = gfx::Screen::GetCursorScreenPoint();
+          client->ConvertPointFromScreen(root, &p);
+          if (root->ContainsPoint(p)) {
+            root->ConvertPointToNativeScreen(&p);
+            XWarpPointer(
+                xdisplay_, None, x_root_window_, 0, 0, 0, 0, p.x(), p.y());
           }
-          ConfineCursorToRootWindow();
         }
-        if (size_changed)
-          delegate_->OnHostResized(bounds.size());
-        if (origin_changed)
-          delegate_->OnHostMoved(bounds_.origin());
-      } else {
-        DCHECK_EQ(x_root_window_, xev->xconfigure.event);
-        DCHECK_EQ(x_root_window_, xev->xconfigure.window);
-        x_root_bounds_.SetRect(xev->xconfigure.x, xev->xconfigure.y,
-            xev->xconfigure.width, xev->xconfigure.height);
+        ConfineCursorToRootWindow();
       }
+      if (size_changed)
+        delegate_->OnHostResized(bounds.size());
+      if (origin_changed)
+        delegate_->OnHostMoved(bounds_.origin());
       break;
     }
-    case GenericEvent: {
-      ui::TouchFactory* factory = ui::TouchFactory::GetInstance();
-      if (!factory->ShouldProcessXI2Event(xev))
-        break;
-
-      ui::EventType type = ui::EventTypeFromNative(xev);
-      XEvent last_event;
-      int num_coalesced = 0;
-
-      switch (type) {
-        case ui::ET_TOUCH_MOVED:
-          num_coalesced = CoalescePendingMotionEvents(xev, &last_event);
-          if (num_coalesced > 0)
-            xev = &last_event;
-          // fallthrough
-        case ui::ET_TOUCH_PRESSED:
-        case ui::ET_TOUCH_RELEASED: {
-          ui::TouchEvent touchev(xev);
-#if defined(OS_CHROMEOS)
-          // X maps the touch-surface to the size of the X root-window. In
-          // multi-monitor setup, the X root-window size is a combination of
-          // both the monitor sizes. So it is necessary to remap the location of
-          // the event from the X root-window to the X host-window for the aura
-          // root-window.
-          if (base::chromeos::IsRunningOnChromeOS()) {
-            touchev.CalibrateLocation(x_root_bounds_.size(), bounds_.size());
-            if (!bounds_.Contains(touchev.location())) {
-              // This might still be in the bezel region.
-              gfx::Rect expanded(bounds_);
-              expanded.Inset(-kXRootWindowPaddingLeft,
-                             -kXRootWindowPaddingTop,
-                             -kXRootWindowPaddingRight,
-                             -kXRootWindowPaddingBottom);
-              if (!expanded.Contains(touchev.location()))
-                break;
-            }
-          }
-#endif  // defined(OS_CHROMEOS)
-          delegate_->OnHostTouchEvent(&touchev);
-          break;
-        }
-        case ui::ET_MOUSE_MOVED:
-        case ui::ET_MOUSE_DRAGGED:
-        case ui::ET_MOUSE_PRESSED:
-        case ui::ET_MOUSE_RELEASED:
-        case ui::ET_MOUSE_ENTERED:
-        case ui::ET_MOUSE_EXITED: {
-          if (type == ui::ET_MOUSE_MOVED || type == ui::ET_MOUSE_DRAGGED) {
-            // If this is a motion event, we want to coalesce all pending motion
-            // events that are at the top of the queue.
-            num_coalesced = CoalescePendingMotionEvents(xev, &last_event);
-            if (num_coalesced > 0)
-              xev = &last_event;
-          } else if (type == ui::ET_MOUSE_PRESSED) {
-            XIDeviceEvent* xievent =
-                static_cast<XIDeviceEvent*>(xev->xcookie.data);
-            int button = xievent->detail;
-            if (button == kBackMouseButton || button == kForwardMouseButton) {
-              client::UserActionClient* gesture_client =
-                  client::GetUserActionClient(delegate_->AsRootWindow());
-              if (gesture_client) {
-                bool reverse_direction =
-                    ui::IsTouchpadEvent(xev) && ui::IsNaturalScrollEnabled();
-                gesture_client->OnUserAction(
-                    (button == kBackMouseButton && !reverse_direction) ||
-                    (button == kForwardMouseButton && reverse_direction) ?
-                    client::UserActionClient::BACK :
-                    client::UserActionClient::FORWARD);
-              }
-              break;
-            }
-          }
-          ui::MouseEvent mouseev(xev);
-          delegate_->OnHostMouseEvent(&mouseev);
-          break;
-        }
-        case ui::ET_MOUSEWHEEL: {
-          ui::MouseWheelEvent mouseev(xev);
-          delegate_->OnHostMouseEvent(&mouseev);
-          break;
-        }
-        case ui::ET_SCROLL_FLING_START:
-        case ui::ET_SCROLL_FLING_CANCEL:
-        case ui::ET_SCROLL: {
-          ui::ScrollEvent scrollev(xev);
-          delegate_->OnHostScrollEvent(&scrollev);
-          break;
-        }
-        case ui::ET_UNKNOWN:
-          break;
-        default:
-          NOTREACHED();
-      }
-
-      // If we coalesced an event we need to free its cookie.
-      if (num_coalesced > 0)
-        XFreeEventData(xev->xgeneric.display, &last_event.xcookie);
+    case GenericEvent:
+      DispatchXI2Event(event);
       break;
-    }
     case MapNotify: {
       // If there's no window manager running, we need to assign the X input
       // focus to our host window.
       if (!IsWindowManagerPresent() && focus_when_shown_)
         XSetInputFocus(xdisplay_, xwindow_, RevertToNone, CurrentTime);
       break;
     }
     case ClientMessage: {
       Atom message_type = static_cast<Atom>(xev->xclient.data.l[0]);
       if (message_type == atom_cache_.GetAtom("WM_DELETE_WINDOW")) {
@@ skipping 46 matching lines @@
       }
 
       ui::MouseEvent mouseev(xev);
       delegate_->OnHostMouseEvent(&mouseev);
       break;
     }
   }
   return true;
 }
 
+bool RootWindowHostLinux::DispatchEventForRootWindow(
+    const base::NativeEvent& event) {
+  switch (event->type) {
+    case ConfigureNotify:
+      DCHECK_EQ(x_root_window_, event->xconfigure.event);
+      x_root_bounds_.SetRect(event->xconfigure.x, event->xconfigure.y,
+          event->xconfigure.width, event->xconfigure.height);
+      break;
+
+    case GenericEvent:
+      DispatchXI2Event(event);
+      break;
+  }
+
+  return true;
+}
+
+void RootWindowHostLinux::DispatchXI2Event(const base::NativeEvent& event) {
+  ui::TouchFactory* factory = ui::TouchFactory::GetInstance();
+  XEvent* xev = event;
+  if (!factory->ShouldProcessXI2Event(xev))
+    return;
+
+  ui::EventType type = ui::EventTypeFromNative(xev);
+  XEvent last_event;
+  int num_coalesced = 0;
+
+  switch (type) {
+    case ui::ET_TOUCH_MOVED:
+      num_coalesced = CoalescePendingMotionEvents(xev, &last_event);
+      if (num_coalesced > 0)
+        xev = &last_event;
+      // fallthrough
+    case ui::ET_TOUCH_PRESSED:
+    case ui::ET_TOUCH_RELEASED: {
+      ui::TouchEvent touchev(xev);
+#if defined(OS_CHROMEOS)
+      // X maps the touch-surface to the size of the X root-window. In
+      // multi-monitor setup, the X root-window size is a combination of
+      // both the monitor sizes. So it is necessary to remap the location of
+      // the event from the X root-window to the X host-window for the aura
+      // root-window.
+      if (base::chromeos::IsRunningOnChromeOS()) {
+        touchev.CalibrateLocation(x_root_bounds_.size(), bounds_.size());
+        if (!bounds_.Contains(touchev.location())) {
+          // This might still be in the bezel region.
+          gfx::Rect expanded(bounds_);
+          expanded.Inset(-kXRootWindowPaddingLeft,
+                         -kXRootWindowPaddingTop,
+                         -kXRootWindowPaddingRight,
+                         -kXRootWindowPaddingBottom);
+          if (!expanded.Contains(touchev.location()))
+            break;
+        }
+      }
+#endif  // defined(OS_CHROMEOS)
+      delegate_->OnHostTouchEvent(&touchev);
+      break;
+    }
+    case ui::ET_MOUSE_MOVED:
+    case ui::ET_MOUSE_DRAGGED:
+    case ui::ET_MOUSE_PRESSED:
+    case ui::ET_MOUSE_RELEASED:
+    case ui::ET_MOUSE_ENTERED:
+    case ui::ET_MOUSE_EXITED: {
+      if (type == ui::ET_MOUSE_MOVED || type == ui::ET_MOUSE_DRAGGED) {
+        // If this is a motion event, we want to coalesce all pending motion
+        // events that are at the top of the queue.
+        num_coalesced = CoalescePendingMotionEvents(xev, &last_event);
+        if (num_coalesced > 0)
+          xev = &last_event;
+      } else if (type == ui::ET_MOUSE_PRESSED) {
+        XIDeviceEvent* xievent =
+            static_cast<XIDeviceEvent*>(xev->xcookie.data);
+        int button = xievent->detail;
+        if (button == kBackMouseButton || button == kForwardMouseButton) {
+          client::UserActionClient* gesture_client =
+              client::GetUserActionClient(delegate_->AsRootWindow());
+          if (gesture_client) {
+            bool reverse_direction =
+                ui::IsTouchpadEvent(xev) && ui::IsNaturalScrollEnabled();
+            gesture_client->OnUserAction(
+                (button == kBackMouseButton && !reverse_direction) ||
+                (button == kForwardMouseButton && reverse_direction) ?
+                client::UserActionClient::BACK :
+                client::UserActionClient::FORWARD);
+          }
+          break;
+        }
+      }
+      ui::MouseEvent mouseev(xev);
+      delegate_->OnHostMouseEvent(&mouseev);
+      break;
+    }
+    case ui::ET_MOUSEWHEEL: {
+      ui::MouseWheelEvent mouseev(xev);
+      delegate_->OnHostMouseEvent(&mouseev);
+      break;
+    }
+    case ui::ET_SCROLL_FLING_START:
+    case ui::ET_SCROLL_FLING_CANCEL:
+    case ui::ET_SCROLL: {
+      ui::ScrollEvent scrollev(xev);
+      delegate_->OnHostScrollEvent(&scrollev);
+      break;
+    }
+    case ui::ET_UNKNOWN:
+      break;
+    default:
+      NOTREACHED();
+  }
+
+  // If we coalesced an event we need to free its cookie.
+  if (num_coalesced > 0)
+    XFreeEventData(xev->xgeneric.display, &last_event.xcookie);
+}
+
 RootWindow* RootWindowHostLinux::GetRootWindow() {
   return delegate_->AsRootWindow();
 }
 
 gfx::AcceleratedWidget RootWindowHostLinux::GetAcceleratedWidget() {
   return xwindow_;
 }
 
 void RootWindowHostLinux::Show() {
   if (!window_mapped_) {
@@ skipping 279 matching lines @@
       ui::ViewProp::GetValue(accelerated_widget, kRootWindowHostLinuxKey));
 }
 
 // static
 gfx::Size RootWindowHost::GetNativeScreenSize() {
   ::Display* xdisplay = base::MessagePumpAuraX11::GetDefaultXDisplay();
   return gfx::Size(DisplayWidth(xdisplay, 0), DisplayHeight(xdisplay, 0));
 }
 
 }  // namespace aura