Forward unhandled KeyEvents to WidgetGtk's HandleKeyboardEvent() in native textfields.

views/controls/textfield/native_textfield_gtk.cc

Index: views/controls/textfield/native_textfield_gtk.cc
diff --git a/views/controls/textfield/native_textfield_gtk.cc b/views/controls/textfield/native_textfield_gtk.cc
index b52a50bbd22aac612229dbff80dc1316b25ed276..e1c000cf27432a195b7855aa02f5f0a7d0f43b56 100644
--- a/views/controls/textfield/native_textfield_gtk.cc
+++ b/views/controls/textfield/native_textfield_gtk.cc
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
+#include <gdk/gdkkeysyms.h>
 #include <gtk/gtk.h>
 
 #include "views/controls/textfield/native_textfield_gtk.h"
@@ -14,6 +15,7 @@
 #include "views/controls/textfield/gtk_views_entry.h"
 #include "views/controls/textfield/gtk_views_textview.h"
 #include "views/controls/textfield/textfield.h"
+#include "views/widget/widget_gtk.h"
 
 namespace views {
 
@@ -361,6 +363,34 @@ gboolean NativeTextfieldGtk::OnKeyPressEvent(GdkEventKey* event) {
 }
 
 // static
+gboolean NativeTextfieldGtk::OnActivateHandler(
+    GtkWidget* widget,
+    NativeTextfieldGtk* textfield) {
+  return textfield->OnActivate();
+}
+
+gboolean NativeTextfieldGtk::OnActivate() {
+  GdkEvent* event = gtk_get_current_event();
+  if (!event || event->type != GDK_KEY_PRESS)
+    return false;
+
+  GdkEventKey* key_event = reinterpret_cast<GdkEventKey*>(event);
+  gboolean handled = false;
+
+  Textfield::Controller* controller = textfield_->GetController();
+  if (controller) {
+    Textfield::Keystroke ks(key_event);
+    handled = controller->HandleKeystroke(textfield_, ks);
+  }
+
+  WidgetGtk* widget = static_cast<WidgetGtk*>(GetWidget());
+  if (!handled && widget)
+    handled = widget->HandleKeyboardEvent(key_event);
+
+  return handled;
+}
+
+// static
 gboolean NativeTextfieldGtk::OnChangedHandler(
     GtkWidget* widget,
     NativeTextfieldGtk* textfield) {
@@ -407,8 +437,11 @@ void NativeTextfieldGtk::NativeControlCreated(GtkWidget* widget) {
     g_signal_connect(widget, "changed",
                      G_CALLBACK(OnChangedHandler), this);
   }
-  g_signal_connect(widget, "key-press-event",
-                   G_CALLBACK(OnKeyPressEventHandler), this);
+  g_signal_connect_after(widget, "key-press-event",

[Dmitry Polukhin, 2011/01/17 10:50:19]

Changing g_signal_connect_after to g_signal_connect basically broke
OnKeyPressEvent functionality for edit boxes. Almost no events now delivered to
OnKeyPressEvent because default processing handles most of them. In particular
I'm fixing http://code.google.com/p/chromium-os/issues/detail?id=10958 that
happened due to this change. There is another issue
http://code.google.com/p/chromium-os/issues/detail?id=10362.

I think this change should be reverted to repair OnKeyPressEvent functionality.

[James Su, 2011/01/17 18:35:16]

We should never intercept key events before being handled by the native control.
Otherwise the functionalities of the native control and the input method may be
broken. For each key event needs intercepting, we need to handle it like what we
have done for Enter key in OnAcivateHandler(). For example, we need to handle
arrow keys in "move-cursor" signal handler and Tab key in "move-focus" signal
handler, etc.

[Dmitry Polukhin, 2011/01/17 20:10:21]

What will happen on Windows? Is it possible to write platform independent code
if different events are delivered to handler? Should we remove OnKeyPressEvent
because it doesn't work anymore (no events are delivered)?

[James Su, 2011/01/17 21:25:39]

Windows has different event flow, which will always dispatch an key event to the
input method, so things like OnKeyPressEvent and SkipDefaultKeyEventProcessing
work on Windows. But on Linux/Gtk, key events are dispatched to the input method
by the widget itself, so we may break the input method badly if we intercept key
events before the widget.
So it's impossible for us to the exact same code for these two platforms. But we
can abstract and share at least part of code between them. Like what we have
done in above OnActivate() method, we can use such kind of trick to deal with
the platform difference and put shared key event handling logic in controller's
HandleKeystroke() method.

+                         G_CALLBACK(OnKeyPressEventHandler), this);
+  // In order to properly trigger Accelerators bound to VKEY_RETURN, we need to
+  // send an event when the widget gets the activate signal.
+  g_signal_connect(widget, "activate", G_CALLBACK(OnActivateHandler), this);
 }
 
 ////////////////////////////////////////////////////////////////////////////////