A workaround to close currently opened menu. Send escape key if screen locker fails to grab input.

chrome/browser/chromeos/login/screen_locker.cc

 // Copyright (c) 2010 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 "chrome/browser/chromeos/login/screen_locker.h"
 
+#include <gdk/gdkx.h>
 #include <string>
 #include <vector>
+#include <X11/extensions/XTest.h>
+#include <X11/keysym.h>
 
 #include "app/l10n_util.h"
 #include "app/resource_bundle.h"
+#include "app/x11_util.h"
 #include "base/command_line.h"
 #include "base/metrics/histogram.h"
 #include "base/message_loop.h"
 #include "base/singleton.h"
 #include "base/string_util.h"
 #include "base/timer.h"
 #include "base/utf_string_conversions.h"
 #include "chrome/browser/browser_list.h"
 #include "chrome/browser/browser_thread.h"
 #include "chrome/browser/browser_window.h"
@@ skipping 245 matching lines @@
         ALLOW_THIS_IN_INITIALIZER_LIST(task_factory_(this)),
         grab_failure_count_(0),
         kbd_grab_status_(GDK_GRAB_INVALID_TIME),
         mouse_grab_status_(GDK_GRAB_INVALID_TIME) {
   }
 
   virtual void Show() {
     views::WidgetGtk::Show();
   }
 
