try 3 of: Split out InputMethodMenuManager from InputMethodManager.

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 "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"
@@ skipping 46 matching lines @@
     manager_->GetInputMethodUtil()->UpdateHardwareLayoutCache();
     candidate_window_controller_ = new MockCandidateWindowController;
     manager_->SetCandidateWindowControllerForTesting(
         candidate_window_controller_);
     xkeyboard_ = new FakeXKeyboard;
     manager_->SetXKeyboardForTesting(xkeyboard_);
     mock_engine_handler_.reset(new MockIMEEngineHandler());
     IMEBridge::Initialize();
     IMEBridge::Get()->SetCurrentEngineHandler(mock_engine_handler_.get());
 
+    menu_manager_ = ash::ime::InputMethodMenuManager::GetInstance();
+
     ime_list_.clear();
 
     ComponentExtensionIME ext1;
     ext1.id = "fpfbhcjppmaeaijcidgiibchfbnhbelj";
     ext1.description = "ext1_description";
     ext1.path = base::FilePath("ext1_file_path");
 
     ComponentExtensionEngine ext1_engine1;
     ext1_engine1.engine_id = "nacl_mozc_us";
     ext1_engine1.display_name = "ext1_engine_1_display_name";
@@ skipping 30 matching lines @@
     ext2.engines.push_back(ext2_engine2);
 
     ime_list_.push_back(ext2);
   }
 
   virtual void TearDown() OVERRIDE {
     delegate_ = NULL;
     candidate_window_controller_ = NULL;
     xkeyboard_ = NULL;
     manager_.reset();
+
     IMEBridge::Get()->SetCurrentEngineHandler(NULL);
     IMEBridge::Shutdown();
   }
 
  protected:
   // Helper function to initialize component extension stuff for testing.
   void InitComponentExtension() {
     mock_delegate_ = new MockComponentExtIMEManagerDelegate();
     mock_delegate_->set_ime_list(ime_list_);
     scoped_ptr<ComponentExtensionIMEManagerDelegate> delegate(mock_delegate_);
@@ skipping 12 matching lines @@
   }
 
   scoped_ptr<InputMethodManagerImpl> manager_;
   FakeInputMethodDelegate* delegate_;
   MockCandidateWindowController* candidate_window_controller_;
   scoped_ptr<MockIMEEngineHandler> mock_engine_handler_;
   FakeXKeyboard* xkeyboard_;
   base::MessageLoop message_loop_;
   MockComponentExtIMEManagerDelegate* mock_delegate_;
   std::vector<ComponentExtensionIME> ime_list_;
+  ash::ime::InputMethodMenuManager* menu_manager_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(InputMethodManagerImplTest);
 };
 
