Move ash/ime to ui/chromeos/ime

chrome/browser/chromeos/input_method/input_method_manager_impl_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 "chrome/browser/chromeos/input_method/input_method_manager_impl.h"
 
 #include <algorithm>
 
-#include "ash/ime/input_method_menu_item.h"
-#include "ash/ime/input_method_menu_manager.h"
 #include "base/basictypes.h"
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/compiler_specific.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
 #include "chrome/browser/chromeos/input_method/input_method_engine_interface.h"
 #include "chrome/browser/chromeos/input_method/mock_candidate_window_controller.h"
 #include "chrome/browser/chromeos/input_method/mock_input_method_engine.h"
 #include "chrome/test/base/browser_with_test_window_test.h"
 #include "chrome/test/base/testing_browser_process.h"
 #include "chrome/test/base/testing_profile.h"
 #include "chrome/test/base/testing_profile_manager.h"
 #include "chromeos/ime/extension_ime_util.h"
 #include "chromeos/ime/fake_ime_keyboard.h"
 #include "chromeos/ime/fake_input_method_delegate.h"
 #include "chromeos/ime/mock_component_extension_ime_manager_delegate.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "ui/base/accelerators/accelerator.h"
 #include "ui/base/ime/chromeos/mock_ime_engine_handler.h"
 #include "ui/base/ime/input_method_initializer.h"
+#include "ui/chromeos/ime/input_method_menu_item.h"
+#include "ui/chromeos/ime/input_method_menu_manager.h"
 #include "ui/events/keycodes/keyboard_codes.h"
 
 namespace chromeos {
 
 namespace input_method {
 namespace {
 
 const char kNaclMozcUsId[] = "nacl_mozc_us";
 const char kNaclMozcJpId[] = "nacl_mozc_jp";
 const char kExt2Engine1Id[] = "ext2_engine1-t-i0-engine_id";
@@ skipping 10 matching lines @@
       return true;
   }
   return false;
 }
 
 std::string ImeIdFromEngineId(const std::string& id) {
   return extension_ime_util::GetInputMethodIDByEngineID(id);
 }
 
 class TestObserver : public InputMethodManager::Observer,
-                     public ash::ime::InputMethodMenuManager::Observer {
+                     public ui::ime::InputMethodMenuManager::Observer {
  public:
   TestObserver()
       : input_method_changed_count_(0),
         input_method_menu_item_changed_count_(0),
         last_show_message_(false) {
   }
   virtual ~TestObserver() {}
 
   virtual void InputMethodChanged(InputMethodManager* manager,
                                   bool show_message) override {
     ++input_method_changed_count_;
     last_show_message_ = show_message;
   }
   virtual void InputMethodMenuItemChanged(
-      ash::ime::InputMethodMenuManager* manager) override {
+      ui::ime::InputMethodMenuManager* manager) override {
     ++input_method_menu_item_changed_count_;
   }
 
   int input_method_changed_count_;
   int input_method_menu_item_changed_count_;
   bool last_show_message_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(TestObserver);
 };
@@ skipping 44 matching lines @@
     manager_->GetInputMethodUtil()->UpdateHardwareLayoutCache();
     candidate_window_controller_ = new MockCandidateWindowController;
     manager_->SetCandidateWindowControllerForTesting(
         candidate_window_controller_);
     keyboard_ = new FakeImeKeyboard;
     manager_->SetImeKeyboardForTesting(keyboard_);
     mock_engine_handler_.reset(new MockInputMethodEngine());
     IMEBridge::Initialize();
     IMEBridge::Get()->SetCurrentEngineHandler(mock_engine_handler_.get());
 
-    menu_manager_ = ash::ime::InputMethodMenuManager::GetInstance();
+    menu_manager_ = ui::ime::InputMethodMenuManager::GetInstance();
 
     InitImeList();
 
     BrowserWithTestWindowTest::SetUp();
   }
 
   virtual void TearDown() override {
     BrowserWithTestWindowTest::TearDown();
 
     ui::ShutdownInputMethodForTesting();
@@ skipping 163 matching lines @@
   }
 
   scoped_ptr<TestingProfileManager> profile_manager_;
   scoped_ptr<InputMethodManagerImpl> manager_;
   FakeInputMethodDelegate* delegate_;
   MockCandidateWindowController* candidate_window_controller_;
   scoped_ptr<MockInputMethodEngine> mock_engine_handler_;
   FakeImeKeyboard* keyboard_;
   MockComponentExtIMEManagerDelegate* mock_delegate_;
   std::vector<ComponentExtensionIME> ime_list_;
-  ash::ime::InputMethodMenuManager* menu_manager_;
+  ui::ime::InputMethodMenuManager* menu_manager_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(InputMethodManagerImplTest);
 };
 
 TEST_F(InputMethodManagerImplTest, TestGetImeKeyboard) {
   EXPECT_TRUE(manager_->GetImeKeyboard());
   EXPECT_EQ(keyboard_, manager_->GetImeKeyboard());
 }
 
