Clean Up: Remove ibus namespace.

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"
 
 #include <map>
 
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
@@ skipping 27 matching lines @@
 const uint32 kIBusShiftKeyMask = 1 << 0;
 const uint32 kIBusKeyReleaseMask = 1 << 30;
 }
 
 InputMethodEngineIBus::InputMethodEngineIBus()
     : focused_(false),
       active_(false),
       context_id_(0),
       next_context_id_(1),
       current_object_path_(0),
-      aux_text_(new ibus::IBusText()),
+      aux_text_(new IBusText()),
       aux_text_visible_(false),
       observer_(NULL),
-      preedit_text_(new ibus::IBusText()),
+      preedit_text_(new IBusText()),
       preedit_cursor_(0),
-      component_(new ibus::IBusComponent()),
-      table_(new ibus::IBusLookupTable()),
+      component_(new IBusComponent()),
+      table_(new IBusLookupTable()),
       window_visible_(false),
       weak_ptr_factory_(this) {
 }
 
 InputMethodEngineIBus::~InputMethodEngineIBus() {
   if (object_path_.IsValid())
     GetCurrentService()->UnsetEngine();
   input_method::GetInputMethodManager()->RemoveInputMethodExtension(ibus_id_);
 }
 
@@ skipping 21 matching lines @@
     layout = JoinString(layouts, ',');
   } else {
     const std::string fallback_id =
         manager->GetInputMethodUtil()->GetHardwareInputMethodId();
     const input_method::InputMethodDescriptor* fallback_desc =
         manager->GetInputMethodUtil()->GetInputMethodDescriptorFromId(
             fallback_id);
     layout = fallback_desc->keyboard_layout();
   }
 
-  component_.reset(new ibus::IBusComponent());
+  component_.reset(new IBusComponent());
   component_->set_name(std::string(kEngineBusPrefix) + std::string(engine_id));
   component_->set_description(description);
   component_->set_author(engine_name);
 
-  chromeos::ibus::IBusComponent::EngineDescription engine_desc;
+  chromeos::IBusComponent::EngineDescription engine_desc;
   engine_desc.engine_id = ibus_id_;
   engine_desc.display_name = description;
   engine_desc.description = description;
   engine_desc.language_code = language;
   engine_desc.author = ibus_id_;
   engine_desc.layout = layout.c_str();
 
   component_->mutable_engine_description()->push_back(engine_desc);
   manager->AddInputMethodExtension(ibus_id_, engine_name, layouts, language,
                                    this);
@@ skipping 14 matching lines @@
   if (!active_) {
     *error = kErrorNotActive;
     return false;
   }
   if (context_id != context_id_ || context_id_ == -1) {
     *error = kErrorWrongContext;
     return false;
   }
 
   preedit_cursor_ = cursor;
-  preedit_text_.reset(new ibus::IBusText());
+  preedit_text_.reset(new IBusText());
   preedit_text_->set_text(text);
 
   // TODO: Add support for displaying selected text in the composition string.
   for (std::vector<SegmentInfo>::const_iterator segment = segments.begin();
        segment != segments.end(); ++segment) {
-    ibus::IBusText::UnderlineAttribute underline;
+    IBusText::UnderlineAttribute underline;
 
     switch (segment->style) {
       case SEGMENT_STYLE_UNDERLINE:
-        underline.type = ibus::IBusText::IBUS_TEXT_UNDERLINE_SINGLE;
+        underline.type = IBusText::IBUS_TEXT_UNDERLINE_SINGLE;
         break;
       case SEGMENT_STYLE_DOUBLE_UNDERLINE:
-        underline.type = ibus::IBusText::IBUS_TEXT_UNDERLINE_DOUBLE;
+        underline.type = IBusText::IBUS_TEXT_UNDERLINE_DOUBLE;
         break;
       default:
         continue;
     }
 
     underline.start_index = segment->start;
     underline.end_index = segment->end;
     preedit_text_->mutable_underline_attributes()->push_back(underline);
   }
 
@@ skipping 11 matching lines @@
   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 ibus::IBusText());
