Clean Up: Remove ibus namespace.

chromeos/dbus/ibus/ibus_panel_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_panel_service.h"
 
 #include <map>
 #include "base/bind.h"
 #include "base/message_loop.h"
 #include "base/values.h"
 #include "chromeos/dbus/ibus/ibus_constants.h"
 #include "chromeos/dbus/ibus/ibus_input_context_client.h"
 #include "chromeos/dbus/ibus/ibus_lookup_table.h"
 #include "chromeos/dbus/ibus/ibus_property.h"
 #include "chromeos/dbus/ibus/ibus_text.h"
 #include "dbus/message.h"
 #include "dbus/mock_bus.h"
 #include "dbus/mock_exported_object.h"
 #include "dbus/object_path.h"
 #include "dbus/values_util.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using testing::Invoke;
 using testing::Return;
 using testing::_;
 
 namespace chromeos {
-// TODO(nona): Remove ibus namespace after complete libibus removal.
-namespace ibus {
 
 namespace {
 
 class MockIBusPanelCandidateWindowHandler
     : public IBusPanelCandidateWindowHandlerInterface {
  public:
   MockIBusPanelCandidateWindowHandler() {}
-  MOCK_METHOD2(UpdateLookupTable, void(const ibus::IBusLookupTable& table,
+  MOCK_METHOD2(UpdateLookupTable, void(const IBusLookupTable& table,
                                        bool visible));
   MOCK_METHOD0(HideLookupTable, void());
   MOCK_METHOD2(UpdateAuxiliaryText, void(const std::string& text,
                                          bool visible));
   MOCK_METHOD0(HideAuxiliaryText, void());
   MOCK_METHOD3(UpdatePreeditText, void(const std::string& text,
                                        uint32 cursor_pos,
                                        bool visible) );
   MOCK_METHOD0(HidePreeditText, void());
   MOCK_METHOD2(SetCursorLocation, void(const ibus::Rect& cursor_location,
                                        const ibus::Rect& composition_head));
 
  private:
   DISALLOW_COPY_AND_ASSIGN(MockIBusPanelCandidateWindowHandler);
 };
 
 class MockIBusPanelPropertyHandler : public IBusPanelPropertyHandlerInterface {
  public:
   MockIBusPanelPropertyHandler() {}
   MOCK_METHOD1(RegisterProperties,
-               void(const ibus::IBusPropertyList& properties));
-  MOCK_METHOD1(UpdateProperty, void(const ibus::IBusProperty& property));
+               void(const IBusPropertyList& properties));
+  MOCK_METHOD1(UpdateProperty, void(const IBusProperty& property));
 
  private:
   DISALLOW_COPY_AND_ASSIGN(MockIBusPanelPropertyHandler);
 };
 
 class MockResponseSender {
  public:
   MOCK_METHOD1(Run, void(dbus::Response* reponse));
 };
 
@@ skipping 69 matching lines @@
     EXPECT_FALSE(reader.HasMoreData());
   }
 
  private:
   std::string expected_signal_name_;
   DISALLOW_COPY_AND_ASSIGN(NullArgumentVerifier);
 };
 
 class UpdateLookupTableVerifier {
  public:
-  UpdateLookupTableVerifier(const ibus::IBusLookupTable& table, bool visible)
+  UpdateLookupTableVerifier(const IBusLookupTable& table, bool visible)
       : table_(table),
         visible_(visible) {}
 
-  void Verify(const ibus::IBusLookupTable& table, bool visible) {
+  void Verify(const IBusLookupTable& table, bool visible) {
     EXPECT_EQ(table_.page_size(), table.page_size());
     EXPECT_EQ(table_.cursor_position(), table.cursor_position());
     EXPECT_EQ(visible_, visible);
   }
 
  private:
-  const ibus::IBusLookupTable& table_;
+  const IBusLookupTable& table_;
   const bool visible_;
 
   DISALLOW_COPY_AND_ASSIGN(UpdateLookupTableVerifier);
 };
 
 // This class is used to verify that a method call which has a PropertyList
 // object. This class verifies a method call has correct arguments based on
 // checking given |keys|.
 class PropertyListVerifier {
  public:
   explicit PropertyListVerifier(const std::vector<std::string>& expected_keys)
       : expected_keys_(expected_keys) {
   }
 
   // Verifies the given |resposne| has IBusPropertyList.
-  void Verify(const ibus::IBusPropertyList& properties) {
+  void Verify(const IBusPropertyList& properties) {
     ASSERT_EQ(expected_keys_.size(), properties.size());
     for (size_t i = 0; i < properties.size(); ++i) {
       EXPECT_EQ(expected_keys_[i], properties[i]->key());
     }
   }
 
  private:
   const std::vector<std::string> expected_keys_;
 };
 
 // This class is used to verify that a method call which has a Property object.
 // This class verifies a method call has correct argument based on |key|.
 class PropertyVerifier {
  public:
   explicit PropertyVerifier(const std::string& key) : key_(key) {}
 
   // Verifies the given |resposne| has IBusPropertyList.
-  void Verify(const ibus::IBusProperty& property) {
+  void Verify(const IBusProperty& property) {
     EXPECT_EQ(key_, property.key());
   }
 
  private:
   const std::string key_;
 };
 
 }  // namespace
 
 class IBusPanelServiceTest : public testing::Test {
@@ skipping 207 matching lines @@
             method_callback_map_.end());
   method_callback_map_[ibus::panel::kHidePreeditTextMethod].Run(
       &method_call,
       base::Bind(&MockResponseSender::Run,
                  base::Unretained(&response_sender)));
 }
 
 TEST_F(IBusPanelServiceTest, UpdateLookupTableTest) {
   // Set expectations.
   const uint32 kSerialNo = 1;
-  ibus::IBusLookupTable table;
+  IBusLookupTable table;
   table.set_page_size(3);
   table.set_cursor_position(4);
   const bool kVisible = false;
 
 
   UpdateLookupTableVerifier evaluator(table, kVisible);
   EXPECT_CALL(*candidate_window_handler_, UpdateLookupTable(_, _))
       .WillOnce(Invoke(&evaluator,
                        &UpdateLookupTableVerifier::Verify));
   MockResponseSender response_sender;
@@ skipping 30 matching lines @@
   EmptyResponseVerifier response_expectation(kSerialNo);
   EXPECT_CALL(response_sender, Run(_))
       .WillOnce(Invoke(&response_expectation,
                        &EmptyResponseVerifier::Verify));
 
   // Create method call;
   dbus::MethodCall method_call(ibus::panel::kServiceInterface,
                                ibus::panel::kUpdateAuxiliaryTextMethod);
   method_call.SetSerial(kSerialNo);
   dbus::MessageWriter writer(&method_call);
-  ibus::AppendStringAsIBusText(text, &writer);
+  AppendStringAsIBusText(text, &writer);
   writer.AppendBool(kVisible);
 
   // Call exported function.
   EXPECT_NE(method_callback_map_.find(ibus::panel::kUpdateAuxiliaryTextMethod),
             method_callback_map_.end());
   method_callback_map_[ibus::panel::kUpdateAuxiliaryTextMethod].Run(
       &method_call,
       base::Bind(&MockResponseSender::Run,
                  base::Unretained(&response_sender)));
 }
@@ skipping 11 matching lines @@
   EmptyResponseVerifier response_expectation(kSerialNo);
   EXPECT_CALL(response_sender, Run(_))
       .WillOnce(Invoke(&response_expectation,
                        &EmptyResponseVerifier::Verify));
 
   // Create method call;
   dbus::MethodCall method_call(ibus::panel::kServiceInterface,
                                ibus::panel::kUpdatePreeditTextMethod);
   method_call.SetSerial(kSerialNo);
   dbus::MessageWriter writer(&method_call);
-  ibus::AppendStringAsIBusText(text, &writer);
+  AppendStringAsIBusText(text, &writer);
   writer.AppendUint32(kCursorPos);
   writer.AppendBool(kVisible);
 
   // Call exported function.
   EXPECT_NE(method_callback_map_.find(ibus::panel::kUpdatePreeditTextMethod),
             method_callback_map_.end());
   method_callback_map_[ibus::panel::kUpdatePreeditTextMethod].Run(
       &method_call,
       base::Bind(&MockResponseSender::Run,
                  base::Unretained(&response_sender)));
@@ skipping 38 matching lines @@
   // Emit signal.
   service_->PageDown();
 }
 
 TEST_F(IBusPanelServiceTest, RegisterPropertiesTest) {
   // Set expectations.
   std::vector<std::string> keys;
   keys.push_back("key1");
   keys.push_back("key2");
   keys.push_back("key3");
-  ibus::IBusPropertyList properties;
+  IBusPropertyList properties;
   for (size_t i = 0; i < keys.size(); ++i) {
-    ibus::IBusProperty* property = new ibus::IBusProperty;
+    IBusProperty* property = new IBusProperty;
     property->set_key(keys[i]);
     properties.push_back(property);
   }
 
   PropertyListVerifier response_expectation(keys);
   EXPECT_CALL(*property_handler_, RegisterProperties(_))
       .WillOnce(Invoke(&response_expectation,
                         &PropertyListVerifier::Verify));
 
   MockResponseSender response_sender;
   EXPECT_CALL(response_sender, Run(_));
 
   // Create method call;
   dbus::MethodCall method_call(ibus::panel::kServiceInterface,
                                ibus::panel::kRegisterPropertiesMethod);
   method_call.SetSerial(1UL);
   dbus::MessageWriter writer(&method_call);
-  ibus::AppendIBusPropertyList(properties, &writer);
+  AppendIBusPropertyList(properties, &writer);
 
   // Call exported function.
   EXPECT_NE(method_callback_map_.find(ibus::panel::kRegisterPropertiesMethod),
             method_callback_map_.end());
   method_callback_map_[ibus::panel::kRegisterPropertiesMethod].Run(
       &method_call,
       base::Bind(&MockResponseSender::Run, base::Unretained(&response_sender)));
 }
 
 TEST_F(IBusPanelServiceTest, UpdatePropertyTest) {
   // Set expectations.
   const char kKey[] = "key";
-  ibus::IBusProperty property;
+  IBusProperty property;
   property.set_key(kKey);
 
   PropertyVerifier response_expectation(kKey);
   EXPECT_CALL(*property_handler_, UpdateProperty(_))
       .WillOnce(Invoke(&response_expectation, &PropertyVerifier::Verify));
 
   MockResponseSender response_sender;
   EXPECT_CALL(response_sender, Run(_));
 
   // Create method call;
   dbus::MethodCall method_call(ibus::panel::kServiceInterface,
                                ibus::panel::kUpdatePropertyMethod);
   method_call.SetSerial(1UL);
   dbus::MessageWriter writer(&method_call);
-  ibus::AppendIBusProperty(property, &writer);
+  AppendIBusProperty(property, &writer);
 
   // Call exported function.
   EXPECT_NE(method_callback_map_.find(ibus::panel::kUpdatePropertyMethod),
             method_callback_map_.end());
   method_callback_map_[ibus::panel::kUpdatePropertyMethod].Run(
       &method_call,
       base::Bind(&MockResponseSender::Run,
                  base::Unretained(&response_sender)));
 }
 
-}  // namespace ibus
 }  // namespace chromeos