Clean Up: Remove ibus namespace.

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
@@ skipping 618 matching lines @@
 void InputMethodIBus::SendFakeProcessKeyEvent(bool pressed) const {
   DispatchFabricatedKeyEventPostIME(pressed ? ET_KEY_PRESSED : ET_KEY_RELEASED,
                                     VKEY_PROCESSKEY,
                                     0);
 }
 
 void InputMethodIBus::AbandonAllPendingKeyEvents() {
   pending_key_events_.clear();
 }
 
-void InputMethodIBus::CommitText(const chromeos::ibus::IBusText& text) {
+void InputMethodIBus::CommitText(const chromeos::IBusText& text) {
   if (suppress_next_result_ || text.text().empty())
     return;
 
   // We need to receive input method result even if the text input type is
   // TEXT_INPUT_TYPE_NONE, to make sure we can always send correct
   // character for each key event to the focused text input client.
   if (!GetTextInputClient())
     return;
 
   const string16 utf16_text = UTF8ToUTF16(text.text());
@@ skipping 38 matching lines @@
   }
 }
 
 void InputMethodIBus::ShowPreeditText() {
   if (suppress_next_result_ || IsTextInputTypeNone())
     return;
 
   composing_text_ = true;
 }
 
-void InputMethodIBus::UpdatePreeditText(const chromeos::ibus::IBusText& text,
+void InputMethodIBus::UpdatePreeditText(const chromeos::IBusText& text,
                                         uint32 cursor_pos,
                                         bool visible) {
   if (suppress_next_result_ || IsTextInputTypeNone())
     return;
 
   // Preedit update means there is a working IME, discard our composer's state.
   character_composer_.Reset();
 
   // |visible| argument is very confusing. For example, what's the correct
   // behavior when:
@@ skipping 115 matching lines @@
 
   DestroyContext();
   CreateContext();
 }
 
 void InputMethodIBus::OnDisconnected() {
   DestroyContext();
 }
 
 void InputMethodIBus::ExtractCompositionText(
-    const chromeos::ibus::IBusText& text,
+    const chromeos::IBusText& text,
     uint32 cursor_position,
     CompositionText* out_composition) const {
   out_composition->Clear();
   out_composition->text = UTF8ToUTF16(text.text());
 
   if (out_composition->text.empty())
     return;
 
   // ibus uses character index for cursor position and attribute range, but we
   // use char16 offset for them. So we need to do conversion here.
   std::vector<size_t> char16_offsets;
   size_t length = out_composition->text.length();
   base::i18n::UTF16CharIterator char_iterator(&out_composition->text);
   do {
     char16_offsets.push_back(char_iterator.array_pos());
   } while (char_iterator.Advance());
 
   // The text length in Unicode characters.
   uint32 char_length = static_cast<uint32>(char16_offsets.size());
   // Make sure we can convert the value of |char_length| as well.
   char16_offsets.push_back(length);
 
   size_t cursor_offset =
       char16_offsets[std::min(char_length, cursor_position)];
 
   out_composition->selection = Range(cursor_offset);
 
-  const std::vector<chromeos::ibus::IBusText::UnderlineAttribute>&
+  const std::vector<chromeos::IBusText::UnderlineAttribute>&
       underline_attributes = text.underline_attributes();
-  const std::vector<chromeos::ibus::IBusText::SelectionAttribute>&
+  const std::vector<chromeos::IBusText::SelectionAttribute>&
       selection_attributes = text.selection_attributes();
 
   if (!underline_attributes.empty()) {
     for (size_t i = 0; i < underline_attributes.size(); ++i) {
       const uint32 start = underline_attributes[i].start_index;
       const uint32 end = underline_attributes[i].end_index;
       if (start >= end)
         continue;
       CompositionUnderline underline(
           char16_offsets[start], char16_offsets[end],
           SK_ColorBLACK, false /* thick */);
       if (underline_attributes[i].type ==
-          chromeos::ibus::IBusText::IBUS_TEXT_UNDERLINE_DOUBLE)
+          chromeos::IBusText::IBUS_TEXT_UNDERLINE_DOUBLE)
         underline.thick = true;
       else if (underline_attributes[i].type ==
-               chromeos::ibus::IBusText::IBUS_TEXT_UNDERLINE_ERROR)
+               chromeos::IBusText::IBUS_TEXT_UNDERLINE_ERROR)
         underline.color = SK_ColorRED;
       out_composition->underlines.push_back(underline);
     }
   }
 
   if (!selection_attributes.empty()) {
     LOG_IF(ERROR, selection_attributes.size() != 1)
         << "Chrome does not support multiple selection";
     for (uint32 i = 0; i < selection_attributes.size(); ++i) {
       const uint32 start = selection_attributes[i].start_index;
@@ skipping 18 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