+  preedit_text_.reset(new IBusText());
   GetCurrentService()->UpdatePreedit(
       *preedit_text_.get(),
       0,
       true,
       chromeos::IBusEngineService::IBUS_ENGINE_PREEEDIT_FOCUS_OUT_MODE_COMMIT);
   return true;
 }
 
 bool InputMethodEngineIBus::CommitText(int context_id, const char* text,
                                        std::string* error) {
@@ skipping 23 matching lines @@
   return true;
 }
 
 void InputMethodEngineIBus::SetCandidateWindowCursorVisible(bool visible) {
   table_->set_is_cursor_visible(visible);
   if (active_)
     GetCurrentService()->UpdateLookupTable(*table_.get(), window_visible_);
 }
 
 void InputMethodEngineIBus::SetCandidateWindowVertical(bool vertical) {
-  table_->set_orientation(vertical ? ibus::IBusLookupTable::VERTICAL :
-                          ibus::IBusLookupTable::HORIZONTAL);
+  table_->set_orientation(vertical ? IBusLookupTable::VERTICAL :
+                          IBusLookupTable::HORIZONTAL);
   if (active_)
     GetCurrentService()->UpdateLookupTable(*table_.get(), window_visible_);
 }
 
 void InputMethodEngineIBus::SetCandidateWindowPageSize(int size) {
   table_->set_page_size(size);
   if (active_)
     GetCurrentService()->UpdateLookupTable(*table_.get(), window_visible_);
 }
 
@@ skipping 29 matching lines @@
     *error = kErrorWrongContext;
     return false;
   }
 
   // TODO: Nested candidates
   candidate_ids_.clear();
   candidate_indexes_.clear();
   table_->mutable_candidates()->clear();
   for (std::vector<Candidate>::const_iterator ix = candidates.begin();
        ix != candidates.end(); ++ix) {
-    ibus::IBusLookupTable::Entry entry;
+    IBusLookupTable::Entry entry;
     entry.value = ix->value;
     entry.label = ix->label;
     entry.annotation = ix->annotation;
     entry.description_title = ix->usage.title;
     entry.description_body = ix->usage.body;
 
     // Store a mapping from the user defined ID to the candidate index.
     candidate_indexes_[ix->id] = candidate_ids_.size();
     candidate_ids_.push_back(ix->id);
 
@@ skipping 23 matching lines @@
 
   table_->set_cursor_position(position->second);
   GetCurrentService()->UpdateLookupTable(*table_.get(), window_visible_);
   return true;
 }
 
 bool InputMethodEngineIBus::SetMenuItems(const std::vector<MenuItem>& items) {
   if (!active_)
     return false;
 
-  ibus::IBusPropertyList properties;
+  IBusPropertyList properties;
   for (std::vector<MenuItem>::const_iterator item = items.begin();
        item != items.end(); ++item) {
-    ibus::IBusProperty* property = new ibus::IBusProperty();
+    IBusProperty* property = new IBusProperty();
     if (!MenuItemToProperty(*item, property)) {
       delete property;
       DVLOG(1) << "Bad menu item";
       return false;
     }
     properties.push_back(property);
   }
   GetCurrentService()->RegisterProperties(properties);
   return true;
 }
 
 bool InputMethodEngineIBus::UpdateMenuItems(
     const std::vector<MenuItem>& items) {
   if (!active_)
     return false;
 
-  ibus::IBusPropertyList properties;
+  IBusPropertyList properties;
   for (std::vector<MenuItem>::const_iterator item = items.begin();
        item != items.end(); ++item) {
-    ibus::IBusProperty* property = new ibus::IBusProperty();
+    IBusProperty* property = new IBusProperty();
     if (!MenuItemToProperty(*item, property)) {
       delete property;
       DVLOG(1) << "Bad menu item";
       return false;
     }
     properties.push_back(property);
   }
   GetCurrentService()->RegisterProperties(properties);
   return true;
 }
@@ skipping 40 matching lines @@
   FocusIn();
 }
 
 void InputMethodEngineIBus::Disable() {
   active_ = false;
   observer_->OnDeactivated(engine_id_);
 }
 
 void InputMethodEngineIBus::PropertyActivate(
     const std::string& property_name,
-    IBusPropertyState property_state) {
+    ibus::IBusPropertyState property_state) {
   observer_->OnMenuItemActivated(engine_id_, property_name);
 }
 
 void InputMethodEngineIBus::PropertyShow(
     const std::string& property_name) {
 }
 
 void InputMethodEngineIBus::PropertyHide(
     const std::string& property_name) {
 }
@@ skipping 19 matching lines @@
   event.key = input_method::GetIBusKey(keysym);
   event.alt_key = state & kIBusAltKeyMask;
   event.ctrl_key = state & kIBusCtrlKeyMask;
   event.shift_key = state & kIBusShiftKeyMask;
   observer_->OnKeyEvent(
       engine_id_,
       event,
       reinterpret_cast<input_method::KeyEventHandle*>(handler));
 }
 
