Do a keyboard grab when select popups are showing. This matches

chrome/browser/renderer_host/render_widget_host_view_gtk.cc

 // Copyright (c) 2006-2008 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/renderer_host/render_widget_host_view_gtk.h"
 
 #include <gtk/gtk.h>
 #include <gdk/gdk.h>
+#include <gdk/gdkkeysyms.h>
 #include <gdk/gdkx.h>
 #include <cairo/cairo.h>
 
 #include "base/gfx/gtk_util.h"
 #include "base/logging.h"
 #include "base/message_loop.h"
 #include "base/string_util.h"
 #include "base/task.h"
 #include "chrome/common/native_web_keyboard_event.h"
 #include "chrome/common/render_messages.h"
@@ skipping 69 matching lines @@
 
   static gboolean ExposeEvent(GtkWidget* widget, GdkEventExpose* expose,
                               RenderWidgetHostViewGtk* host_view) {
     const gfx::Rect damage_rect(expose->area);
     host_view->Paint(damage_rect);
     return FALSE;
   }
 
   static gboolean KeyPressReleaseEvent(GtkWidget* widget, GdkEventKey* event,
                                        RenderWidgetHostViewGtk* host_view) {
-    NativeWebKeyboardEvent wke(event);
-    host_view->GetRenderWidgetHost()->ForwardKeyboardEvent(wke);
+    if (host_view->parent_ && host_view->activatable() &&
+        GDK_Escape == event->keyval) {
+      // Force popups to close on Esc just in case the renderer is hung.  This
+      // allows us to release our keyboard grab.
+      host_view->host_->Shutdown();
+    } else {
+      NativeWebKeyboardEvent wke(event);
+      host_view->GetRenderWidgetHost()->ForwardKeyboardEvent(wke);
+    }
     // We return TRUE because we did handle the event. If it turns out webkit
     // can't handle the event, we'll deal with it in
     // RenderView::UnhandledKeyboardEvent().
     return TRUE;
   }
 
   static gboolean OnFocusIn(GtkWidget* widget, GdkEventFocus* focus,
                             RenderWidgetHostViewGtk* host_view) {
     host_view->ShowCurrentCursor();
     host_view->GetRenderWidgetHost()->Focus();
     return FALSE;
   }
 
   static gboolean OnFocusOut(GtkWidget* widget, GdkEventFocus* focus,
                            RenderWidgetHostViewGtk* host_view) {
     // Whenever we lose focus, set the cursor back to that of our parent window,
     // which should be the default arrow.
     gdk_window_set_cursor(widget->window, NULL);
     host_view->GetRenderWidgetHost()->Blur();
     return FALSE;
   }
 
   static gboolean ButtonPressReleaseEvent(
       GtkWidget* widget, GdkEventButton* event,
       RenderWidgetHostViewGtk* host_view) {
     // We want to translate the coordinates of events that do not originate
     // from this widget to be relative to the top left of the widget.
-    GtkWidget* event_widget = gtk_get_event_widget((GdkEvent*)event);
+    GtkWidget* event_widget = gtk_get_event_widget(
+        reinterpret_cast<GdkEvent*>(event));
     if (event_widget != widget) {
       int x = 0;
       int y = 0;
       gtk_widget_get_pointer(widget, &x, &y);
       // If the mouse release happens outside our popup, force the popup to
       // close.  We do this so a hung renderer doesn't prevent us from
       // releasing the x pointer grab.
       bool click_in_popup = x >= 0 && y >= 0 && x < widget->allocation.width &&
           y < widget->allocation.height;
       if (!host_view->is_popup_first_mouse_release_ && !click_in_popup) {
@@ skipping 12 matching lines @@
     if (event->type == GDK_BUTTON_PRESS && !GTK_WIDGET_HAS_FOCUS(widget))
       gtk_widget_grab_focus(widget);
 
     return FALSE;
   }
 
   static gboolean MouseMoveEvent(GtkWidget* widget, GdkEventMotion* event,
                                  RenderWidgetHostViewGtk* host_view) {
     // We want to translate the coordinates of events that do not originate
     // from this widget to be relative to the top left of the widget.
-    GtkWidget* event_widget = gtk_get_event_widget((GdkEvent*)event);
+    GtkWidget* event_widget = gtk_get_event_widget(
+        reinterpret_cast<GdkEvent*>(event));
     if (event_widget != widget) {
       int x = 0;
       int y = 0;
       gtk_widget_get_pointer(widget, &x, &y);
       event->x = x;
       event->y = y;
     }
     host_view->GetRenderWidgetHost()->ForwardMouseEvent(
         WebInputEventFactory::mouseEvent(event));
     return FALSE;
@@ skipping 52 matching lines @@
     // Now grab all of X's input.
     gdk_pointer_grab(
         parent_->window,
         TRUE,  // Only events outside of the window are reported with respect
                // to |parent_->window|.
         static_cast<GdkEventMask>(GDK_BUTTON_PRESS_MASK |
             GDK_BUTTON_RELEASE_MASK | GDK_POINTER_MOTION_MASK),
         NULL,
         NULL,
         GDK_CURRENT_TIME);
+    // We grab keyboard events too so things like alt+tab are eaten.
+    gdk_keyboard_grab(parent_->window, TRUE, GDK_CURRENT_TIME);
 
     // Our parent widget actually keeps GTK focus within its window, but we have
     // to make the webkit selection box disappear to maintain appearances.
     parent_host_view->Blur();
   }
 
   gtk_widget_set_size_request(view_.get(), pos.width(), pos.height());
 
   gtk_window_set_default_size(GTK_WINDOW(popup), -1, -1);
   // Don't allow the window to be resized. This also forces the window to
@@ skipping 126 matching lines @@
   Destroy();
 }
 
 void RenderWidgetHostViewGtk::Destroy() {
   // If |parent_| is non-null, we are a popup and we must disconnect from our
   // parent and destroy the popup window.
   if (parent_) {
     if (activatable()) {
       GdkDisplay *display = gtk_widget_get_display(parent_);
       gdk_display_pointer_ungrab(display, GDK_CURRENT_TIME);
+      gdk_display_keyboard_ungrab(display, GDK_CURRENT_TIME);
       parent_host_view_->Focus();
     }
     gtk_widget_destroy(gtk_widget_get_parent(view_.get()));
   }
 
   // Remove |view_| from all containers now, so nothing else can hold a
   // reference to |view_|'s widget except possibly a gtk signal handler if
   // this code is currently executing within the context of a gtk signal
   // handler.  Note that |view_| is still alive after this call.  It will be
   // deallocated in the destructor.
@@ skipping 103 matching lines @@
 void RenderWidgetHostViewGtk::ReceivedSelectionText(GtkClipboard* clipboard,
     const gchar* text, gpointer userdata) {
   // If there's nothing to paste (|text| is NULL), do nothing.
   if (!text)
     return;
   RenderWidgetHostViewGtk* host_view =
       reinterpret_cast<RenderWidgetHostViewGtk*>(userdata);
   host_view->host_->Send(new ViewMsg_InsertText(host_view->host_->routing_id(),
                                                 UTF8ToUTF16(text)));
 }