Clean UP: Remove IBusClientImpl from ui/base/ime/*

ui/base/ime/input_method_ibus.cc

 // 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.
 
 #include "ui/base/ime/input_method_ibus.h"
 
 #include <X11/X.h>
 #include <X11/Xlib.h>
 #include <X11/Xutil.h>
 #undef FocusIn
 #undef FocusOut
 
 #include <algorithm>
 #include <cstring>
 #include <set>
 #include <vector>
 
 #include "base/basictypes.h"
 #include "base/bind.h"
 #include "base/i18n/char_iterator.h"
 #include "base/logging.h"
 #include "base/string_util.h"
 #include "base/third_party/icu/icu_utf.h"
 #include "base/utf_string_conversions.h"
 #include "chromeos/dbus/dbus_thread_manager.h"
+#include "chromeos/dbus/ibus/ibus_client.h"
 #include "chromeos/dbus/ibus/ibus_input_context_client.h"
 #include "chromeos/dbus/ibus/ibus_text.h"
 #include "ui/base/events.h"
-#include "ui/base/ime/ibus_client_impl.h"
+#include "ui/base/ime/ibus_client.h"
 #include "ui/base/ime/text_input_client.h"
 #include "ui/base/keycodes/keyboard_code_conversion.h"
 #include "ui/base/keycodes/keyboard_code_conversion_x.h"
 #include "ui/base/keycodes/keyboard_codes.h"
 #include "ui/gfx/rect.h"
 
 namespace {
 
 const int kIBusReleaseMask = 1 << 30;
+const char kClientName[] = "chrome";
+
+// Following capability mask is introduced from
+// http://ibus.googlecode.com/svn/docs/ibus-1.4/ibus-ibustypes.html#IBusCapabilite
+const uint32 kIBusCapabilityPreeditText = 1U;
+const uint32 kIBusCapabilityFocus = 8U;
 
 XKeyEvent* GetKeyEvent(XEvent* event) {
   DCHECK(event && (event->type == KeyPress || event->type == KeyRelease));
   return &event->xkey;
 }
 
 // Converts X (and ibus) flags to event flags.
 int EventFlagsFromXFlags(unsigned int flags) {
   return (flags & LockMask ? ui::EF_CAPS_LOCK_DOWN : 0) |
       (flags & ControlMask ? ui::EF_CONTROL_DOWN : 0) |
@@ skipping 21 matching lines @@
   // translate Shift and CapsLock states.
   KeySym keysym = NoSymbol;
   ::XLookupString(x_key, NULL, 0, &keysym, NULL);
   *ibus_keyval = keysym;
   *ibus_keycode = x_key->keycode;
   *ibus_state = IBusStateFromXFlags(x_key->state);
   if (native_event->type == KeyRelease)
     *ibus_state |= kIBusReleaseMask;
 }
 
+chromeos::IBusInputContextClient* GetInputContextClient() {
+  return chromeos::DBusThreadManager::Get()->GetIBusInputContextClient();
+}
+
 }  // namespace
 
 namespace ui {
 
-// InputMethodIBus::PendingKeyEventImpl implementation ------------------------
-class InputMethodIBus::PendingKeyEventImpl
-    : public internal::IBusClient::PendingKeyEvent {
+// A class to hold all data related to a key event being processed by the input
+// method but still has no result back yet.
+class InputMethodIBus::PendingKeyEvent {
  public:
-  PendingKeyEventImpl(InputMethodIBus* input_method,
-                      const base::NativeEvent& native_event,
-                      uint32 ibus_keyval);
-  virtual ~PendingKeyEventImpl();
+  PendingKeyEvent(InputMethodIBus* input_method,
+                  const base::NativeEvent& native_event,
+                  uint32 ibus_keyval);
+  virtual ~PendingKeyEvent();
 
-  // internal::IBusClient::PendingKeyEvent overrides:
-  virtual void ProcessPostIME(bool handled) OVERRIDE;
+  // Process this pending key event after we receive its result from the input
+  // method. It just call through InputMethodIBus::ProcessKeyEventPostIME().
+  void ProcessPostIME(bool handled);
 
   // Abandon this pending key event. Its result will just be discarded.
   void Abandon() { input_method_ = NULL; }
 
   InputMethodIBus* input_method() const { return input_method_; }
 
  private:
   InputMethodIBus* input_method_;
 
   // TODO(yusukes): To support a fabricated key event (which is typically from
   // a virtual keyboard), we might have to copy event type, event flags, key
   // code, 'character_', and 'unmodified_character_'. See views::InputMethodIBus
   // for details.
 
   // corresponding XEvent data of a key event. It's a plain struct so we can do
   // bitwise copy.
   XKeyEvent x_event_;
 
   const uint32 ibus_keyval_;
 
-  DISALLOW_COPY_AND_ASSIGN(PendingKeyEventImpl);
+  DISALLOW_COPY_AND_ASSIGN(PendingKeyEvent);
 };
 
-InputMethodIBus::PendingKeyEventImpl::PendingKeyEventImpl(
+InputMethodIBus::PendingKeyEvent::PendingKeyEvent(
     InputMethodIBus* input_method,
     const base::NativeEvent& native_event,
     uint32 ibus_keyval)
     : input_method_(input_method),
       ibus_keyval_(ibus_keyval) {
   DCHECK(input_method_);
 
   // TODO(yusukes): Support non-native event (from e.g. a virtual keyboard).
   DCHECK(native_event);
   x_event_ = *GetKeyEvent(native_event);
 }
 
-InputMethodIBus::PendingKeyEventImpl::~PendingKeyEventImpl() {
+InputMethodIBus::PendingKeyEvent::~PendingKeyEvent() {
   if (input_method_)
     input_method_->FinishPendingKeyEvent(this);
 }
 
-void InputMethodIBus::PendingKeyEventImpl::ProcessPostIME(bool handled) {
+void InputMethodIBus::PendingKeyEvent::ProcessPostIME(bool handled) {
   if (!input_method_)
     return;
 
   if (x_event_.type == KeyPress || x_event_.type == KeyRelease) {
     input_method_->ProcessKeyEventPostIME(reinterpret_cast<XEvent*>(&x_event_),
                                           ibus_keyval_,
                                           handled);
     return;
   }
 
   // TODO(yusukes): Support non-native event (from e.g. a virtual keyboard).
   // See views::InputMethodIBus for details. Never forget to set 'character_'
   // and 'unmodified_character_' to support i18n VKs like a French VK!
 }
 
-// InputMethodIBus::PendingCreateICRequestImpl implementation -----------------
-class InputMethodIBus::PendingCreateICRequestImpl
-    : public internal::IBusClient::PendingCreateICRequest {
+// A class to hold information of a pending request for creating an ibus input
+// context.
+class InputMethodIBus::PendingCreateICRequest {
  public:
-  PendingCreateICRequestImpl(InputMethodIBus* input_method,
-                             internal::IBusClient* ibus_client,
-                             PendingCreateICRequestImpl** request_ptr);
-  virtual ~PendingCreateICRequestImpl();
+  PendingCreateICRequest(InputMethodIBus* input_method,
+                         PendingCreateICRequest** request_ptr);
+  virtual ~PendingCreateICRequest();
 
-  // internal::IBusClient::PendingCreateICRequest overrides:
-  virtual void InitOrAbandonInputContext() OVERRIDE;
-  virtual void OnCreateInputContextFailed() OVERRIDE;
+  // Set up signal handlers, or destroy object proxy if the input context is
+  // already abandoned.
+  void InitOrAbandonInputContext();
+
+  // Called if the create input context method call is failed.
+  void OnCreateInputContextFailed();
 
   // Abandon this pending key event. Its result will just be discarded.
   void Abandon() {
     input_method_ = NULL;
     request_ptr_ = NULL;
     // Do not reset |ibus_client_| here.
   }
 
  private:
   InputMethodIBus* input_method_;
-  internal::IBusClient* ibus_client_;
-  PendingCreateICRequestImpl** request_ptr_;
+  PendingCreateICRequest** request_ptr_;
 
-  DISALLOW_COPY_AND_ASSIGN(PendingCreateICRequestImpl);
+  DISALLOW_COPY_AND_ASSIGN(PendingCreateICRequest);
 };
 
-InputMethodIBus::PendingCreateICRequestImpl::PendingCreateICRequestImpl(
+InputMethodIBus::PendingCreateICRequest::PendingCreateICRequest(
     InputMethodIBus* input_method,
-    internal::IBusClient* ibus_client,
-    PendingCreateICRequestImpl** request_ptr)
+    PendingCreateICRequest** request_ptr)
     : input_method_(input_method),
-      ibus_client_(ibus_client),
       request_ptr_(request_ptr) {
 }
 
-InputMethodIBus::PendingCreateICRequestImpl::~PendingCreateICRequestImpl() {
+InputMethodIBus::PendingCreateICRequest::~PendingCreateICRequest() {
   if (request_ptr_) {
     DCHECK_EQ(*request_ptr_, this);
     *request_ptr_ = NULL;
   }
 }
 
-void InputMethodIBus::PendingCreateICRequestImpl::OnCreateInputContextFailed() {
+void InputMethodIBus::PendingCreateICRequest::OnCreateInputContextFailed() {
   // TODO(nona): If the connection between Chrome and ibus-daemon terminates
   // for some reason, the create ic request will fail. We might want to call
   // ibus_client_->CreateContext() again after some delay.
 }
 
-void InputMethodIBus::PendingCreateICRequestImpl::InitOrAbandonInputContext() {
+void InputMethodIBus::PendingCreateICRequest::InitOrAbandonInputContext() {
   if (input_method_) {
-    DCHECK(ibus_client_->IsContextReady());
+    DCHECK(input_method_->IsContextReady());
     input_method_->SetUpSignalHandlers();
   } else {
-    ibus_client_->DestroyProxy();
-    DCHECK(!ibus_client_->IsContextReady());
+    GetInputContextClient()->ResetObjectProxy();
   }
 }
 
 // InputMethodIBus implementation -----------------------------------------
 InputMethodIBus::InputMethodIBus(
     internal::InputMethodDelegate* delegate)
-    :
-      ibus_client_(new internal::IBusClientImpl),
+    : ibus_client_(new internal::IBusClient),
       pending_create_ic_request_(NULL),
       context_focused_(false),
       composing_text_(false),
       composition_changed_(false),
       suppress_next_result_(false),
       weak_ptr_factory_(this) {
   SetDelegate(delegate);
 }
 
 InputMethodIBus::~InputMethodIBus() {
   AbandonAllPendingKeyEvents();
-  if (ibus_client_->IsContextReady())
+  if (IsContextReady())
     DestroyContext();
 }
 
 void InputMethodIBus::set_ibus_client(
     scoped_ptr<internal::IBusClient> new_client) {
   ibus_client_.swap(new_client);
 }
 
 internal::IBusClient* InputMethodIBus::ibus_client() const {
   return ibus_client_.get();
 }
 
 void InputMethodIBus::OnFocus() {
   InputMethodBase::OnFocus();
   UpdateContextFocusState();
 }
 
 void InputMethodIBus::OnBlur() {
   ConfirmCompositionText();
   InputMethodBase::OnBlur();
   UpdateContextFocusState();
 }
 
 void InputMethodIBus::Init(bool focused) {
   // Initializes the connection to ibus daemon. It may happen asynchronously,
   // and as soon as the connection is established, the |context_| will be
   // created automatically.
 
   // Create the input context if the connection is already established.
-  if (ibus_client_->IsConnected())
+  if (IsConnected())
     CreateContext();
 
   InputMethodBase::Init(focused);
 }
 
 // static
 void InputMethodIBus::ProcessKeyEventDone(
-    PendingKeyEventImpl* pending_key_event, bool is_handled) {
+    PendingKeyEvent* pending_key_event, bool is_handled) {
   DCHECK(pending_key_event);
   pending_key_event->ProcessPostIME(is_handled);
   delete pending_key_event;
 }
 
 void InputMethodIBus::DispatchKeyEvent(const base::NativeEvent& native_event) {
   DCHECK(native_event && (native_event->type == KeyPress ||
                           native_event->type == KeyRelease));
   DCHECK(system_toplevel_window_focused());
 
@@ skipping 12 matching lines @@
       GetTextInputType() == TEXT_INPUT_TYPE_PASSWORD ||
       ibus_client_->GetInputMethodType() ==
       internal::IBusClient::INPUT_METHOD_XKB_LAYOUT) {
     if (native_event->type == KeyPress)
       ProcessUnfilteredKeyPressEvent(native_event, ibus_keyval);
     else
       DispatchKeyEventPostIME(native_event);
     return;
   }
 
-  PendingKeyEventImpl* pending_key =
-      new PendingKeyEventImpl(this, native_event, ibus_keyval);
+  PendingKeyEvent* pending_key =
+      new PendingKeyEvent(this, native_event, ibus_keyval);
   pending_key_events_.insert(pending_key);
 
-  ibus_client_->SendKeyEvent(ibus_keyval,
-                             ibus_keycode,
-                             ibus_state,
-                             base::Bind(&InputMethodIBus::ProcessKeyEventDone,
-                                        base::Unretained(pending_key)));
+  GetInputContextClient()->ProcessKeyEvent(
+      ibus_keyval,
+      ibus_keycode,
+      ibus_state, base::Bind(&InputMethodIBus::ProcessKeyEventDone,
+                             base::Unretained(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(const TextInputClient* client) {
-  if (ibus_client_->IsContextReady() && IsTextInputClientFocused(client)) {
+  if (IsContextReady() && IsTextInputClientFocused(client)) {
     ResetContext();
     UpdateContextFocusState();
   }
   InputMethodBase::OnTextInputTypeChanged(client);
 }
 
 void InputMethodIBus::OnCaretBoundsChanged(const TextInputClient* client) {
   if (!context_focused_ || !IsTextInputClientFocused(client))
     return;
 
@@ skipping 42 matching lines @@
   // focus and after it acquires focus again are the same.
   OnTextInputTypeChanged(focused);
 
   UpdateContextFocusState();
   // Force to update caret bounds, in case the client thinks that the caret
   // bounds has not changed.
   OnCaretBoundsChanged(focused);
 }
 
 void InputMethodIBus::CreateContext() {
-  DCHECK(ibus_client_->IsConnected());
+  DCHECK(IsConnected());
   DCHECK(!pending_create_ic_request_);
 
+  pending_create_ic_request_ = new PendingCreateICRequest(
+      this, &pending_create_ic_request_);
+
   // Creates the input context asynchronously.
-  pending_create_ic_request_ = new PendingCreateICRequestImpl(
-      this, ibus_client_.get(), &pending_create_ic_request_);
-  ibus_client_->CreateContext(pending_create_ic_request_);
+  chromeos::DBusThreadManager::Get()->GetIBusClient()->CreateInputContext(
+      kClientName,
+      base::Bind(&InputMethodIBus::CreateInputContextDone,
+                 weak_ptr_factory_.GetWeakPtr(),
+                 base::Unretained(pending_create_ic_request_)),
+      base::Bind(&InputMethodIBus::CreateInputContextFail,
+                 weak_ptr_factory_.GetWeakPtr(),
+                 base::Unretained(pending_create_ic_request_)));
 }
 
 void InputMethodIBus::SetUpSignalHandlers() {
-  DCHECK(ibus_client_->IsContextReady());
+  DCHECK(IsContextReady());
 
   // connect input context signals
   chromeos::IBusInputContextClient* input_context_client =
       chromeos::DBusThreadManager::Get()->GetIBusInputContextClient();
   input_context_client->SetCommitTextHandler(
       base::Bind(&InputMethodIBus::OnCommitText,
                  weak_ptr_factory_.GetWeakPtr()));
 
   input_context_client->SetForwardKeyEventHandler(
       base::Bind(&InputMethodIBus::OnForwardKeyEvent,
                  weak_ptr_factory_.GetWeakPtr()));
 
   input_context_client->SetUpdatePreeditTextHandler(
       base::Bind(&InputMethodIBus::OnUpdatePreeditText,
                  weak_ptr_factory_.GetWeakPtr()));
 
   input_context_client->SetShowPreeditTextHandler(
       base::Bind(&InputMethodIBus::OnShowPreeditText,
                  weak_ptr_factory_.GetWeakPtr()));
 
   input_context_client->SetHidePreeditTextHandler(
       base::Bind(&InputMethodIBus::OnHidePreeditText,
                  weak_ptr_factory_.GetWeakPtr()));
 
-  ibus_client_->SetCapabilities(internal::IBusClient::INLINE_COMPOSITION);
+  GetInputContextClient()->SetCapabilities(
+      kIBusCapabilityPreeditText | kIBusCapabilityFocus);
 
   UpdateContextFocusState();
   // Since ibus-daemon is launched in an on-demand basis on Chrome OS, RWHVA (or
   // equivalents) might call OnCaretBoundsChanged() before the daemon starts. To
   // save the case, call OnCaretBoundsChanged() here.
   OnCaretBoundsChanged(GetTextInputClient());
   OnInputMethodChanged();
 }
 
 void InputMethodIBus::DestroyContext() {
   if (pending_create_ic_request_) {
-    DCHECK(!ibus_client_->IsContextReady());
+    DCHECK(!IsContextReady());
     // |pending_create_ic_request_| will be deleted in CreateInputContextDone().
     pending_create_ic_request_->Abandon();
     pending_create_ic_request_ = NULL;
     return;
   }
   const chromeos::IBusInputContextClient* input_context =
       chromeos::DBusThreadManager::Get()->GetIBusInputContextClient();
   if (input_context && input_context->IsObjectProxyReady()) {
     // We can't use IsContextReady here because we want to destroy object proxy
     // regardless of connection. The IsContextReady contains connection check.
     ResetInputContext();
-    DCHECK(!ibus_client_->IsContextReady());
+    DCHECK(!IsContextReady());
   }
 }
 
 void InputMethodIBus::ConfirmCompositionText() {
   TextInputClient* client = GetTextInputClient();
   if (client && client->HasCompositionText())
     client->ConfirmCompositionText();
 
   ResetContext();
 }
@@ skipping 21 matching lines @@
 
   // We need to abandon all pending key events, but as above comment says, there
   // 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_client_->Reset();
+  GetInputContextClient()->Reset();
 
   character_composer_.Reset();
 }
 
 void InputMethodIBus::UpdateContextFocusState() {
-  if (!ibus_client_->IsContextReady()) {
+  if (!IsContextReady()) {
     context_focused_ = false;
     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 TEXT_INPUT_TYPE_NONE:
     case 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_client_->FocusOut();
+    GetInputContextClient()->FocusOut();
   else if (!old_context_focused && context_focused_)
-    ibus_client_->FocusIn();
+    GetInputContextClient()->FocusIn();
 
   if (context_focused_) {
-    internal::IBusClient::InlineCompositionCapability capability =
-        CanComposeInline() ? internal::IBusClient::INLINE_COMPOSITION
-                           : internal::IBusClient::OFF_THE_SPOT_COMPOSITION;
-    ibus_client_->SetCapabilities(capability);
+    uint32 capability = kIBusCapabilityFocus;
+    if (CanComposeInline())
+      capability |= kIBusCapabilityPreeditText;
+    GetInputContextClient()->SetCapabilities(capability);
   }
 }
 
 void InputMethodIBus::ProcessKeyEventPostIME(
     const base::NativeEvent& native_event,
     uint32 ibus_keyval,
     bool handled) {
   TextInputClient* client = GetTextInputClient();
 
   if (!client) {
@@ skipping 176 matching lines @@
 bool InputMethodIBus::HasInputMethodResult() const {
   return result_text_.length() || composition_changed_;
 }
 
 void InputMethodIBus::SendFakeProcessKeyEvent(bool pressed) const {
   DispatchFabricatedKeyEventPostIME(pressed ? ET_KEY_PRESSED : ET_KEY_RELEASED,
                                     VKEY_PROCESSKEY,
                                     0);
 }
 
-void InputMethodIBus::FinishPendingKeyEvent(PendingKeyEventImpl* pending_key) {
+void InputMethodIBus::FinishPendingKeyEvent(PendingKeyEvent* pending_key) {
   DCHECK(pending_key_events_.count(pending_key));
 
   // |pending_key| will be deleted in ProcessKeyEventDone().
   pending_key_events_.erase(pending_key);
 }
 
 void InputMethodIBus::AbandonAllPendingKeyEvents() {
-  std::set<PendingKeyEventImpl*>::iterator i;
+  std::set<PendingKeyEvent*>::iterator i;
   for (i = pending_key_events_.begin(); i != pending_key_events_.end(); ++i) {
     // The object will be deleted in ProcessKeyEventDone().
     (*i)->Abandon();
   }
   pending_key_events_.clear();
 }
 
 void InputMethodIBus::OnCommitText(const chromeos::ibus::IBusText& text) {
   if (suppress_next_result_ || text.text().empty())
     return;
@@ skipping 109 matching lines @@
   }
 }
 
 void InputMethodIBus::ResetInputContext() {
   context_focused_ = false;
 
   ConfirmCompositionText();
 
   // We are dead, so we need to ask the client to stop relying on us.
   OnInputMethodChanged();
-  ibus_client_->DestroyProxy();
+  GetInputContextClient()->ResetObjectProxy();
+}
+
+void InputMethodIBus::CreateInputContextDone(
+    PendingCreateICRequest* ic_request,
+    const dbus::ObjectPath& object_path) {
+  chromeos::DBusThreadManager::Get()->GetIBusInputContextClient()
+      ->Initialize(chromeos::DBusThreadManager::Get()->GetIBusBus(),
+                   object_path);
+  ic_request->InitOrAbandonInputContext();
+  delete ic_request;
+}
+
+void InputMethodIBus::CreateInputContextFail(
+    PendingCreateICRequest* ic_request) {
+  ic_request->OnCreateInputContextFailed();
+  delete ic_request;
+}
+
+bool InputMethodIBus::IsConnected() {
+  return chromeos::DBusThreadManager::Get()->GetIBusBus() != NULL;
+}
+
+bool InputMethodIBus::IsContextReady() {
+  if (!IsConnected())
+    return false;
+  if (!GetInputContextClient())
+    return false;
+  return GetInputContextClient()->IsObjectProxyReady();
 }
 
 void InputMethodIBus::OnConnected() {
-  DCHECK(ibus_client_->IsConnected());
+  DCHECK(IsConnected());
   // If already input context is initialized, do nothing.
-  if (ibus_client_->IsContextReady())
+  if (IsContextReady())
     return;
 
   DestroyContext();
   CreateContext();
 }
 
 void InputMethodIBus::OnDisconnected() {
   DestroyContext();
 }
 
@@ skipping 76 matching lines @@
   }
 
   // Use a black thin underline by default.
   if (out_composition->underlines.empty()) {
     out_composition->underlines.push_back(CompositionUnderline(
         0, length, SK_ColorBLACK, false /* thick */));
   }
 }
 
 }  // namespace ui