Remove fake context support.

views/ime/input_method_ibus.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_ibus.h"
 
 #include <ibus.h>
 #if defined(TOUCH_UI)
 #include <X11/Xlib.h>
 #include <X11/Xutil.h>
@@ skipping 247 matching lines @@
     key.set_character(character_);
     key.set_unmodified_character(unmodified_character_);
   }
   input_method_->ProcessKeyEventPostIME(key, ibus_keyval_, handled);
 }
 
 // InputMethodIBus::PendingCreateICRequest implementation ---------------------
 class InputMethodIBus::PendingCreateICRequest {
  public:
   PendingCreateICRequest(InputMethodIBus* input_method,
-                         PendingCreateICRequest** request_ptr,
-                         bool fake);
+                         PendingCreateICRequest** request_ptr);
   ~PendingCreateICRequest();
 
   // Abandon this pending key event. Its result will just be discarded.
   void abandon() {
     input_method_ = NULL;
     request_ptr_ = NULL;
   }
 
   // Stores the result input context to |input_method_|, or abandon it if
   // |input_method_| is NULL.
   void StoreOrAbandonInputContext(IBusInputContext* ic);
 
  private:
   InputMethodIBus* input_method_;
   PendingCreateICRequest** request_ptr_;
-  bool fake_;
 };
 
 InputMethodIBus::PendingCreateICRequest::PendingCreateICRequest(
     InputMethodIBus* input_method,
-    PendingCreateICRequest** request_ptr,
-    bool fake)
+    PendingCreateICRequest** request_ptr)
     : input_method_(input_method),
