Consolidate OnKeyEvent and InputMethod code.

views/ime/input_method_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/ime/input_method_gtk.h"
 
 #include <gdk/gdk.h>
 #include <gdk/gdkkeysyms.h>
 
 #include <algorithm>
@@ skipping 92 matching lines @@
 }
 
 void InputMethodGtk::OnBlur() {
   DCHECK(widget_focused());
   ConfirmCompositionText();
   InputMethodBase::OnBlur();
   UpdateContextFocusState();
 }
 
 void InputMethodGtk::DispatchKeyEvent(const KeyEvent& key) {
+  DCHECK(key.type() == ui::ET_KEY_PRESSED || key.type() == ui::ET_KEY_RELEASED);
   suppress_next_result_ = false;
 
   // We should bypass |context_| and |context_simple_| only if there is no
-  // text input client is focused at all. Otherwise, we should always send the
-  // key event to either |context_| or |context_simple_| even if the text input
-  // type is ui::TEXT_INPUT_TYPE_NONE, to make sure we can get correct character
-  // result.
+  // text input client focused. Otherwise, always send the key event to either
+  // |context_| or |context_simple_| even if the text input type is
+  // ui::TEXT_INPUT_TYPE_NONE, to make sure we can get correct character result.
   if (!GetTextInputClient()) {
     DispatchKeyEventPostIME(key);
     return;
   }
 
   handling_key_event_ = true;
   composition_changed_ = false;
   result_text_.clear();
 
-  GdkEvent* event = key.native_event();
-  DCHECK(!event || event->type == GDK_KEY_PRESS ||
-         event->type == GDK_KEY_RELEASE);
-
-  // If it's a fake key event, then we need to synthesis a GdkEventKey.
-  bool need_free_event = false;
-  if (!event) {
-    event = SynthesizeGdkEventKey(key);
-    need_free_event = true;
-  }
-
-  gboolean filtered = false;
-  if (context_focused_)
-    filtered = gtk_im_context_filter_keypress(context_, &event->key);
-  else
-    filtered = gtk_im_context_filter_keypress(context_simple_, &event->key);
+  // If it's a fake key event, then we need to synthesize a GdkEventKey.
+  GdkEvent* event = key.native_event() ? key.native_event() :
+                                         SynthesizeGdkEventKey(key);
+  gboolean filtered = gtk_im_context_filter_keypress(
+      context_focused_ ? context_ : context_simple_, &event->key);
 
   handling_key_event_ = false;
 
   const View* old_focused_view = focused_view();
   if (key.type() == ui::ET_KEY_PRESSED && filtered)
     ProcessFilteredKeyPressEvent(key);
 
-  // In case the focus was changed by the key event.
-  if (old_focused_view != focused_view())
-    return;
+  // Ensure no focus change from processing the key event.
+  if (old_focused_view == focused_view()) {
+    if (HasInputMethodResult())
+      ProcessInputMethodResult(key, filtered);
+    // Ensure no focus change sending input method results to the focused View.
+    if (old_focused_view == focused_view()) {
+      if (key.type() == ui::ET_KEY_PRESSED && !filtered)
+        ProcessUnfilteredKeyPressEvent(key);
+      else if (key.type() == ui::ET_KEY_RELEASED)
+        DispatchKeyEventPostIME(key);
+    }
+  }
 
-  if (HasInputMethodResult())
-    ProcessInputMethodResult(key, filtered);
-
-  // In case the focus was changed when sending input method results to the
-  // focused View.
-  if (old_focused_view != focused_view())
-    return;
-
-  if (key.type() == ui::ET_KEY_PRESSED && !filtered)
-    ProcessUnfilteredKeyPressEvent(key);
-  else if (key.type() == ui::ET_KEY_RELEASED)
-    DispatchKeyEventPostIME(key);
-
-  if (need_free_event)
+  // Free the synthesized event if there was no underlying native event.
+  if (event != key.native_event())
     gdk_event_free(event);
 }
 
 void InputMethodGtk::OnTextInputTypeChanged(View* view) {
   if (IsViewFocused(view)) {
     DCHECK(!composing_text_);
     UpdateContextFocusState();
   }
 }
 
@@ skipping 173 matching lines @@
 void InputMethodGtk::SendFakeProcessKeyEvent(bool pressed) const {
   KeyEvent key(pressed ? ui::ET_KEY_PRESSED : ui::ET_KEY_RELEASED,
                ui::VKEY_PROCESSKEY, 0);
   DispatchKeyEventPostIME(key);
 }
 
 GdkEvent* InputMethodGtk::SynthesizeGdkEventKey(const KeyEvent& key) const {
   guint keyval =
       ui::GdkKeyCodeForWindowsKeyCode(key.key_code(), key.IsShiftDown());
   guint state = 0;
-  if (key.IsShiftDown())
-    state |= GDK_SHIFT_MASK;
-  if (key.IsControlDown())
-    state |= GDK_CONTROL_MASK;
-  if (key.IsAltDown())
-    state |= GDK_MOD1_MASK;
-  if (key.IsCapsLockDown())
-    state |= GDK_LOCK_MASK;
+  state |= key.IsShiftDown() ? GDK_SHIFT_MASK : 0;
+  state |= key.IsControlDown() ? GDK_CONTROL_MASK : 0;
+  state |= key.IsAltDown() ? GDK_MOD1_MASK : 0;
+  state |= key.IsCapsLockDown() ? GDK_LOCK_MASK : 0;
 
   DCHECK(widget()->GetNativeView()->window);
   return ui::SynthesizeKeyEvent(widget()->GetNativeView()->window,
                                 key.type() == ui::ET_KEY_PRESSED,
                                 keyval, state);
 }
 
 void InputMethodGtk::OnCommit(GtkIMContext* context, gchar* text) {
   if (suppress_next_result_) {
     suppress_next_result_ = false;
@@ skipping 77 matching lines @@
     gtk_im_context_set_client_window(context_simple_, widget->window);
   }
 }
 
 void InputMethodGtk::OnWidgetUnrealize(GtkWidget* widget) {
   gtk_im_context_set_client_window(context_, NULL);
   gtk_im_context_set_client_window(context_simple_, NULL);
 }
 
 }  // namespace views