[mutter] display: Ensure that we ignore our own focus events for focus predictions

[Jasper St. Pierre <jstpierre src gnome org>]

commit 7fdfbad6d495ede1632588e528801443846e5f6d
Author: Jasper St. Pierre <jstpierre mecheye net>
Date:   Sat May 25 16:09:08 2013 -0400

    display: Ensure that we ignore our own focus events for focus predictions
    
    When we set the input focus, we first set the predicted window,
    and then try to process focus events. But as XI_FocusOut on the
    existing window comes before XI_FocusIn on the new window, we'll
    see the focus out on the old window and think the focus is going
    to nothing, which makes mutter think the prediction failed.
    
    This didn't really matter as nothing paid attention to the focus
    window changing, but with gnome-shell's focus rework, we'll try
    and drop keyboard focus in events like these.
    
    Fix this by making sure that we ignore focus window changes of our
    own cause when updating the focus window field, by ignoring all
    focus events that have a serial the same as the focus request or
    lower. Note that if mutter doens't make any requests after the
    focus request, this could be racy, as another client could steal
    the focus, but mutter would ignore it as the serial was the same.
    Bump the serial by making a dummy ChangeProperty request to a
    mutter-controlled window in this case.
    
    https://bugzilla.gnome.org/show_bug.cgi?id=701017

 src/core/display.c   |   58 +++++++++++++++++++++++++++++++++++++-------------
 src/meta/atomnames.h |    2 +
 2 files changed, 45 insertions(+), 15 deletions(-)
---
diff --git a/src/core/display.c b/src/core/display.c
index 60cb00c..e127ef0 100644
--- a/src/core/display.c
+++ b/src/core/display.c
@@ -1467,6 +1467,17 @@ meta_display_get_current_time (MetaDisplay *display)
   return display->current_time;
 }
 
+static Bool
+find_timestamp_predicate (Display  *display,
+                          XEvent   *ev,
+                          XPointer  arg)
+{
+  MetaDisplay *display = arg;
+
+  return (ev->type == PropertyNotify &&
+          ev->xproperty.atom == display->atom__MUTTER_TIMESTAMP_PING);
+}
+
 /* Get a timestamp, even if it means a roundtrip */
 guint32
 meta_display_get_current_time_roundtrip (MetaDisplay *display)
@@ -1478,17 +1489,13 @@ meta_display_get_current_time_roundtrip (MetaDisplay *display)
     {
       XEvent property_event;
 
-      /* Using the property XA_PRIMARY because it's safe; nothing
-       * would use it as a property. The type doesn't matter.
-       */
-      XChangeProperty (display->xdisplay,
-                       display->timestamp_pinging_window,
-                       XA_PRIMARY, XA_STRING, 8,
-                       PropModeAppend, NULL, 0);
-      XWindowEvent (display->xdisplay,
-                    display->timestamp_pinging_window,
-                    PropertyChangeMask,
-                    &property_event);
+      XChangeProperty (display->xdisplay, display->timestamp_pinging_window,
+                       display->atom__MUTTER_TIMESTAMP_PING,
+                       XA_STRING, 8, PropModeAppend, NULL, 0);
+      XIfEvent (display->xdisplay,
+                &property_event,
+                find_timestamp_predicate,
+                display);
       timestamp = property_event.xproperty.time;
     }
 
@@ -1952,6 +1959,7 @@ request_xserver_input_focus_change (MetaDisplay *display,
                                     guint32      timestamp)
 {
   MetaWindow *meta_window;
+  gulong serial;
 
   if (timestamp_too_old (display, &timestamp))
     return;
@@ -1959,14 +1967,34 @@ request_xserver_input_focus_change (MetaDisplay *display,
   meta_window = meta_display_lookup_x_window (display, xwindow);
 
   meta_error_trap_push (display);
-  update_focus_window (display,
-                       meta_window,
-                       XNextRequest (display->xdisplay));
+
+  /* In order for mutter to know that the focus request succeeded, we track
+   * the serial of the "focus request" we made, but if we take the serial
+   * of the XSetInputFocus request, then there's no way to determine the
+   * difference between focus events as a result of the SetInputFocus and
+   * focus events that other clients send around the same time. Ensure that
+   * we know which is which by making two requests that the server will
+   * process at the same time.
+   */
+  meta_display_grab (display);
+
+  serial = XNextRequest (display->xdisplay);
 
   XSetInputFocus (display->xdisplay,
                   xwindow,
                   RevertToPointerRoot,
                   timestamp);
+
+  XChangeProperty (display->xdisplay, display->timestamp_pinging_window,
+                   display->atom__MUTTER_FOCUS_SET,
+                   XA_STRING, 8, PropModeAppend, NULL, 0);
+
+  meta_display_ungrab (display);
+
+  update_focus_window (display,
+                       meta_window,
+                       serial);
+
   meta_error_trap_pop (display);
 
   display->last_focus_time = timestamp;
@@ -2079,7 +2107,7 @@ handle_window_focus_event (MetaDisplay  *display,
   else
     g_return_if_reached ();
 
-  if (display->server_focus_serial >= display->focus_serial)
+  if (display->server_focus_serial > display->focus_serial)
     {
       update_focus_window (display, focus_window,
                            display->server_focus_serial);
diff --git a/src/meta/atomnames.h b/src/meta/atomnames.h
index d262071..1223151 100644
--- a/src/meta/atomnames.h
+++ b/src/meta/atomnames.h
@@ -70,6 +70,8 @@ item(_GNOME_WM_KEYBINDINGS)
 item(_GNOME_PANEL_ACTION)
 item(_GNOME_PANEL_ACTION_MAIN_MENU)
 item(_GNOME_PANEL_ACTION_RUN_DIALOG)
+item(_MUTTER_TIMESTAMP_PING)
+item(_MUTTER_FOCUS_SET)
 item(_MUTTER_SENTINEL)
 item(_MUTTER_VERSION)
 item(WM_CLIENT_MACHINE)