@@ skipping 453 matching lines @@
   // Disable Dvorak.
   ids.erase(ids.begin());
   EXPECT_TRUE(manager_->GetActiveIMEState()->ReplaceEnabledInputMethods(ids));
   EXPECT_EQ(3U, manager_->GetActiveIMEState()->GetNumActiveInputMethods());
   EXPECT_EQ(6, keyboard_->set_current_keyboard_layout_by_name_count_);
   EXPECT_EQ("us(colemak)", keyboard_->last_layout_);
 }
 
 TEST_F(InputMethodManagerImplTest, TestActivateInputMethodMenuItem) {
   const std::string kKey = "key";
-  ash::ime::InputMethodMenuItemList menu_list;
-  menu_list.push_back(ash::ime::InputMethodMenuItem(
+  ui::ime::InputMethodMenuItemList menu_list;
+  menu_list.push_back(ui::ime::InputMethodMenuItem(
       kKey, "label", false, false));
   menu_manager_->SetCurrentInputMethodMenuItemList(menu_list);
 
   manager_->ActivateInputMethodMenuItem(kKey);
   EXPECT_EQ(kKey, mock_engine_handler_->last_activated_property());
 
   // Key2 is not registered, so activated property should not be changed.
   manager_->ActivateInputMethodMenuItem("key2");
   EXPECT_EQ(kKey, mock_engine_handler_->last_activated_property());
 }
 
 TEST_F(InputMethodManagerImplTest, TestGetCurrentInputMethodProperties) {
   InitComponentExtension();
   EXPECT_TRUE(menu_manager_->GetCurrentInputMethodMenuItemList().empty());
 
   manager_->SetUISessionState(InputMethodManager::STATE_BROWSER_SCREEN);
   std::vector<std::string> ids;
   ids.push_back(ImeIdFromEngineId("xkb:us::eng"));
   ids.push_back(ImeIdFromEngineId(kNaclMozcUsId));
   EXPECT_TRUE(manager_->GetActiveIMEState()->ReplaceEnabledInputMethods(ids));
   EXPECT_EQ(2U, manager_->GetActiveIMEState()->GetNumActiveInputMethods());
   EXPECT_TRUE(menu_manager_->GetCurrentInputMethodMenuItemList().empty());
   manager_->GetActiveIMEState()->ChangeInputMethod(
       ImeIdFromEngineId(kNaclMozcUsId), false /* show_message */);
 
-  ash::ime::InputMethodMenuItemList current_property_list;
-  current_property_list.push_back(ash::ime::InputMethodMenuItem(
+  ui::ime::InputMethodMenuItemList current_property_list;
+  current_property_list.push_back(ui::ime::InputMethodMenuItem(
       "key", "label", false, false));
   menu_manager_->SetCurrentInputMethodMenuItemList(current_property_list);
 
   ASSERT_EQ(1U, menu_manager_->GetCurrentInputMethodMenuItemList().size());
   EXPECT_EQ("key",
             menu_manager_->GetCurrentInputMethodMenuItemList().at(0).key);
 
   manager_->GetActiveIMEState()->ChangeInputMethod("xkb:us::eng",
                                                    false /* show_message */);
   EXPECT_TRUE(menu_manager_->GetCurrentInputMethodMenuItemList().empty());
 }
 
 TEST_F(InputMethodManagerImplTest, TestGetCurrentInputMethodPropertiesTwoImes) {
   InitComponentExtension();
   EXPECT_TRUE(menu_manager_->GetCurrentInputMethodMenuItemList().empty());
 
   manager_->SetUISessionState(InputMethodManager::STATE_BROWSER_SCREEN);
   std::vector<std::string> ids;
   ids.push_back(ImeIdFromEngineId(kNaclMozcUsId));   // Japanese
   ids.push_back(ImeIdFromEngineId(kExt2Engine1Id));  // T-Chinese
   EXPECT_TRUE(manager_->GetActiveIMEState()->ReplaceEnabledInputMethods(ids));
   EXPECT_EQ(2U, manager_->GetActiveIMEState()->GetNumActiveInputMethods());
   EXPECT_TRUE(menu_manager_->GetCurrentInputMethodMenuItemList().empty());
 
-  ash::ime::InputMethodMenuItemList current_property_list;
-  current_property_list.push_back(ash::ime::InputMethodMenuItem("key-mozc",
+  ui::ime::InputMethodMenuItemList current_property_list;
+  current_property_list.push_back(ui::ime::InputMethodMenuItem("key-mozc",
                                                                 "label",
                                                                 false,
                                                                 false));
   menu_manager_->SetCurrentInputMethodMenuItemList(current_property_list);
 
   ASSERT_EQ(1U, menu_manager_->GetCurrentInputMethodMenuItemList().size());
   EXPECT_EQ("key-mozc",
             menu_manager_->GetCurrentInputMethodMenuItemList().at(0).key);
 
   manager_->GetActiveIMEState()->ChangeInputMethod(
       ImeIdFromEngineId(kExt2Engine1Id), false /* show_message */);
   // Since the IME is changed, the property for mozc Japanese should be hidden.
   EXPECT_TRUE(menu_manager_->GetCurrentInputMethodMenuItemList().empty());
 
   // Asynchronous property update signal from mozc-chewing.
   current_property_list.clear();
-  current_property_list.push_back(ash::ime::InputMethodMenuItem(
+  current_property_list.push_back(ui::ime::InputMethodMenuItem(
       "key-chewing", "label", false, false));
   menu_manager_->SetCurrentInputMethodMenuItemList(current_property_list);
   ASSERT_EQ(1U, menu_manager_->GetCurrentInputMethodMenuItemList().size());
   EXPECT_EQ("key-chewing",
             menu_manager_->GetCurrentInputMethodMenuItemList().at(0).key);
 }
 
 TEST_F(InputMethodManagerImplTest, TestNextInputMethod) {
   TestObserver observer;
   manager_->AddObserver(&observer);
@@ skipping 507 matching lines @@
   ASSERT_EQ(4U, input_method_ids.size());
 
   EXPECT_EQ(ImeIdFromEngineId("xkb:us::eng"), input_method_ids[0]);
   EXPECT_EQ(ImeIdFromEngineId("xkb:fr::fra"), input_method_ids[1]);
   EXPECT_EQ("_comp_ime_asdf_pinyin", input_method_ids[2]);
   EXPECT_EQ(ImeIdFromEngineId("zh-t-i0-pinyin"), input_method_ids[3]);
 }
 
 }  // namespace input_method
 }  // namespace chromeos