-      request_ptr_(request_ptr),
-      fake_(fake) {
+      request_ptr_(request_ptr) {
 }
 
 InputMethodIBus::PendingCreateICRequest::~PendingCreateICRequest() {
   if (request_ptr_) {
     DCHECK_EQ(*request_ptr_, this);
     *request_ptr_ = NULL;
   }
 }
 
 void InputMethodIBus::PendingCreateICRequest::StoreOrAbandonInputContext(
     IBusInputContext* ic) {
   if (input_method_) {
-    input_method_->SetContext(ic, fake_);
+    input_method_->SetContext(ic);
   } else {
     // ibus_proxy_destroy() will not really release the object, we still need
     // to call g_object_unref() explicitly.
     ibus_proxy_destroy(reinterpret_cast<IBusProxy *>(ic));
     g_object_unref(ic);
   }
 }
 
 // InputMethodIBus implementation ---------------------------------------------
 InputMethodIBus::InputMethodIBus(internal::InputMethodDelegate* delegate)
     : context_(NULL),
-      fake_context_(NULL),
       pending_create_ic_request_(NULL),
-      pending_create_fake_ic_request_(NULL),
       context_focused_(false),
       composing_text_(false),
       composition_changed_(false),
       suppress_next_result_(false) {
   set_delegate(delegate);
 }
 
 InputMethodIBus::~InputMethodIBus() {
   AbandonAllPendingKeyEvents();
   DestroyContext();
@@ skipping 40 matching lines @@
 
 void InputMethodIBus::DispatchKeyEvent(const KeyEvent& key) {
   DCHECK(key.type() == ui::ET_KEY_PRESSED || key.type() == ui::ET_KEY_RELEASED);
   DCHECK(widget_focused());
 
   guint32 ibus_keyval = 0;
   guint32 ibus_keycode = 0;
   guint32 ibus_state = 0;
   IBusKeyEventFromViewsKeyEvent(key, &ibus_keyval, &ibus_keycode, &ibus_state);
 
-  // If |context_| is not usable and |fake_context_| is not created yet, then we
-  // can only dispatch the key event as is. We also dispatch the key event
-  // directly if the current text input type is ui::TEXT_INPUT_TYPE_PASSWORD,
-  // to bypass the input method.
+  // If |context_| is not usable, then we can only dispatch the key event as is.
+  // We also dispatch the key event directly if the current text input type is
+  // ui::TEXT_INPUT_TYPE_PASSWORD, to bypass the input method.
   // Note: We need to send the key event to ibus even if the |context_| is not
   // enabled, so that ibus can have a chance to enable the |context_|.
-  if (!(context_focused_ || fake_context_) ||
+  if (!context_focused_ ||
       GetTextInputType() == ui::TEXT_INPUT_TYPE_PASSWORD) {
     if (key.type() == ui::ET_KEY_PRESSED)
       ProcessUnfilteredKeyPressEvent(key, ibus_keyval);
     else
       DispatchKeyEventPostIME(key);
     return;
   }
 
   PendingKeyEvent* pending_key = new PendingKeyEvent(this, key, ibus_keyval);
   pending_key_events_.insert(pending_key);
 
   // Note:
   // 1. We currently set timeout to -1, because ibus doesn't have a mechanism to
   // associate input method results to corresponding key event, thus there is
   // actually no way to abandon results generated by a specific key event. So we
   // actually cannot abandon a specific key event and its result but accept
   // following key events and their results. So a timeout to abandon a key event
   // will not work.
   // 2. We set GCancellable to NULL, because the operation of cancelling a async
   // request also happens asynchronously, thus it's actually useless to us.
   //
   // The fundemental problem of ibus' async API is: it uses Glib's GIO API to
   // realize async communication, but in fact, GIO API is specially designed for
   // concurrent tasks, though it supports async communication as well, the API
   // is much more complicated than an ordinary message based async communication
   // API (such as Chrome's IPC).
   // Thus it's very complicated, if not impossible, to implement a client that
   // fully utilize asynchronous communication without potential problem.
   ibus_input_context_process_key_event_async(
-      context_focused_ ? context_ : fake_context_,
+      context_,
       ibus_keyval, ibus_keycode, ibus_state, -1, NULL,
       reinterpret_cast<GAsyncReadyCallback>(ProcessKeyEventDone),
       pending_key);
 
   // We don't want to suppress the result generated by this key event, but it
   // may cause problem. See comment in ResetContext() method.
   suppress_next_result_ = false;
 }
 
 void InputMethodIBus::OnTextInputTypeChanged(View* view) {
@@ skipping 69 matching lines @@
   UpdateContextFocusState();
 
   // Force to update caret bounds, in case the View thinks that the caret
   // bounds has not changed.
   if (context_focused_)
     OnCaretBoundsChanged(GetFocusedView());
 }
 
 void InputMethodIBus::CreateContext() {
   DCHECK(!context_);
-  DCHECK(!fake_context_);
   DCHECK(GetIBus());
   DCHECK(ibus_bus_is_connected(GetIBus()));
   DCHECK(!pending_create_ic_request_);
-  DCHECK(!pending_create_fake_ic_request_);
 
   // Creates the input context asynchronously.
   pending_create_ic_request_ = new PendingCreateICRequest(
-      this, &pending_create_ic_request_, false /* fake */);
+      this, &pending_create_ic_request_);
   ibus_bus_create_input_context_async(
       GetIBus(), "chrome", -1, NULL,
       reinterpret_cast<GAsyncReadyCallback>(CreateInputContextDone),
       pending_create_ic_request_);
-
-  // Creates the fake input context asynchronously. ibus will match the "fake"
-  // prefix in the application name to do magic thing.
-  pending_create_fake_ic_request_ = new PendingCreateICRequest(
-      this, &pending_create_fake_ic_request_, true /* fake */);
-  ibus_bus_create_input_context_async(
-      GetIBus(), "fake-chrome", -1, NULL,
-      reinterpret_cast<GAsyncReadyCallback>(CreateInputContextDone),
-      pending_create_fake_ic_request_);
 }
 
-void InputMethodIBus::SetContext(IBusInputContext* ic, bool fake) {
+void InputMethodIBus::SetContext(IBusInputContext* ic) {
   DCHECK(ic);
-  if (fake) {
-    DCHECK(!fake_context_);
-    fake_context_ = ic;
-
-    // We only need to care about "destroy" signal of the fake context,
-    // as it will not generate any input method result.
-    g_signal_connect(ic, "destroy", G_CALLBACK(OnFakeDestroyThunk), this);
-
-    ibus_input_context_set_capabilities(ic, IBUS_CAP_FOCUS);
-    UpdateFakeContextFocusState();
-    return;
-  }
-
   DCHECK(!context_);
   context_ = ic;
 
   // connect input context signals
   g_signal_connect(ic, "commit-text",
                    G_CALLBACK(OnCommitTextThunk), this);
   g_signal_connect(ic, "forward-key-event",
                    G_CALLBACK(OnForwardKeyEventThunk), this);
   g_signal_connect(ic, "update-preedit-text",
                    G_CALLBACK(OnUpdatePreeditTextThunk), this);
@@ skipping 18 matching lines @@
     // |pending_create_ic_request_| will be deleted in CreateInputContextDone().
     pending_create_ic_request_->abandon();
     pending_create_ic_request_ = NULL;
   } else if (context_) {
     // ibus_proxy_destroy() will not really release the resource of |context_|
     // object. We still need to handle "destroy" signal and call
     // g_object_unref() there.
     ibus_proxy_destroy(reinterpret_cast<IBusProxy *>(context_));
     DCHECK(!context_);
   }
-
-  if (pending_create_fake_ic_request_) {
-    DCHECK(!fake_context_);
-    // |pending_create_fake_ic_request_| will be deleted in
-    // CreateInputContextDone().
-    pending_create_fake_ic_request_->abandon();
-    pending_create_fake_ic_request_ = NULL;
-  } else if (fake_context_) {
-    ibus_proxy_destroy(reinterpret_cast<IBusProxy *>(fake_context_));
-    DCHECK(!fake_context_);
-  }
 }
 
 void InputMethodIBus::ConfirmCompositionText() {
   ui::TextInputClient* client = GetTextInputClient();
   if (client && client->HasCompositionText())
     client->ConfirmCompositionText();
 
   ResetContext();
 }
 
@@ skipping 23 matching lines @@
   // is no reliable way to abandon all results generated by these abandoned key
   // events.
   AbandonAllPendingKeyEvents();
 
   // This function runs asynchronously.
   // Note: some input method engines may not support reset method, such as
   // ibus-anthy. But as we control all input method engines by ourselves, we can
   // make sure that all of the engines we are using support it correctly.
   ibus_input_context_reset(context_);
 
-  // We don't need to reset |fake_context_|.
-
   character_composer_.Reset();
 }
 
 void InputMethodIBus::UpdateContextFocusState() {
   if (!context_) {
     context_focused_ = false;
-    UpdateFakeContextFocusState();
     return;
   }
 
   const bool old_context_focused = context_focused_;
   // Use switch here in case we are going to add more text input types.
   switch (GetTextInputType()) {
     case ui::TEXT_INPUT_TYPE_NONE:
     case ui::TEXT_INPUT_TYPE_PASSWORD:
       context_focused_ = false;
       break;
     default:
       context_focused_ = true;
       break;
   }
 
   // We only focus in |context_| when the focus is in a normal textfield.
   // ibus_input_context_focus_{in|out}() run asynchronously.
   if (old_context_focused && !context_focused_)
     ibus_input_context_focus_out(context_);
   else if (!old_context_focused && context_focused_)
     ibus_input_context_focus_in(context_);
-
-  UpdateFakeContextFocusState();
-}
-
-void InputMethodIBus::UpdateFakeContextFocusState() {
-  if (!fake_context_)
-    return;
-
-  if (widget_focused() && !context_focused_ &&
-      GetTextInputType() != ui::TEXT_INPUT_TYPE_PASSWORD) {
-    // We disable input method in password fields, so it makes no sense to allow
-    // switching input method.
-    ibus_input_context_focus_in(fake_context_);
-  } else {
-    ibus_input_context_focus_out(fake_context_);
-  }
 }
 
 void InputMethodIBus::ProcessKeyEventPostIME(const KeyEvent& key,
                                              guint32 ibus_keyval,
                                              bool handled) {
   // If we get here without a focused text input client, then it means the key
   // event is sent to the global ibus input context.
   if (!GetTextInputClient()) {
     DispatchKeyEventPostIME(key);
     return;
@@ skipping 258 matching lines @@
   context_focused_ = false;
 
   ConfirmCompositionText();
 
   // We are dead, so we need to ask the client to stop relying on us.
   // We cannot do it in DestroyContext(), because OnDestroy() may be called
   // automatically.
   OnInputMethodChanged();
 }
 
-void InputMethodIBus::OnFakeDestroy(IBusInputContext* context) {
-  DCHECK_EQ(fake_context_, context);
-  g_object_unref(fake_context_);
-  fake_context_ = NULL;
-}
-
 void InputMethodIBus::OnIBusConnected(IBusBus* bus) {
   DCHECK_EQ(GetIBus(), bus);
   DCHECK(ibus_bus_is_connected(bus));
 
   DestroyContext();
   CreateContext();
 }
 
 void InputMethodIBus::OnIBusDisconnected(IBusBus* bus) {
   DCHECK_EQ(GetIBus(), bus);
@@ skipping 16 matching lines @@
   }
   return ibus;
 }
 
 // static
 void InputMethodIBus::ProcessKeyEventDone(IBusInputContext* context,
                                           GAsyncResult* res,
                                           PendingKeyEvent* data) {
   DCHECK(data);
   DCHECK(!data->input_method() ||
-         data->input_method()->context_ == context ||
-         data->input_method()->fake_context_ == context);
+         data->input_method()->context_ == context);
 
   gboolean handled = ibus_input_context_process_key_event_async_finish(
       context, res, NULL);
   data->ProcessPostIME(handled);
   delete data;
 }
 
 // static
 void InputMethodIBus::CreateInputContextDone(IBusBus* bus,
                                              GAsyncResult* res,
                                              PendingCreateICRequest* data) {
   DCHECK_EQ(GetIBus(), bus);
   DCHECK(data);
   IBusInputContext* ic =
       ibus_bus_create_input_context_async_finish(bus, res, NULL);
   if (ic)
     data->StoreOrAbandonInputContext(ic);
   delete data;
 }
 
 }  // namespace views