Clean Up: Remove ibus namespace.

chromeos/dbus/ibus/ibus_engine_service_unittest.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 "chromeos/dbus/ibus/ibus_engine_service.h"
 
 #include <map>
 #include "base/bind.h"
 #include "base/message_loop.h"
 #include "base/values.h"
@@ skipping 18 matching lines @@
 namespace {
 const std::string kObjectPath = "/org/freedesktop/IBus/Engine/1";
 
 class MockIBusEngineHandler : public IBusEngineHandlerInterface {
  public:
   MOCK_METHOD0(FocusIn, void());
   MOCK_METHOD0(FocusOut, void());
   MOCK_METHOD0(Enable, void());
   MOCK_METHOD0(Disable, void());
   MOCK_METHOD2(PropertyActivate, void(const std::string& property_name,
-                                      IBusPropertyState property_state));
+                                      ibus::IBusPropertyState property_state));
   MOCK_METHOD1(PropertyShow, void(const std::string& property_name));
   MOCK_METHOD1(PropertyHide, void(const std::string& property_name));
   MOCK_METHOD1(SetCapability, void(IBusCapability capability));
   MOCK_METHOD0(Reset, void());
   MOCK_METHOD4(ProcessKeyEvent, void(
       uint32 keysym,
       uint32 keycode,
       uint32 state,
       const KeyEventDoneCallback& callback));
   MOCK_METHOD3(CandidateClicked, void(uint32 index,
@@ skipping 52 matching lines @@
   uint32 serial_no_;
   bool result_;
 
   DISALLOW_COPY_AND_ASSIGN(BoolResponseExpectation);
 };
 
 // Used for RegisterProperties signal message evaluation.
 class RegisterPropertiesExpectation {
  public:
   explicit RegisterPropertiesExpectation(
-      const ibus::IBusPropertyList& property_list)
+      const IBusPropertyList& property_list)
       : property_list_(property_list) {}
 
   // Evaluates the given |signal| is a valid message.
   void Evaluate(dbus::Signal* signal) {
-    ibus::IBusPropertyList property_list;
+    IBusPropertyList property_list;
 
     // Read a signal argument.
     dbus::MessageReader reader(signal);
-    EXPECT_TRUE(ibus::PopIBusPropertyList(&reader, &property_list));
+    EXPECT_TRUE(PopIBusPropertyList(&reader, &property_list));
     EXPECT_FALSE(reader.HasMoreData());
 
     // Check an argument.
     EXPECT_EQ(property_list_.size(), property_list.size());
     for (size_t i = 0; i < property_list_.size(); ++i) {
       EXPECT_EQ(property_list_[i]->key(), property_list[i]->key());
       EXPECT_EQ(property_list_[i]->type(), property_list[i]->type());
       EXPECT_EQ(property_list_[i]->label(), property_list[i]->label());
       EXPECT_EQ(property_list_[i]->tooltip(), property_list[i]->tooltip());
       EXPECT_EQ(property_list_[i]->visible(), property_list[i]->visible());
       EXPECT_EQ(property_list_[i]->checked(), property_list[i]->checked());
     }
   }
 
  private:
-  const ibus::IBusPropertyList& property_list_;
+  const IBusPropertyList& property_list_;
 
   DISALLOW_COPY_AND_ASSIGN(RegisterPropertiesExpectation);
 };
 
 // Used for mocking ProcessKeyEventHandler.
 class ProcessKeyEventHandler {
  public:
   explicit ProcessKeyEventHandler(bool expected_value)
       : expected_value_(expected_value) {
   }
@@ skipping 33 matching lines @@
   bool expected_value_;
   MessageLoop* message_loop_;
 
   DISALLOW_COPY_AND_ASSIGN(DelayProcessKeyEventHandler);
 };
 
 // Used for UpdatePreedit signal message evaluation.
 class UpdatePreeditExpectation {
  public:
   UpdatePreeditExpectation(
-      const ibus::IBusText& ibus_text,
+      const IBusText& ibus_text,
       uint32 cursor_pos,
       bool is_visible,
       IBusEngineService::IBusEnginePreeditFocusOutMode mode)
       : ibus_text_(ibus_text),
         cursor_pos_(cursor_pos),
         is_visible_(is_visible),
         mode_(mode) {}
 
   // Evaluates the given |signal| is a valid message.
   void Evaluate(dbus::Signal* signal) {
-    ibus::IBusText ibus_text;
+    IBusText ibus_text;
     uint32 cursor_pos = 0;
     bool is_visible = false;
     uint32 preedit_mode = 0;
 
     // Read signal arguments.
     dbus::MessageReader reader(signal);
-    EXPECT_TRUE(ibus::PopIBusText(&reader, &ibus_text));
+    EXPECT_TRUE(PopIBusText(&reader, &ibus_text));
     EXPECT_TRUE(reader.PopUint32(&cursor_pos));
     EXPECT_TRUE(reader.PopBool(&is_visible));
     EXPECT_TRUE(reader.PopUint32(&preedit_mode));
     EXPECT_FALSE(reader.HasMoreData());
 
     // Check arguments.
     EXPECT_EQ(ibus_text_.text(), ibus_text.text());
     EXPECT_EQ(cursor_pos_, cursor_pos);
     EXPECT_EQ(is_visible_, is_visible);
     EXPECT_EQ(mode_,
               static_cast<IBusEngineService::IBusEnginePreeditFocusOutMode>(
                   preedit_mode));
   }
 
  private:
-  const ibus::IBusText& ibus_text_;
+  const IBusText& ibus_text_;
   uint32 cursor_pos_;
   bool is_visible_;
   IBusEngineService::IBusEnginePreeditFocusOutMode mode_;
 
   DISALLOW_COPY_AND_ASSIGN(UpdatePreeditExpectation);
 };
 
 // Used for UpdateAuxiliaryText signal message evaluation.
 class UpdateAuxiliaryTextExpectation {
  public:
-  UpdateAuxiliaryTextExpectation(const ibus::IBusText& ibus_text,
+  UpdateAuxiliaryTextExpectation(const IBusText& ibus_text,
                                  bool is_visible)
       : ibus_text_(ibus_text), is_visible_(is_visible) {}
 
   // Evaluates the given |signal| is a valid message.
   void Evaluate(dbus::Signal* signal) {
-    ibus::IBusText ibus_text;
+    IBusText ibus_text;
     bool is_visible = false;
 
     // Read signal arguments.
     dbus::MessageReader reader(signal);
-    EXPECT_TRUE(ibus::PopIBusText(&reader, &ibus_text));
+    EXPECT_TRUE(PopIBusText(&reader, &ibus_text));
     EXPECT_TRUE(reader.PopBool(&is_visible));
     EXPECT_FALSE(reader.HasMoreData());
 
     // Check arguments.
     EXPECT_EQ(ibus_text_.text(), ibus_text.text());
     EXPECT_EQ(is_visible_, is_visible);
   }
 
  private:
-  const ibus::IBusText& ibus_text_;
+  const IBusText& ibus_text_;
   bool is_visible_;
 
   DISALLOW_COPY_AND_ASSIGN(UpdateAuxiliaryTextExpectation);
 };
 
 // Used for UpdateLookupTable signal message evaluation.
 class UpdateLookupTableExpectation {
  public:
-  UpdateLookupTableExpectation(const ibus::IBusLookupTable& lookup_table,
+  UpdateLookupTableExpectation(const IBusLookupTable& lookup_table,
                                bool is_visible)
       : lookup_table_(lookup_table), is_visible_(is_visible) {}
 
   // Evaluates the given |signal| is a valid message.
   void Evaluate(dbus::Signal* signal) {
-    ibus::IBusLookupTable lookup_table;
+    IBusLookupTable lookup_table;
     bool is_visible = false;
 
     // Read signal arguments.
     dbus::MessageReader reader(signal);
     EXPECT_TRUE(PopIBusLookupTable(&reader, &lookup_table));
     EXPECT_TRUE(reader.PopBool(&is_visible));
     EXPECT_FALSE(reader.HasMoreData());
 
     // Check arguments.
     EXPECT_EQ(lookup_table_.page_size(), lookup_table.page_size());
     EXPECT_EQ(lookup_table_.cursor_position(), lookup_table.cursor_position());
     EXPECT_EQ(lookup_table_.is_cursor_visible(),
               lookup_table.is_cursor_visible());
     EXPECT_EQ(is_visible_, is_visible);
   }
 
  private:
-  const ibus::IBusLookupTable& lookup_table_;
+  const IBusLookupTable& lookup_table_;
   bool is_visible_;
 
   DISALLOW_COPY_AND_ASSIGN(UpdateLookupTableExpectation);
 };
 
 // Used for UpdateProperty signal message evaluation.
 class UpdatePropertyExpectation {
  public:
-  explicit UpdatePropertyExpectation(const ibus::IBusProperty& property)
+  explicit UpdatePropertyExpectation(const IBusProperty& property)
       : property_(property) {}
 
   // Evaluates the given |signal| is a valid message.
   void Evaluate(dbus::Signal* signal) {
-    ibus::IBusProperty property;
+    IBusProperty property;
 
     // Read a signal argument.
     dbus::MessageReader reader(signal);
     EXPECT_TRUE(PopIBusProperty(&reader, &property));
     EXPECT_FALSE(reader.HasMoreData());
 
     // Check the argument.
     EXPECT_EQ(property_.key(), property.key());
     EXPECT_EQ(property_.type(), property.type());
     EXPECT_EQ(property_.label(), property.label());
     EXPECT_EQ(property_.tooltip(), property.tooltip());
     EXPECT_EQ(property_.visible(), property.visible());
     EXPECT_EQ(property_.checked(), property.checked());
   }
 
  private:
-  const ibus::IBusProperty& property_;
+  const IBusProperty& property_;
 
   DISALLOW_COPY_AND_ASSIGN(UpdatePropertyExpectation);
 };
 
 // Used for ForwardKeyEvent signal message evaluation.
 class ForwardKeyEventExpectation {
  public:
   ForwardKeyEventExpectation(uint32 keyval, uint32 keycode, uint32 state)
       : keyval_(keyval),
         keycode_(keycode),
@@ skipping 310 matching lines @@
   method_callback_map_[ibus::engine::kDisableMethod].Run(
       &method_call,
       base::Bind(&MockResponseSender::Run,
                  base::Unretained(&response_sender)));
 }
 
 TEST_F(IBusEngineServiceTest, PropertyActivateTest) {
   // Set expectations.
   const uint32 kSerialNo = 1;
   const std::string kPropertyName = "Property Name";
-  const IBusEngineHandlerInterface::IBusPropertyState kIBusPropertyState =
-      IBusEngineHandlerInterface::IBUS_PROPERTY_STATE_UNCHECKED;
+  const ibus::IBusPropertyState kIBusPropertyState =
+      ibus::IBUS_PROPERTY_STATE_UNCHECKED;
   EXPECT_CALL(*engine_handler_, PropertyActivate(kPropertyName,
                                                  kIBusPropertyState));
   MockResponseSender response_sender;
   EmptyResponseExpectation response_expectation(kSerialNo);
   EXPECT_CALL(response_sender, Run(_))
       .WillOnce(Invoke(&response_expectation,
                        &EmptyResponseExpectation::Evaluate));
 
   // Create method call;
   dbus::MethodCall method_call(ibus::engine::kServiceInterface,
@@ skipping 338 matching lines @@
                                                    kAnchorPos)).Times(0);
   EXPECT_CALL(response_sender, Run(_)).Times(0);
   method_callback_map_[ibus::engine::kSetSurroundingTextMethod].Run(
       &method_call,
       base::Bind(&MockResponseSender::Run,
                  base::Unretained(&response_sender)));
 }
 
 TEST_F(IBusEngineServiceTest, RegisterProperties) {
   // Set expectations.
-  ibus::IBusPropertyList property_list;
-  property_list.push_back(new ibus::IBusProperty());
+  IBusPropertyList property_list;
+  property_list.push_back(new IBusProperty());
   property_list[0]->set_key("Sample Key");
-  property_list[0]->set_type(ibus::IBusProperty::IBUS_PROPERTY_TYPE_MENU);
+  property_list[0]->set_type(IBusProperty::IBUS_PROPERTY_TYPE_MENU);
   property_list[0]->set_label("Sample Label");
   property_list[0]->set_tooltip("Sample Tooltip");
   property_list[0]->set_visible(true);
   property_list[0]->set_checked(true);
 
   RegisterPropertiesExpectation expectation(property_list);
   EXPECT_CALL(*mock_exported_object_, SendSignal(_))
       .WillOnce(Invoke(&expectation,
                        &RegisterPropertiesExpectation::Evaluate));
   // Emit signal.
   service_->RegisterProperties(property_list);
 }
 
 TEST_F(IBusEngineServiceTest, UpdatePreeditTest) {
   // Set expectations.
-  ibus::IBusText ibus_text;
+  IBusText ibus_text;
   ibus_text.set_text("Sample Text");
   const uint32 kCursorPos = 9;
   const bool kIsVisible = false;
   const IBusEngineService::IBusEnginePreeditFocusOutMode kPreeditMode =
       IBusEngineService::IBUS_ENGINE_PREEEDIT_FOCUS_OUT_MODE_CLEAR;
   UpdatePreeditExpectation expectation(ibus_text, kCursorPos, kIsVisible,
                                        kPreeditMode);
   EXPECT_CALL(*mock_exported_object_, SendSignal(_))
       .WillOnce(Invoke(&expectation, &UpdatePreeditExpectation::Evaluate));
 
   // Emit signal.
   service_->UpdatePreedit(ibus_text, kCursorPos, kIsVisible, kPreeditMode);
 }
 
 TEST_F(IBusEngineServiceTest, UpdateAuxiliaryText) {
-  ibus::IBusText ibus_text;
+  IBusText ibus_text;
   ibus_text.set_text("Sample Text");
   const bool kIsVisible = false;
   UpdateAuxiliaryTextExpectation expectation(ibus_text, kIsVisible);
 
   EXPECT_CALL(*mock_exported_object_, SendSignal(_))
       .WillOnce(Invoke(&expectation,
                        &UpdateAuxiliaryTextExpectation::Evaluate));
 
   // Emit signal.
   service_->UpdateAuxiliaryText(ibus_text, kIsVisible);
 }
 
 TEST_F(IBusEngineServiceTest, UpdateLookupTableTest) {
-  ibus::IBusLookupTable lookup_table;
+  IBusLookupTable lookup_table;
   lookup_table.set_page_size(10);
   lookup_table.set_cursor_position(2);
   lookup_table.set_is_cursor_visible(false);
   const bool kIsVisible = true;
 
   UpdateLookupTableExpectation expectation(lookup_table, kIsVisible);
   EXPECT_CALL(*mock_exported_object_, SendSignal(_))
       .WillOnce(Invoke(&expectation,
                        &UpdateLookupTableExpectation::Evaluate));
 
   // Emit signal.
   service_->UpdateLookupTable(lookup_table, kIsVisible);
 }
 
 TEST_F(IBusEngineServiceTest, UpdatePropertyTest) {
-  ibus::IBusProperty property;
+  IBusProperty property;
   property.set_key("Sample Key");
-  property.set_type(ibus::IBusProperty::IBUS_PROPERTY_TYPE_MENU);
+  property.set_type(IBusProperty::IBUS_PROPERTY_TYPE_MENU);
   property.set_label("Sample Label");
   property.set_tooltip("Sample Tooltip");
   property.set_visible(true);
   property.set_checked(true);
 
   UpdatePropertyExpectation expectation(property);
   EXPECT_CALL(*mock_exported_object_, SendSignal(_))
       .WillOnce(Invoke(&expectation,
                        &UpdatePropertyExpectation::Evaluate));
 
@@ skipping 20 matching lines @@
   RequireSurroundingTextExpectation expectation;
   EXPECT_CALL(*mock_exported_object_, SendSignal(_))
       .WillOnce(Invoke(&expectation,
                        &RequireSurroundingTextExpectation::Evaluate));
 
   // Emit signal.
   service_->RequireSurroundingText();
 }
 
 }  // namespace chromeos