Consolidate OnKeyEvent and InputMethod code.

views/widget/widget_gtk.cc

 // Copyright (c) 2011 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 "views/widget/widget_gtk.h"
 
 #include <gdk/gdk.h>
 #include <gdk/gdkx.h>
 #include <X11/extensions/shape.h>
 #include <X11/Xatom.h>
@@ skipping 1244 matching lines @@
     return false;
 
   // Only top-level Widget should have an InputMethod instance.
   if (input_method_.get())
     input_method_->OnBlur();
   return false;
 }
 
 gboolean WidgetGtk::OnKeyEvent(GtkWidget* widget, GdkEventKey* event) {
   KeyEvent key(reinterpret_cast<NativeEvent>(event));
-  if (input_method_.get())
-    input_method_->DispatchKeyEvent(key);
-  else
-    DispatchKeyEventPostIME(key);
-
+  delegate->OnKeyEvent(key_event);
   // Returns true to prevent GtkWindow's default key event handler.
   return true;
 }
 
 gboolean WidgetGtk::OnQueryTooltip(GtkWidget* widget,
                                    gint x,
                                    gint y,
                                    gboolean keyboard_mode,
                                    GtkTooltip* tooltip) {
   return tooltip_manager_->ShowTooltip(x, y, keyboard_mode, tooltip);
@@ skipping 59 matching lines @@
 
 RootView* WidgetGtk::CreateRootView() {
   return new RootView(this);
 }
 
 gfx::AcceleratedWidget WidgetGtk::GetAcceleratedWidget() {
   DCHECK(window_contents_ && window_contents_->window);
   return GDK_WINDOW_XID(window_contents_->window);
 }
 
-void WidgetGtk::DispatchKeyEventPostIME(const KeyEvent& key) {
+bool WidgetGtk::DispatchKeyEventPostIME(const KeyEvent& key) {
   // Always reset |should_handle_menu_key_release_| unless we are handling a
   // VKEY_MENU key release event. It ensures that VKEY_MENU accelerator can only
   // be activated when handling a VKEY_MENU key release event which is preceded
   // by an unhandled VKEY_MENU key press event. See also HandleKeyboardEvent().
   if (key.key_code() != ui::VKEY_MENU || key.type() != ui::ET_KEY_RELEASED)
     should_handle_menu_key_release_ = false;
 
-  bool handled = false;
-
   // Dispatch the key event to View hierarchy first.
-  handled = GetRootView()->ProcessKeyEvent(key);
+  bool handled = Widget::DispatchKeyEventPostIME(key);
 
   if (key.key_code() == ui::VKEY_PROCESSKEY || handled)

[Ben Goodger (Google), 2011/04/12 21:11:15]

See my comment in widget.cc.

Once you make those changes... code below this line should be inserted into
WidgetGtk::OnKeyEvent() after the call to delegate_->OnKeyEvent().

This override can then die.

[msw, 2011/04/14 21:47:39]

Not so, if I understand suzhe and InputHandlerGtk correctly; this override is
needed for Gtk (and IBus?) IME asynchronous handling.

-    return;
+    return handled;
 
   // Dispatch the key event to native GtkWidget hierarchy.
   // To prevent GtkWindow from handling the key event as a keybinding, we need
   // to bypass GtkWindow's default key event handler and dispatch the event
   // here.
   GdkEventKey* event = reinterpret_cast<GdkEventKey*>(key.native_event());
   if (!handled && event && GTK_IS_WINDOW(widget_))
     handled = gtk_window_propagate_key_event(GTK_WINDOW(widget_), event);
 
   // On Linux, in order to handle VKEY_MENU (Alt) accelerator key correctly and
   // avoid issues like: http://crbug.com/40966 and http://crbug.com/49701, we
   // should only send the key event to the focus manager if it's not handled by
   // any View or native GtkWidget.
   // The flow is different when the focus is in a RenderWidgetHostViewGtk, which
   // always consumes the key event and send it back to us later by calling
   // HandleKeyboardEvent() directly, if it's not handled by webkit.
   if (!handled)
     handled = HandleKeyboardEvent(key);
 
   // Dispatch the key event for bindings processing.
   if (!handled && event && GTK_IS_WINDOW(widget_))
-    gtk_bindings_activate_event(GTK_OBJECT(widget_), event);
+    handled = gtk_bindings_activate_event(GTK_OBJECT(widget_), event);
+
+  return handled;
 }
 
 gboolean WidgetGtk::OnWindowPaint(GtkWidget* widget, GdkEventExpose* event) {
   // Clear the background to be totally transparent. We don't need to
   // paint the root view here as that is done by OnPaint.
   DCHECK(transparent_);
   DrawTransparentBackground(widget, event);
   // The Keyboard layout view has a renderer that covers the entire
   // window, which prevents OnPaint from being called on window_contents_,
   // so we need to remove the FREEZE_UPDATES property here.
@@ skipping 320 matching lines @@
 
   NativeWidget* native_widget = GetNativeWidgetForNativeView(native_view);
   if (native_widget)
     children->insert(native_widget);
   gtk_container_foreach(GTK_CONTAINER(native_view),
                         EnumerateChildWidgetsForNativeWidgets,
                         reinterpret_cast<gpointer>(children));
 }
 
 }  // namespace views