-void InputMethodEngineIBus::CandidateClicked(
-    uint32 index,
-    ibus::IBusMouseButton button,
-    uint32 state) {
+void InputMethodEngineIBus::CandidateClicked(uint32 index,
+                                             ibus::IBusMouseButton button,
+                                             uint32 state) {
   if (index > candidate_ids_.size()) {
     return;
   }
 
   MouseButtonEvent pressed_button;
   switch (button) {
     case ibus::IBUS_MOUSE_BUTTON_LEFT:
       pressed_button = MOUSE_BUTTON_LEFT;
       break;
     case ibus::IBUS_MOUSE_BUTTON_MIDDLE:
@@ skipping 17 matching lines @@
     uint32 cursor_pos,
     uint32 anchor_pos) {
 }
 
 IBusEngineService* InputMethodEngineIBus::GetCurrentService() {
   return DBusThreadManager::Get()->GetIBusEngineService(object_path_);
 }
 
 bool InputMethodEngineIBus::MenuItemToProperty(
     const MenuItem& item,
-    ibus::IBusProperty* property) {
+    IBusProperty* property) {
   property->set_key(item.id);
 
   if (item.modified & MENU_ITEM_MODIFIED_LABEL) {
     property->set_label(item.label);
   }
   if (item.modified & MENU_ITEM_MODIFIED_VISIBLE) {
     property->set_visible(item.visible);
   }
   if (item.modified & MENU_ITEM_MODIFIED_CHECKED) {
     property->set_checked(item.checked);
   }
   if (item.modified & MENU_ITEM_MODIFIED_ENABLED) {
     // TODO(nona): implement sensitive entry(crbug.com/140192).
   }
   if (item.modified & MENU_ITEM_MODIFIED_STYLE) {
-    ibus::IBusProperty::IBusPropertyType type =
-        ibus::IBusProperty::IBUS_PROPERTY_TYPE_NORMAL;
+    IBusProperty::IBusPropertyType type =
+        IBusProperty::IBUS_PROPERTY_TYPE_NORMAL;
     if (!item.children.empty()) {
-      type = ibus::IBusProperty::IBUS_PROPERTY_TYPE_MENU;
+      type = IBusProperty::IBUS_PROPERTY_TYPE_MENU;
     } else {
       switch (item.style) {
         case MENU_ITEM_STYLE_NONE:
-          type = ibus::IBusProperty::IBUS_PROPERTY_TYPE_NORMAL;
+          type = IBusProperty::IBUS_PROPERTY_TYPE_NORMAL;
           break;
         case MENU_ITEM_STYLE_CHECK:
-          type = ibus::IBusProperty::IBUS_PROPERTY_TYPE_TOGGLE;
+          type = IBusProperty::IBUS_PROPERTY_TYPE_TOGGLE;
           break;
         case MENU_ITEM_STYLE_RADIO:
-          type = ibus::IBusProperty::IBUS_PROPERTY_TYPE_RADIO;
+          type = IBusProperty::IBUS_PROPERTY_TYPE_RADIO;
           break;
         case MENU_ITEM_STYLE_SEPARATOR:
-          type = ibus::IBusProperty::IBUS_PROPERTY_TYPE_SEPARATOR;
+          type = IBusProperty::IBUS_PROPERTY_TYPE_SEPARATOR;
           break;
       }
     }
     property->set_type(type);
   }
 
   for (std::vector<MenuItem>::const_iterator child = item.children.begin();
        child != item.children.end(); ++child) {
-    ibus::IBusProperty* new_property = new ibus::IBusProperty();
+    IBusProperty* new_property = new IBusProperty();
     if (!MenuItemToProperty(*child, new_property)) {
       delete new_property;
       DVLOG(1) << "Bad menu item child";
       return false;
     }
     property->mutable_sub_properties()->push_back(new_property);
   }
 
   return true;
 }
@@ skipping 38 matching lines @@
   DBusThreadManager::Get()->RemoveIBusEngineService(object_path_);
 
   current_object_path_++;
   object_path_ = dbus::ObjectPath(kObjectPathPrefix +
                                   base::IntToString(current_object_path_));
   GetCurrentService()->SetEngine(this);
   sender.Run(object_path_);
 }
 
 }  // namespace chromeos