-  void ClearGrab() {
+  void ClearGtkGrab() {
     GtkWidget* current_grab_window;
-    // Grab gtk input first so that the menu holding grab will close itself.
+    // Grab gtk input first so that the menu holding gtk grab will
+    // close itself.
     gtk_grab_add(window_contents());
 
-    // Make sure there is no grab widget so that gtk simply propagates
+    // Make sure there is no gtk grab widget so that gtk simply propagates
     // an event.  This is necessary to allow message bubble and password
     // field, button to process events simultaneously. GTK
     // maintains grab widgets in a linked-list, so we need to remove
     // until it's empty.
     while ((current_grab_window = gtk_grab_get_current()) != NULL)
       gtk_grab_remove(current_grab_window);
   }
 
   virtual gboolean OnButtonPress(GtkWidget* widget, GdkEventButton* event) {
     WidgetGtk::OnButtonPress(widget, event);
     // Never propagate event to parent.
     return true;
   }
 
   // Try to grab all inputs. It initiates another try if it fails to
   // grab and the retry count is within a limit, or fails with CHECK.
   void TryGrabAllInputs();
 
+  // This method tries to steal pointer/keyboard grab from other
+  // client by sending events that will hopefullly close menu or window

[Daniel Erat, 2010/11/17 01:24:23]

nit: s/menu or window/menus or windows/

[oshima, 2010/11/17 18:15:38]

Done.

+  // that have the grab.
+  void TryUngrabOtherClients();
+
  private:
   virtual void HandleGrabBroke() {
     // Input should never be stolen from ScreenLocker once it's
     // grabbed.  If this happens, it's a bug and has to be fixed. We
     // let chrome crash to get a crash report and dump, and
     // SessionManager will terminate the session to logout.
     CHECK(kbd_grab_status_ != GDK_GRAB_SUCCESS ||
           mouse_grab_status_ != GDK_GRAB_SUCCESS)
         << "Grab Broke. quitting";
   }
 
   chromeos::ScreenLocker* screen_locker_;
   ScopedRunnableMethodFactory<GrabWidget> task_factory_;
 
   // The number times the widget tried to grab all focus.
   int grab_failure_count_;
   // Status of keyboard and mouse grab.
   GdkGrabStatus kbd_grab_status_;
   GdkGrabStatus mouse_grab_status_;
 
   DISALLOW_COPY_AND_ASSIGN(GrabWidget);
 };
 
 void GrabWidget::TryGrabAllInputs() {
-  ClearGrab();
-
   if (kbd_grab_status_ != GDK_GRAB_SUCCESS) {
     kbd_grab_status_ = gdk_keyboard_grab(window_contents()->window, FALSE,
                                          GDK_CURRENT_TIME);
   }
+  // Grab x server so that we can atomically grab and take
+  // action when grab fails.
+  gdk_x11_grab_server();

[Daniel Erat, 2010/11/17 01:24:23]

Do you mean for this to appear before the call to gdk_keyboard_grab?  Seems
strange that it happens after the keyboard grab but before the pointer grab.

[oshima, 2010/11/17 18:15:38]

Doh, yes, that's what I meant.

   if (mouse_grab_status_ != GDK_GRAB_SUCCESS) {
     mouse_grab_status_ =
         gdk_pointer_grab(window_contents()->window,
                          FALSE,
                          static_cast<GdkEventMask>(
                              GDK_BUTTON_PRESS_MASK | GDK_BUTTON_RELEASE_MASK |
                              GDK_POINTER_MOTION_MASK),
                          NULL,
                          NULL,
                          GDK_CURRENT_TIME);
   }
   if ((kbd_grab_status_ != GDK_GRAB_SUCCESS ||
        mouse_grab_status_ != GDK_GRAB_SUCCESS) &&
       grab_failure_count_++ < kMaxGrabFailures) {
     LOG(WARNING) << "Failed to grab inputs. Trying again in "
                  << kRetryGrabIntervalMs << " ms: kbd="
                  << kbd_grab_status_ << ", mouse=" << mouse_grab_status_;
+    TryUngrabOtherClients();
     MessageLoop::current()->PostDelayedTask(
         FROM_HERE,
         task_factory_.NewRunnableMethod(&GrabWidget::TryGrabAllInputs),
         kRetryGrabIntervalMs);
   } else {
     CHECK_EQ(GDK_GRAB_SUCCESS, kbd_grab_status_)
         << "Failed to grab keyboard input:" << kbd_grab_status_;
     CHECK_EQ(GDK_GRAB_SUCCESS, mouse_grab_status_)
         << "Failed to grab pointer input:" << mouse_grab_status_;
     DVLOG(1) << "Grab Success";
     screen_locker_->OnGrabInputs();
   }
+  gdk_x11_ungrab_server();

[Daniel Erat, 2010/11/17 01:24:23]

Server grabs block all other clients from doing anything, so I'm a bit worried
about this interrupting window manager animations.  Can you move this up so we
call it before the CHECK_EQ() calls and OnGrabInputs() (and add another copy of
it to the end of the failed-grab path)?

[oshima, 2010/11/17 18:15:38]

Done.

+}
+
+void GrabWidget::TryUngrabOtherClients() {
+#if !defined(NDEBUG)
+  {
+    int event_base, error_base;
+    int major, minor;
+    // Make sure we have XTest extension.
+    DCHECK(XTestQueryExtension(x11_util::GetXDisplay(),
+                               &event_base, &error_base,
+                               &major, &minor));
+  }
+#endif
+
+  // The following code is an attempt to grab inputs by closing
+  // supposedly opened menu. This happens when a plugin has a menu
+  // opened.
+  if (mouse_grab_status_ == GDK_GRAB_ALREADY_GRABBED ||
+      mouse_grab_status_ == GDK_GRAB_FROZEN) {
+    // Successfully grabbed the keyboard, but pointer is still
+    // grabbed by other client. Another attempt to close supposedly
+    // opened menu by emulating keypress at the left top corner.
+    Display* display = x11_util::GetXDisplay();
+    Window root, child;
+    int root_x, root_y, win_x, winy;
+    unsigned int mask;
+    XQueryPointer(display,
+                  x11_util::GetX11WindowFromGtkWidget(window_contents()),
+                  &root, &child, &root_x, &root_y,
+                  &win_x, &winy, &mask);
+    XTestFakeMotionEvent(display, -1, -10000, -10000, CurrentTime);
+    XTestFakeButtonEvent(display, 1, True, CurrentTime);
+    XTestFakeButtonEvent(display, 1, False, CurrentTime);
+    // Move the pointer back.
+    XTestFakeMotionEvent(display, -1, root_x, root_y, CurrentTime);
+    XFlush(display);
+  } else if (kbd_grab_status_ == GDK_GRAB_ALREADY_GRABBED ||
+             kbd_grab_status_ == GDK_GRAB_FROZEN) {
+    // Successfully grabbed the pointer, but keyboard is still grabbed
+    // by other client. Another attempt to close supposedly opened
+    // menu by emulating escape key.  Such situation must be very
+    // rare, but handling this just in case
+    Display* display = x11_util::GetXDisplay();
+    KeyCode escape = XKeysymToKeycode(display, XK_Escape);
+    XTestFakeKeyEvent(display, escape, True, CurrentTime);
+    XTestFakeKeyEvent(display, escape, False, CurrentTime);
+    XFlush(display);
+  }
 }
 
 // BackgroundView for ScreenLocker, which layouts a lock widget in
 // addition to other background components.
 class ScreenLockerBackgroundView : public chromeos::BackgroundView {
  public:
   ScreenLockerBackgroundView(views::WidgetGtk* lock_widget,
                              views::View* screen_lock_view)
       : lock_widget_(lock_widget),
         screen_lock_view_(screen_lock_view) {
@@ skipping 235 matching lines @@
 
   DCHECK(GTK_WIDGET_REALIZED(lock_window_->GetNativeView()));
   WmIpc::instance()->SetWindowType(
       lock_window_->GetNativeView(),
       WM_IPC_WINDOW_CHROME_SCREEN_LOCKER,
       NULL);
 
   lock_window_->SetContentsView(background_view_);
   lock_window_->Show();
 
+  cast_lock_widget->ClearGtkGrab();
+
+  // Call this after lock_window_->Show() otherwise the 1st invocation
+  // of gdk_xxx_grab() will always fail.
   cast_lock_widget->TryGrabAllInputs();
 
   // Add the window to its own group so that its grab won't be stolen if
   // gtk_grab_add() gets called on behalf on a non-screen-locker widget (e.g.
   // a modal dialog) -- see http://crosbug.com/8999.  We intentionally do this
-  // after calling TryGrabAllInputs(), as want to be in the default window group
+  // after calling ClearGtkGrab(), as want to be in the default window group
   // then so we can break any existing GTK grabs.
   GtkWindowGroup* window_group = gtk_window_group_new();
   gtk_window_group_add_window(window_group,
                               GTK_WINDOW(lock_window_->GetNativeView()));
   g_object_unref(window_group);
 
   // Don't let X draw default background, which was causing flash on
   // resume.
   gdk_window_set_back_pixmap(lock_window_->GetNativeView()->window,
                              NULL, false);
@@ skipping 294 matching lines @@
 
 bool ScreenLocker::AcceleratorPressed(const views::Accelerator& accelerator) {
   if (!background_view_->IsScreenSaverVisible()) {
     StartScreenSaver();
     return true;
   }
   return false;
 }
 
 }  // namespace chromeos