Delete IBusEngineService.

chrome/browser/chromeos/input_method/input_method_engine_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 "chrome/browser/chromeos/input_method/input_method_engine_ibus.h"
 
 #define XK_MISCELLANY
 #include <X11/keysymdef.h>
 #include <map>
 
+#include "base/bind.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "chromeos/dbus/dbus_thread_manager.h"
-#include "chromeos/dbus/ibus/ibus_engine_service.h"
 #include "chromeos/dbus/ibus/ibus_text.h"
 #include "chromeos/ime/candidate_window.h"
 #include "chromeos/ime/component_extension_ime_manager.h"
 #include "chromeos/ime/extension_ime_util.h"
 #include "chromeos/ime/ibus_keymap.h"
 #include "chromeos/ime/input_method_manager.h"
 #include "dbus/object_path.h"
 
 namespace chromeos {
 const char* kErrorNotActive = "IME is not active";
 const char* kErrorWrongContext = "Context is not active";
 const char* kCandidateNotFound = "Candidate not found";
 const char* kEngineBusPrefix = "org.freedesktop.IBus.";
 
 namespace {
 const uint32 kIBusAltKeyMask = 1 << 3;
 const uint32 kIBusCtrlKeyMask = 1 << 2;
 const uint32 kIBusShiftKeyMask = 1 << 0;
 const uint32 kIBusCapsLockMask = 1 << 1;
 const uint32 kIBusKeyReleaseMask = 1 << 30;
+
+// Notifies InputContextHandler that the preedit is changed.
+void UpdatePreedit(const IBusText& ibus_text,
+                   uint32 cursor_pos,
+                   bool is_visible) {
+  IBusInputContextHandlerInterface* input_context =
+      IBusBridge::Get()->GetInputContextHandler();
+  if (input_context)
+    input_context->UpdatePreeditText(ibus_text, cursor_pos, is_visible);
 }
 
+// Notifies CandidateWindowHandler that the auxilary text is changed.
+// Auxilary text is usually footer text.
+void UpdateAuxiliaryText(const IBusText& ibus_text, bool is_visible) {
+  IBusPanelCandidateWindowHandlerInterface* candidate_window =
+      IBusBridge::Get()->GetCandidateWindowHandler();
+  if (candidate_window)
+    candidate_window->UpdateAuxiliaryText(ibus_text.text(), is_visible);
+}
+
+}  // namespace
+
 InputMethodEngineIBus::InputMethodEngineIBus()
     : focused_(false),
       active_(false),
       context_id_(0),
       next_context_id_(1),
-      is_create_engine_handler_called_(false),
       aux_text_(new IBusText()),
       aux_text_visible_(false),
       observer_(NULL),
       preedit_text_(new IBusText()),
       preedit_cursor_(0),
       candidate_window_(new input_method::CandidateWindow()),
       window_visible_(false),
       weak_ptr_factory_(this) {}
 
 InputMethodEngineIBus::~InputMethodEngineIBus() {
   input_method::InputMethodManager::Get()->RemoveInputMethodExtension(ibus_id_);
 
   // Do not unset engine before removing input method extension, above
   // function may call reset function of engine object.
-  if (is_create_engine_handler_called_) {
-    GetCurrentService()->UnsetEngine(this);
-    ibus_engine_service_.reset();
-  }
+  if (IBusBridge::Get()->GetEngineHandler() == this)
+    IBusBridge::Get()->SetEngineHandler(NULL);
 }
 
 void InputMethodEngineIBus::Initialize(
     InputMethodEngine::Observer* observer,
     const char* engine_name,
     const char* extension_id,
     const char* engine_id,
     const char* description,
     const std::vector<std::string>& languages,
     const std::vector<std::string>& layouts,
@@ skipping 71 matching lines @@
       default:
         continue;
     }
 
     underline.start_index = segment->start;
     underline.end_index = segment->end;
     preedit_text_->mutable_underline_attributes()->push_back(underline);
   }
 
   // TODO(nona): Makes focus out mode configuable, if necessary.
