GTK: For the render view, count keyboard grab shadows the same as focus event...

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>
@@ skipping 45 matching lines @@
     g_signal_connect(widget, "expose-event",
                      G_CALLBACK(ExposeEvent), host_view);
     g_signal_connect(widget, "key-press-event",
                      G_CALLBACK(KeyPressReleaseEvent), host_view);
     g_signal_connect(widget, "key-release-event",
                      G_CALLBACK(KeyPressReleaseEvent), host_view);
     g_signal_connect(widget, "focus-in-event",
                      G_CALLBACK(OnFocusIn), host_view);
     g_signal_connect(widget, "focus-out-event",
                      G_CALLBACK(OnFocusOut), host_view);
+    g_signal_connect(widget, "grab-notify",
+                     G_CALLBACK(OnGrabNotify), host_view);
     g_signal_connect(widget, "button-press-event",
                      G_CALLBACK(ButtonPressReleaseEvent), host_view);
     g_signal_connect(widget, "button-release-event",
                      G_CALLBACK(ButtonPressReleaseEvent), host_view);
     g_signal_connect(widget, "motion-notify-event",
                      G_CALLBACK(MouseMoveEvent), host_view);
     g_signal_connect(widget, "scroll-event",
                      G_CALLBACK(MouseScrollEvent), host_view);
 
     // Create a GtkIMContext instance and attach its signal handlers.
@@ skipping 71 matching lines @@
           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;
   }
 
+  // WARNING: OnGrabNotify relies on the fact this function doesn't try to
+  // dereference |focus|.
   static gboolean OnFocusIn(GtkWidget* widget, GdkEventFocus* focus,
                             RenderWidgetHostViewGtk* host_view) {
     int x, y;
     gtk_widget_get_pointer(widget, &x, &y);
     // http://crbug.com/13389
     // If the cursor is in the render view, fake a mouse move event so that
     // webkit updates its state. Otherwise webkit might think the cursor is
     // somewhere it's not.
     if (x >= 0 && y >= 0 && x < widget->allocation.width &&
         y < widget->allocation.height) {
@@ skipping 17 matching lines @@
     // attach this GtkIMContext object to this window.
     // We should call gtk_im_context_set_client_window() only when this window
     // gain (or release) the window focus because an immodule may reset its
     // internal status when processing this function.
     gtk_im_context_focus_in(host_view->im_context_);
     gtk_im_context_set_client_window(host_view->im_context_,
                                      host_view->native_view()->window);
     return FALSE;
   }
 
+  // WARNING: OnGrabNotify relies on the fact this function doesn't try to
+  // dereference |focus|.
   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);
     // If we are showing a context menu, maintain the illusion that webkit has
     // focus.
     if (!host_view->is_showing_context_menu_)
       host_view->GetRenderWidgetHost()->Blur();
 
     // Notify the GtkIMContext object of this focus-in event and
     // detach this GtkIMContext object from this window.
     gtk_im_context_focus_out(host_view->im_context_);
     gtk_im_context_set_client_window(host_view->im_context_, NULL);
     return FALSE;
   }
 
+  // Called when we are shadowed or unshadowed by a keyboard grab (which will
+  // occur for activatable popups, such as dropdown menus). Popup windows do not
+  // take focus, so we never get a focus out or focus in event when they are
+  // shown, and must rely on this signal instead.
+  static void OnGrabNotify(GtkWidget* widget, gboolean was_grabbed,
+                           RenderWidgetHostViewGtk* host_view) {
+    if (was_grabbed)

[Evan Stade, 2009/07/11 01:14:06]

this check seems backward, but is not

+      OnFocusIn(widget, NULL, host_view);
+    else
+      OnFocusOut(widget, NULL, host_view);
+  }
+
   static gboolean ButtonPressReleaseEvent(
       GtkWidget* widget, GdkEventButton* event,
       RenderWidgetHostViewGtk* host_view) {
     if (!(event->button == 1 || event->button == 2 || event->button == 3))
       return FALSE;  // We do not forward any other buttons to the renderer.
 
     // 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(
         reinterpret_cast<GdkEvent*>(event));
@@ skipping 487 matching lines @@
 }
 
 gfx::PluginWindowHandle RenderWidgetHostViewGtk::CreatePluginContainer() {
   return plugin_container_manager_.CreatePluginContainer();
 }
 
 void RenderWidgetHostViewGtk::DestroyPluginContainer(
     gfx::PluginWindowHandle container) {
   plugin_container_manager_.DestroyPluginContainer(container);
 }