sk6_charactercomposer: Merged DispatchKeyEvent and its fabricated version.

ui/base/ime/input_method_ibus.h

 // Copyright (c) 2012 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.
 
 #ifndef UI_BASE_IME_INPUT_METHOD_IBUS_H_
 #define UI_BASE_IME_INPUT_METHOD_IBUS_H_
 
 #include <set>
 #include <string>
 
@@ skipping 23 matching lines @@
       public chromeos::IBusInputContextHandlerInterface {
  public:
   explicit InputMethodIBus(internal::InputMethodDelegate* delegate);
   virtual ~InputMethodIBus();
 
   // Overridden from InputMethod:
   virtual void OnFocus() OVERRIDE;
   virtual void OnBlur() OVERRIDE;
   virtual bool OnUntranslatedIMEMessage(const base::NativeEvent& event,
                                         NativeEventResult* result) OVERRIDE;
-  virtual bool DispatchKeyEvent(
-      const base::NativeEvent& native_key_event) OVERRIDE;
+  virtual bool DispatchKeyEvent(const ui::KeyEvent& event) OVERRIDE;
   virtual bool DispatchFabricatedKeyEvent(const ui::KeyEvent& event) OVERRIDE;
   virtual void OnTextInputTypeChanged(const TextInputClient* client) OVERRIDE;
   virtual void OnCaretBoundsChanged(const TextInputClient* client) OVERRIDE;
   virtual void CancelComposition(const TextInputClient* client) OVERRIDE;
   virtual std::string GetInputLocale() OVERRIDE;
   virtual base::i18n::TextDirection GetInputTextDirection() OVERRIDE;
   virtual bool IsActive() OVERRIDE;
   virtual bool IsCandidatePopupOpen() const OVERRIDE;
 
  protected:
   // Converts |text| into CompositionText.
   void ExtractCompositionText(const chromeos::IBusText& text,
                               uint32 cursor_position,
                               CompositionText* out_composition) const;
 
   // Process a key returned from the input method.
-  virtual void ProcessKeyEventPostIME(const base::NativeEvent& native_key_event,
-                                      uint32 ibus_state,
+  virtual void ProcessKeyEventPostIME(const ui::KeyEvent& event,
                                       bool handled);
 
-  // Converts |native_event| to ibus representation.
-  virtual void IBusKeyEventFromNativeKeyEvent(
-      const base::NativeEvent& native_event,
-      uint32* ibus_keyval,
-      uint32* ibus_keycode,
-      uint32* ibus_state);
-
   // Resets context and abandon all pending results and key events.
   void ResetContext();
 
  private:
   class PendingKeyEvent;
 
   // Overridden from InputMethodBase:
   virtual void OnWillChangeFocusedClient(TextInputClient* focused_before,
                                          TextInputClient* focused) OVERRIDE;
   virtual void OnDidChangeFocusedClient(TextInputClient* focused_before,
                                         TextInputClient* focused) OVERRIDE;
 
   // Asks the client to confirm current composition text.
   void ConfirmCompositionText();
 
   // Checks the availability of focused text input client and update focus
   // state.
   void UpdateContextFocusState();
 
   // Processes a key event that was already filtered by the input method.
   // A VKEY_PROCESSKEY may be dispatched to the focused View.
-  void ProcessFilteredKeyPressEvent(const base::NativeEvent& native_key_event);
+  void ProcessFilteredKeyPressEvent(const ui::KeyEvent& key_event);
 
   // Processes a key event that was not filtered by the input method.
-  void ProcessUnfilteredKeyPressEvent(const base::NativeEvent& native_key_event,
-                                      uint32 ibus_state);
-  void ProcessUnfilteredFabricatedKeyPressEvent(EventType type,
-                                                KeyboardCode key_code,
-                                                int event_flags);
+  void ProcessUnfilteredKeyPressEvent(const ui::KeyEvent& key_event);
 
   // Sends input method result caused by the given key event to the focused text
   // input client.
-  void ProcessInputMethodResult(const base::NativeEvent& native_key_event,
-                                bool filtered);
+  void ProcessInputMethodResult(const ui::KeyEvent& key_event, bool handled);
 
   // Checks if the pending input method result needs inserting into the focused
   // text input client as a single character.
   bool NeedInsertChar() const;
 
   // Checks if there is pending input method result.
   bool HasInputMethodResult() const;
 
   // Abandons all pending key events. It usually happends when we lose keyboard
   // focus, the text input type is changed or we are destroyed.
   void AbandonAllPendingKeyEvents();
 
   // Passes keyevent and executes character composition if necessary. Returns
   // true if character composer comsumes key event.
-  bool ExecuteCharacterComposer(uint32 ibus_keyval,
-                                uint32 ibus_keycode,
-                                uint32 ibus_state);
+  bool ExecuteCharacterComposer(const ui::KeyEvent& event);
 
   // chromeos::IBusInputContextHandlerInterface overrides:
   virtual void CommitText(const std::string& text) OVERRIDE;
   virtual void ForwardKeyEvent(uint32 keyval,
                                uint32 keycode,
                                uint32 state) OVERRIDE;
   virtual void ShowPreeditText() OVERRIDE;
   virtual void HidePreeditText() OVERRIDE;
   virtual void UpdatePreeditText(const chromeos::IBusText& text,
                                  uint32 cursor_pos,
                                  bool visible) OVERRIDE;
   virtual void DeleteSurroundingText(int32 offset, uint32 length) OVERRIDE;
 
-  void ProcessKeyEventDone(uint32 id, XEvent* xevent,
-                           uint32 ibus_keyval, uint32 ibus_keycode,
-                           uint32 ibus_state, bool is_handled);
+  // Callback function for IBusEngineHandlerInterface::ProcessKeyEvent.
+  void ProcessKeyEventDone(uint32 id, ui::KeyEvent* key_event, bool is_handled);
 
   // Processes a caret bounds changed event.
   void OnCaretBoundsChangedInternal(const TextInputClient* client);
 
   // All pending key events. Note: we do not own these object, we just save
   // pointers to these object so that we can abandon them when necessary.
   // They will be deleted in ProcessKeyEventDone().
   std::set<uint32> pending_key_events_;
 
   // Pending composition text generated by the current pending key event.
@@ skipping 33 matching lines @@
 
   // Used for making callbacks.
   base::WeakPtrFactory<InputMethodIBus> weak_ptr_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(InputMethodIBus);
 };
 
 }  // namespace ui
 
 #endif  // UI_BASE_IME_INPUT_METHOD_IBUS_H_