-  GetCurrentService()->UpdatePreedit(
-      *preedit_text_.get(),
-      preedit_cursor_,
-      true,
-      IBusEngineService::IBUS_ENGINE_PREEEDIT_FOCUS_OUT_MODE_COMMIT);
+  UpdatePreedit(*preedit_text_, preedit_cursor_, true);
   return true;
 }
 
 bool InputMethodEngineIBus::ClearComposition(int context_id,
                                              std::string* error)  {
   if (!active_) {
     *error = kErrorNotActive;
     return false;
   }
   if (context_id != context_id_ || context_id_ == -1) {
     *error = kErrorWrongContext;
     return false;
   }
 
   preedit_cursor_ = 0;
   preedit_text_.reset(new IBusText());
-  GetCurrentService()->UpdatePreedit(
-      *preedit_text_.get(),
-      0,
-      false,
-      IBusEngineService::IBUS_ENGINE_PREEEDIT_FOCUS_OUT_MODE_COMMIT);
+  UpdatePreedit(*preedit_text_, preedit_cursor_, false);
   return true;
 }
 
 bool InputMethodEngineIBus::CommitText(int context_id, const char* text,
                                        std::string* error) {
   if (!active_) {
     // TODO: Commit the text anyways.
     *error = kErrorNotActive;
     return false;
   }
@@ skipping 46 matching lines @@
     IBusBridge::Get()->GetCandidateWindowHandler();
   if (cw_handler)
     cw_handler->UpdateLookupTable(*candidate_window_, window_visible_);
   return true;
 }
 
 void InputMethodEngineIBus::SetCandidateWindowAuxText(const char* text) {
   aux_text_->set_text(text);
   if (active_) {
     // Should not show auxiliary text if the whole window visibility is false.
-    GetCurrentService()->UpdateAuxiliaryText(
-        *aux_text_.get(),
-        window_visible_ && aux_text_visible_);
+    UpdateAuxiliaryText(*aux_text_, window_visible_ && aux_text_visible_);
   }
 }
 
 void InputMethodEngineIBus::SetCandidateWindowAuxTextVisible(bool visible) {
   aux_text_visible_ = visible;
   if (active_) {
     // Should not show auxiliary text if the whole window visibility is false.
-    GetCurrentService()->UpdateAuxiliaryText(
-        *aux_text_.get(),
-        window_visible_ && aux_text_visible_);
+    UpdateAuxiliaryText(*aux_text_, window_visible_ && aux_text_visible_);
   }
 }
 
 bool InputMethodEngineIBus::SetCandidates(
     int context_id,
     const std::vector<Candidate>& candidates,
     std::string* error) {
   if (!active_) {
     *error = kErrorNotActive;
     return false;
@@ skipping 104 matching lines @@
   }
   if (context_id != context_id_ || context_id_ == -1) {
     *error = kErrorWrongContext;
     return false;
   }
 
   if (offset < 0 && static_cast<size_t>(-1 * offset) != size_t(number_of_chars))
     return false;  // Currently we can only support preceding text.
 
   // TODO(nona): Return false if there is ongoing composition.
-  GetCurrentService()->DeleteSurroundingText(offset, number_of_chars);
+
+  IBusInputContextHandlerInterface* input_context =
+      IBusBridge::Get()->GetInputContextHandler();
+  if (input_context)
+    input_context->DeleteSurroundingText(offset, number_of_chars);
+
   return true;
 }
 
 void InputMethodEngineIBus::FocusIn(ibus::TextInputType text_input_type) {
   focused_ = true;
   if (!active_)
     return;
   context_id_ = next_context_id_;
   ++next_context_id_;
 
@@ skipping 29 matching lines @@
     return;
   int context_id = context_id_;
   context_id_ = -1;
   observer_->OnBlur(context_id);
 }
 
 void InputMethodEngineIBus::Enable() {
   active_ = true;
   observer_->OnActivate(engine_id_);
   FocusIn(ibus::TEXT_INPUT_TYPE_TEXT);
-
-  // Calls RequireSurroundingText once here to notify ibus-daemon to send
-  // surrounding text to this engine.
-  GetCurrentService()->RequireSurroundingText();
 }
 
 void InputMethodEngineIBus::Disable() {
   active_ = false;
   observer_->OnDeactivated(engine_id_);
 }
 
 void InputMethodEngineIBus::PropertyActivate(const std::string& property_name) {
   observer_->OnMenuItemActivated(engine_id_, property_name);
 }
@@ skipping 67 matching lines @@
 
 void InputMethodEngineIBus::SetSurroundingText(const std::string& text,
                                                uint32 cursor_pos,
                                                uint32 anchor_pos) {
   observer_->OnSurroundingTextChanged(engine_id_,
                                       text,
                                       static_cast<int>(cursor_pos),
                                       static_cast<int>(anchor_pos));
 }
 
-IBusEngineService* InputMethodEngineIBus::GetCurrentService() {
-  if (!ibus_engine_service_)
-    ibus_engine_service_.reset(IBusEngineService::Create());
-  return ibus_engine_service_.get();
-}
-
 void InputMethodEngineIBus::MenuItemToProperty(
     const MenuItem& item,
     input_method::InputMethodProperty* property) {
   property->key = item.id;
 
   if (item.modified & MENU_ITEM_MODIFIED_LABEL) {
     property->label = item.label;
   }
   if (item.modified & MENU_ITEM_MODIFIED_VISIBLE) {
     // TODO(nona): Implement it.
@@ skipping 36 matching lines @@
 }
 
 void InputMethodEngineIBus::RegisterComponent() {
   IBusBridge::Get()->SetCreateEngineHandler(
       ibus_id_,
       base::Bind(&InputMethodEngineIBus::CreateEngineHandler,
                  weak_ptr_factory_.GetWeakPtr()));
 }
 
 void InputMethodEngineIBus::CreateEngineHandler() {
-  GetCurrentService()->UnsetEngine(this);
-  ibus_engine_service_.reset();
-  GetCurrentService()->SetEngine(this);
-  is_create_engine_handler_called_ = true;
+  IBusBridge::Get()->SetEngineHandler(this);
 }
 
 }  // namespace chromeos