-class TestObserver : public InputMethodManager::Observer {
+class TestObserver : public InputMethodManager::Observer,
+                     public ash::ime::InputMethodMenuManager::Observer{
  public:
   TestObserver()
       : input_method_changed_count_(0),
-        input_method_property_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 InputMethodPropertyChanged(
-      InputMethodManager* manager) OVERRIDE {
-    ++input_method_property_changed_count_;
+  virtual void InputMethodMenuItemChanged(
+      ash::ime::InputMethodMenuManager* manager) OVERRIDE {
+    ++input_method_menu_item_changed_count_;
   }
 
   int input_method_changed_count_;
-  int input_method_property_changed_count_;
+  int input_method_menu_item_changed_count_;
   bool last_show_message_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(TestObserver);
 };
 
 class TestCandidateWindowObserver
     : public InputMethodManager::CandidateWindowObserver {
  public:
   TestCandidateWindowObserver()
@@ skipping 40 matching lines @@
 
 TEST_F(InputMethodManagerImplTest, TestObserver) {
   // For http://crbug.com/19655#c11 - (3). browser_state_monitor_unittest.cc is
   // also for the scenario.
   std::vector<std::string> keyboard_layouts;
   keyboard_layouts.push_back("xkb:us::eng");
 
   TestObserver observer;
   InitComponentExtension();
   manager_->AddObserver(&observer);
+  menu_manager_->AddObserver(&observer);
   EXPECT_EQ(0, observer.input_method_changed_count_);
   manager_->EnableLoginLayouts("en-US", keyboard_layouts);
   EXPECT_EQ(1, observer.input_method_changed_count_);
-  EXPECT_EQ(1, observer.input_method_property_changed_count_);
+  EXPECT_EQ(1, observer.input_method_menu_item_changed_count_);
   manager_->ChangeInputMethod("xkb:us:dvorak:eng");
   EXPECT_FALSE(observer.last_show_message_);
   EXPECT_EQ(2, observer.input_method_changed_count_);
-  EXPECT_EQ(2, observer.input_method_property_changed_count_);
+  EXPECT_EQ(2, observer.input_method_menu_item_changed_count_);
   manager_->ChangeInputMethod("xkb:us:dvorak:eng");
   EXPECT_FALSE(observer.last_show_message_);
 
   // The observer is always notified even when the same input method ID is
   // passed to ChangeInputMethod() more than twice.
   // TODO(komatsu): Revisit if this is neccessary.
   EXPECT_EQ(3, observer.input_method_changed_count_);
 
   // If the same input method ID is passed, PropertyChanged() is not
   // notified.
-  EXPECT_EQ(2, observer.input_method_property_changed_count_);
+  EXPECT_EQ(2, observer.input_method_menu_item_changed_count_);
 
   manager_->RemoveObserver(&observer);
+  menu_manager_->RemoveObserver(&observer);
 }
 
 TEST_F(InputMethodManagerImplTest, TestGetSupportedInputMethods) {
   InitComponentExtension();
   scoped_ptr<InputMethodDescriptors> methods(
       manager_->GetSupportedInputMethods());
   ASSERT_TRUE(methods.get());
   // Try to find random 4-5 layuts and IMEs to make sure the returned list is
   // correct.
   const InputMethodDescriptor* id_to_find =
@@ skipping 354 matching lines @@
   EXPECT_EQ(5, xkeyboard_->set_current_keyboard_layout_by_name_count_);
   EXPECT_EQ("us(dvorak)", xkeyboard_->last_layout_);
   // Disable Dvorak.
   ids.erase(ids.begin());
   EXPECT_TRUE(manager_->ReplaceEnabledInputMethods(ids));
   EXPECT_EQ(3U, manager_->GetNumActiveInputMethods());
   EXPECT_EQ(6, xkeyboard_->set_current_keyboard_layout_by_name_count_);
   EXPECT_EQ("us(colemak)", xkeyboard_->last_layout_);
 }
 
-TEST_F(InputMethodManagerImplTest, TestActivateInputMethodProperty) {
+TEST_F(InputMethodManagerImplTest, TestActivateInputMethodMenuItem) {
   const std::string kKey = "key";
-  InputMethodPropertyList property_list;
-  property_list.push_back(InputMethodProperty(kKey, "label", false, false));
-  manager_->SetCurrentInputMethodProperties(property_list);
+  ash::ime::InputMethodMenuItemList menu_list;
+  menu_list.push_back(ash::ime::InputMethodMenuItem(
+      kKey, "label", false, false));
+  menu_manager_->SetCurrentInputMethodMenuItemList(menu_list);
 
-  manager_->ActivateInputMethodProperty(kKey);
+  manager_->ActivateInputMethodMenuItem(kKey);
   EXPECT_EQ(kKey, mock_engine_handler_->last_activated_property());
 
   // Key2 is not registered, so activated property should not be changed.
-  manager_->ActivateInputMethodProperty("key2");
+  manager_->ActivateInputMethodMenuItem("key2");
   EXPECT_EQ(kKey, mock_engine_handler_->last_activated_property());
 }
 
 TEST_F(InputMethodManagerImplTest, TestGetCurrentInputMethodProperties) {
   InitComponentExtension();
-  EXPECT_TRUE(manager_->GetCurrentInputMethodProperties().empty());
+  EXPECT_TRUE(menu_manager_->GetCurrentInputMethodMenuItemList().empty());
 
   manager_->SetState(InputMethodManager::STATE_BROWSER_SCREEN);
   std::vector<std::string> ids;
   ids.push_back("xkb:us::eng");
   ids.push_back(kNaclMozcUsId);
   EXPECT_TRUE(manager_->ReplaceEnabledInputMethods(ids));
   EXPECT_EQ(2U, manager_->GetNumActiveInputMethods());
-  EXPECT_TRUE(manager_->GetCurrentInputMethodProperties().empty());
+  EXPECT_TRUE(menu_manager_->GetCurrentInputMethodMenuItemList().empty());
   manager_->ChangeInputMethod(kNaclMozcUsId);
 
-  InputMethodPropertyList current_property_list;
-  current_property_list.push_back(InputMethodProperty("key",
-                                                      "label",
-                                                      false,
-                                                      false));
-  manager_->SetCurrentInputMethodProperties(current_property_list);
+  ash::ime::InputMethodMenuItemList current_property_list;
+  current_property_list.push_back(ash::ime::InputMethodMenuItem(
+      "key", "label", false, false));
+  menu_manager_->SetCurrentInputMethodMenuItemList(current_property_list);
 
-  ASSERT_EQ(1U, manager_->GetCurrentInputMethodProperties().size());
-  EXPECT_EQ("key", manager_->GetCurrentInputMethodProperties().at(0).key);
+  ASSERT_EQ(1U, menu_manager_->GetCurrentInputMethodMenuItemList().size());
+  EXPECT_EQ("key",
+            menu_manager_->GetCurrentInputMethodMenuItemList().at(0).key);
 
   manager_->ChangeInputMethod("xkb:us::eng");
-  EXPECT_TRUE(manager_->GetCurrentInputMethodProperties().empty());
+  EXPECT_TRUE(menu_manager_->GetCurrentInputMethodMenuItemList().empty());
 }
 
 TEST_F(InputMethodManagerImplTest, TestGetCurrentInputMethodPropertiesTwoImes) {
   InitComponentExtension();
-  EXPECT_TRUE(manager_->GetCurrentInputMethodProperties().empty());
+  EXPECT_TRUE(menu_manager_->GetCurrentInputMethodMenuItemList().empty());
 
   manager_->SetState(InputMethodManager::STATE_BROWSER_SCREEN);
   std::vector<std::string> ids;
   ids.push_back(kNaclMozcUsId);  // Japanese
   ids.push_back(kExt2Engine1Id);  // T-Chinese
   EXPECT_TRUE(manager_->ReplaceEnabledInputMethods(ids));
   EXPECT_EQ(2U, manager_->GetNumActiveInputMethods());
-  EXPECT_TRUE(manager_->GetCurrentInputMethodProperties().empty());
+  EXPECT_TRUE(menu_manager_->GetCurrentInputMethodMenuItemList().empty());
 
-  InputMethodPropertyList current_property_list;
-  current_property_list.push_back(InputMethodProperty("key-mozc",
-                                                      "label",
-                                                      false,
-                                                      false));
-  manager_->SetCurrentInputMethodProperties(current_property_list);
+  ash::ime::InputMethodMenuItemList current_property_list;
+  current_property_list.push_back(ash::ime::InputMethodMenuItem("key-mozc",
+                                                                "label",
+                                                                false,
+                                                                false));
+  menu_manager_->SetCurrentInputMethodMenuItemList(current_property_list);
 
-  ASSERT_EQ(1U, manager_->GetCurrentInputMethodProperties().size());
-  EXPECT_EQ("key-mozc", manager_->GetCurrentInputMethodProperties().at(0).key);
+  ASSERT_EQ(1U, menu_manager_->GetCurrentInputMethodMenuItemList().size());
+  EXPECT_EQ("key-mozc",
+            menu_manager_->GetCurrentInputMethodMenuItemList().at(0).key);
 
   manager_->ChangeInputMethod(kExt2Engine1Id);
   // Since the IME is changed, the property for mozc Japanese should be hidden.
-  EXPECT_TRUE(manager_->GetCurrentInputMethodProperties().empty());
+  EXPECT_TRUE(menu_manager_->GetCurrentInputMethodMenuItemList().empty());
 
   // Asynchronous property update signal from mozc-chewing.
   current_property_list.clear();
-  current_property_list.push_back(InputMethodProperty("key-chewing",
-                                                      "label",
-                                                      false,
-                                                      false));
-  manager_->SetCurrentInputMethodProperties(current_property_list);
-  ASSERT_EQ(1U, manager_->GetCurrentInputMethodProperties().size());
+  current_property_list.push_back(ash::ime::InputMethodMenuItem(
+      "key-chewing", "label", false, false));
+  menu_manager_->SetCurrentInputMethodMenuItemList(current_property_list);
+  ASSERT_EQ(1U, menu_manager_->GetCurrentInputMethodMenuItemList().size());
   EXPECT_EQ("key-chewing",
-            manager_->GetCurrentInputMethodProperties().at(0).key);
+            menu_manager_->GetCurrentInputMethodMenuItemList().at(0).key);
 }
 
 TEST_F(InputMethodManagerImplTest, TestNextInputMethod) {
   TestObserver observer;
   manager_->AddObserver(&observer);
   InitComponentExtension();
   std::vector<std::string> keyboard_layouts;
   keyboard_layouts.push_back("xkb:us::eng");
   // For http://crbug.com/19655#c11 - (1)
   manager_->EnableLoginLayouts("en-US", keyboard_layouts);
@@ skipping 471 matching lines @@
   ids.push_back(ext_id2);
   EXPECT_TRUE(manager_->ReplaceEnabledInputMethods(ids));
   EXPECT_EQ(2U, manager_->GetNumActiveInputMethods());
   EXPECT_EQ(ext_id1, manager_->GetCurrentInputMethod().id());
   manager_->ChangeInputMethod(ext_id2);
   EXPECT_EQ(ext_id2, manager_->GetCurrentInputMethod().id());
 }
 
 }  // namespace input_method
 }  // namespace chromeos