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 188 matching lines @@
       } else {
         // This isn't an event we want so free its cookie data.
         XFreeEventData(display, &next_event.xcookie);
       }
     }
     break;
   }
   return num_coalesed;
 }
 
+::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;
+}
+
 void SelectEventsForRootWindow() {
   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);
+  XWindowAttributes attr;
+  XGetWindowAttributes(display, root_window, &attr);
+  if (!(attr.your_event_mask & StructureNotifyMask)) {
+    XSelectInput(display, root_window,
+                 StructureNotifyMask | attr.your_event_mask);
+  }
 }
 
 // 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 124 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;
@@ skipping 147 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);
+      DCHECK_EQ(x_root_window_, event->xconfigure.window);
+      x_root_bounds_.SetRect(event->xconfigure.x, event->xconfigure.y,
+          event->xconfigure.width, event->xconfigure.height);
+      break;
+  }
+
+  return false;

[Daniel Erat, 2012/09/13 19:14:09]

i think that we previously returned true in this case.  is the switch to false
here intentional?

[sadrul, 2012/09/13 23:41:24]

It wasn't. Incidentally, however, the return value from the root-window
message-dispatcher is ignored. So it doesn't make a difference. For consistency,
I have switched it back to returning true (and changed the only other such
root-window dispatcher that currently returns false to return true).

+}
+
 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