Remove mozc from whitelist.

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 "base/basictypes.h"
 #include "base/compiler_specific.h"
@@ skipping 13 matching lines @@
 #include "testing/gtest/include/gtest/gtest.h"
 #include "ui/base/accelerators/accelerator.h"
 #include "ui/base/ime/text_input_test_support.h"
 #include "ui/base/keycodes/keyboard_codes.h"
 
 namespace chromeos {
 
 namespace input_method {
 namespace {
 
+const char nacl_mozc_us_id[] =
+    "_comp_ime_fpfbhcjppmaeaijcidgiibchfbnhbeljnacl_mozc_us";
+const char nacl_mozc_jp_id[] =
+    "_comp_ime_fpfbhcjppmaeaijcidgiibchfbnhbeljnacl_mozc_jp";
+
 // Returns true if |descriptors| contain |target|.
 bool Contain(const InputMethodDescriptors& descriptors,
              const InputMethodDescriptor& target) {
   for (size_t i = 0; i < descriptors.size(); ++i) {
     if (descriptors[i].id() == target.id())
       return true;
   }
   return false;
 }
 
@@ skipping 25 matching lines @@
     manager_->SetIBusControllerForTesting(controller_);
     candidate_window_controller_ = new MockCandidateWindowController;
     manager_->SetCandidateWindowControllerForTesting(
         candidate_window_controller_);
     xkeyboard_ = new MockXKeyboard;
     manager_->SetXKeyboardForTesting(xkeyboard_);
 
     ime_list_.clear();
 
     ComponentExtensionIME ext1;
-    ext1.id = "ext1_id";
+    ext1.id = "fpfbhcjppmaeaijcidgiibchfbnhbelj";
     ext1.description = "ext1_description";
     ext1.path = base::FilePath("ext1_file_path");
 
     ComponentExtensionEngine ext1_engine1;
-    ext1_engine1.engine_id = "ext1_engine1_engine_id";
+    ext1_engine1.engine_id = "nacl_mozc_us";
     ext1_engine1.display_name = "ext1_engine_1_display_name";
-    ext1_engine1.language_code = "en";
+    ext1_engine1.language_code = "ja";
     ext1_engine1.layouts.push_back("us");
     ext1.engines.push_back(ext1_engine1);
 
+    ComponentExtensionEngine ext1_engine2;
+    ext1_engine2.engine_id = "nacl_mozc_jp";
+    ext1_engine2.display_name = "ext1_engine_1_display_name";
+    ext1_engine2.language_code = "ja";
+    ext1_engine2.layouts.push_back("jp");
+    ext1.engines.push_back(ext1_engine2);
+
     ime_list_.push_back(ext1);
 
     ComponentExtensionIME ext2;
     ext2.id = "ext2_id";
     ext2.description = "ext2_description";
     ext2.path = base::FilePath("ext2_file_path");
 
     ComponentExtensionEngine ext2_engine1;
     ext2_engine1.engine_id = "ext2_engine1_engine_id";
     ext2_engine1.display_name = "ext2_engine_1_display_name";
@@ skipping 146 matching lines @@
   manager_->RemoveObserver(&observer);
 }
 
 TEST_F(InputMethodManagerImplTest, TestGetSupportedInputMethods) {
   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 =
-      manager_->GetInputMethodUtil()->GetInputMethodDescriptorFromId("mozc");
+      manager_->GetInputMethodUtil()->GetInputMethodDescriptorFromId(
+          nacl_mozc_us_id);
   id_to_find = manager_->GetInputMethodUtil()->GetInputMethodDescriptorFromId(
       "mozc-chewing");
   EXPECT_TRUE(Contain(*methods.get(), *id_to_find));
   id_to_find = manager_->GetInputMethodUtil()->GetInputMethodDescriptorFromId(
       "xkb:us::eng");
   EXPECT_TRUE(Contain(*methods.get(), *id_to_find));
   id_to_find = manager_->GetInputMethodUtil()->GetInputMethodDescriptorFromId(
       "xkb:us:dvorak:eng");
   EXPECT_TRUE(Contain(*methods.get(), *id_to_find));
   id_to_find = manager_->GetInputMethodUtil()->GetInputMethodDescriptorFromId(
@@ skipping 136 matching lines @@
 }
 
 TEST_F(InputMethodManagerImplTest, TestEnableLayoutAndIme) {
   // For http://crbug.com/19655#c11 - (10).
   TestObserver observer;
   manager_->AddObserver(&observer);
   ComponentExtensionInitialize();
   manager_->SetState(InputMethodManager::STATE_BROWSER_SCREEN);
   std::vector<std::string> ids;
   ids.push_back("xkb:us:dvorak:eng");
-  ids.push_back("mozc");
+  ids.push_back(nacl_mozc_us_id);
   EXPECT_TRUE(manager_->EnableInputMethods(ids));
   EXPECT_EQ(1, mock_ibus_daemon_controller_->start_count());
   EXPECT_EQ(1, observer.input_method_changed_count_);
   EXPECT_EQ(ids[0], manager_->GetCurrentInputMethod().id());
   EXPECT_EQ("us(dvorak)", xkeyboard_->last_layout_);
   // Switch to Mozc
   manager_->SwitchToNextInputMethod();
   EXPECT_EQ(2, observer.input_method_changed_count_);
   EXPECT_EQ(ids[1], manager_->GetCurrentInputMethod().id());
   EXPECT_EQ("us", xkeyboard_->last_layout_);
@@ skipping 14 matching lines @@
 }
 
 TEST_F(InputMethodManagerImplTest, TestEnableLayoutAndIme2) {
   // For http://crbug.com/19655#c11 - (11).
   TestObserver observer;
   manager_->AddObserver(&observer);
   ComponentExtensionInitialize();
   manager_->SetState(InputMethodManager::STATE_BROWSER_SCREEN);
   std::vector<std::string> ids;
   ids.push_back("xkb:us:dvorak:eng");
-  ids.push_back("mozc");
+  ids.push_back(nacl_mozc_us_id);
   EXPECT_TRUE(manager_->EnableInputMethods(ids));
   EXPECT_EQ(1, mock_ibus_daemon_controller_->start_count());
   EXPECT_EQ(1, observer.input_method_changed_count_);
   EXPECT_EQ(ids[0], manager_->GetCurrentInputMethod().id());
   EXPECT_EQ("us(dvorak)", xkeyboard_->last_layout_);
 
   // Disable Dvorak.
   ids.erase(ids.begin());
   EXPECT_TRUE(manager_->EnableInputMethods(ids));
   EXPECT_EQ(1U, manager_->GetNumActiveInputMethods());
@@ skipping 77 matching lines @@
 }
 
 TEST_F(InputMethodManagerImplTest, TestEnableLayoutAndImeThenLock) {
   // For http://crbug.com/19655#c11 - (15).
   TestObserver observer;
   manager_->AddObserver(&observer);
   ComponentExtensionInitialize();
   manager_->SetState(InputMethodManager::STATE_BROWSER_SCREEN);
   std::vector<std::string> ids;
   ids.push_back("xkb:us:dvorak:eng");
-  ids.push_back("mozc-dv");
+  ids.push_back("pinyin-dv");
   ids.push_back("mozc-chewing");
   EXPECT_TRUE(manager_->EnableInputMethods(ids));
   EXPECT_EQ(3U, manager_->GetNumActiveInputMethods());
   EXPECT_EQ(1, observer.input_method_changed_count_);
   EXPECT_EQ(ids[0], manager_->GetCurrentInputMethod().id());
   EXPECT_EQ("us(dvorak)", xkeyboard_->last_layout_);
 
   // Switch to Mozc.
   manager_->SwitchToNextInputMethod();
   EXPECT_EQ(2, observer.input_method_changed_count_);
   EXPECT_EQ(ids[1], manager_->GetCurrentInputMethod().id());
   EXPECT_EQ("us(dvorak)", xkeyboard_->last_layout_);
 
   // Lock screen
   manager_->SetState(InputMethodManager::STATE_LOCK_SCREEN);
   EXPECT_EQ(2U, manager_->GetNumActiveInputMethods());  // Qwerty+Dvorak.
   EXPECT_EQ("xkb:us:dvorak:eng",
             manager_->GetCurrentInputMethod().id());
   EXPECT_EQ("us(dvorak)", xkeyboard_->last_layout_);
   // controller_->Stop() should never be called when the screen is locked even
   // after crosbug.com/27051 is fixed.
   EXPECT_EQ(0, mock_ibus_daemon_controller_->stop_count());
   manager_->SwitchToNextInputMethod();
   EXPECT_EQ("xkb:us::eng",  // The hardware keyboard layout.
             manager_->GetCurrentInputMethod().id());
   EXPECT_EQ("us", xkeyboard_->last_layout_);
 
-  // Unlock screen. The original state, mozc-dv, is restored.
+  // Unlock screen. The original state, pinyin-dv, is restored.
   manager_->SetState(InputMethodManager::STATE_BROWSER_SCREEN);
   EXPECT_EQ(3U, manager_->GetNumActiveInputMethods());  // Dvorak and 2 IMEs.
   EXPECT_EQ(ids[1], manager_->GetCurrentInputMethod().id());
   EXPECT_EQ("us(dvorak)", xkeyboard_->last_layout_);
 
   manager_->RemoveObserver(&observer);
 }
 
 TEST_F(InputMethodManagerImplTest, TestXkbSetting) {
   // For http://crbug.com/19655#c11 - (8), step 7-11.
   ComponentExtensionInitialize();
   manager_->SetState(InputMethodManager::STATE_BROWSER_SCREEN);
   std::vector<std::string> ids;
   ids.push_back("xkb:us:dvorak:eng");
   ids.push_back("xkb:us:colemak:eng");
-  ids.push_back("mozc-jp");
-  ids.push_back("mozc");
+  ids.push_back(nacl_mozc_jp_id);
+  ids.push_back(nacl_mozc_us_id);
   EXPECT_TRUE(manager_->EnableInputMethods(ids));
   EXPECT_EQ(4U, manager_->GetNumActiveInputMethods());
   EXPECT_EQ(1, xkeyboard_->set_current_keyboard_layout_by_name_count_);
   // See input_methods.txt for an expected XKB layout name.
   EXPECT_EQ("us(dvorak)", xkeyboard_->last_layout_);
   manager_->SwitchToNextInputMethod();
   EXPECT_EQ(2, xkeyboard_->set_current_keyboard_layout_by_name_count_);
   EXPECT_EQ("us(colemak)", xkeyboard_->last_layout_);
   manager_->SwitchToNextInputMethod();
   EXPECT_EQ(3, xkeyboard_->set_current_keyboard_layout_by_name_count_);
@@ skipping 21 matching lines @@
   EXPECT_EQ("key2", controller_->activate_input_method_property_key_);
 }
 
 TEST_F(InputMethodManagerImplTest, TestGetCurrentInputMethodProperties) {
   ComponentExtensionInitialize();
   EXPECT_TRUE(manager_->GetCurrentInputMethodProperties().empty());
 
   manager_->SetState(InputMethodManager::STATE_BROWSER_SCREEN);
   std::vector<std::string> ids;
   ids.push_back("xkb:us::eng");
-  ids.push_back("mozc");
+  ids.push_back(nacl_mozc_us_id);
   EXPECT_TRUE(manager_->EnableInputMethods(ids));
   EXPECT_EQ(2U, manager_->GetNumActiveInputMethods());
   EXPECT_TRUE(manager_->GetCurrentInputMethodProperties().empty());
-  manager_->ChangeInputMethod("mozc");
+  manager_->ChangeInputMethod(nacl_mozc_us_id);
 
   InputMethodPropertyList current_property_list;
   current_property_list.push_back(InputMethodProperty("key",
                                                       "label",
                                                       false,
                                                       false));
   controller_->SetCurrentPropertiesForTesting(current_property_list);
   controller_->NotifyPropertyChangedForTesting();
 
   ASSERT_EQ(1U, manager_->GetCurrentInputMethodProperties().size());
   EXPECT_EQ("key", manager_->GetCurrentInputMethodProperties().at(0).key);
 
   manager_->ChangeInputMethod("xkb:us::eng");
   EXPECT_TRUE(manager_->GetCurrentInputMethodProperties().empty());
 
   // Delayed asynchronous property update signal from the Mozc IME.
   controller_->NotifyPropertyChangedForTesting();
   // When XKB layout is in use, GetCurrentInputMethodProperties() should always
   // return an empty list.
   EXPECT_TRUE(manager_->GetCurrentInputMethodProperties().empty());
 }
 
 TEST_F(InputMethodManagerImplTest, TestGetCurrentInputMethodPropertiesTwoImes) {
   ComponentExtensionInitialize();
   EXPECT_TRUE(manager_->GetCurrentInputMethodProperties().empty());
 
   manager_->SetState(InputMethodManager::STATE_BROWSER_SCREEN);
   std::vector<std::string> ids;
-  ids.push_back("mozc");  // Japanese
+  ids.push_back(nacl_mozc_us_id);  // Japanese
   ids.push_back("mozc-chewing");  // T-Chinese
   EXPECT_TRUE(manager_->EnableInputMethods(ids));
   EXPECT_EQ(2U, manager_->GetNumActiveInputMethods());
   EXPECT_TRUE(manager_->GetCurrentInputMethodProperties().empty());
 
   InputMethodPropertyList current_property_list;
   current_property_list.push_back(InputMethodProperty("key-mozc",
                                                       "label",
                                                       false,
                                                       false));
@@ skipping 180 matching lines @@
       ui::Accelerator(ui::VKEY_HANGUL, ui::EF_NONE)));
   EXPECT_EQ("xkb:kr:kr104:kor", manager_->GetCurrentInputMethod().id());
   EXPECT_EQ("kr(kr104)", xkeyboard_->last_layout_);
 }
 
 TEST_F(InputMethodManagerImplTest, TestSwitchInputMethodWithJpIme) {
   ComponentExtensionInitialize();
   manager_->SetState(InputMethodManager::STATE_BROWSER_SCREEN);
   std::vector<std::string> ids;
   ids.push_back("xkb:jp::jpn");
-  ids.push_back("mozc-jp");
+  ids.push_back(nacl_mozc_jp_id);
   EXPECT_TRUE(manager_->EnableInputMethods(ids));
   EXPECT_EQ("xkb:jp::jpn", manager_->GetCurrentInputMethod().id());
   EXPECT_EQ("jp", xkeyboard_->last_layout_);
   EXPECT_TRUE(manager_->SwitchInputMethod(
       ui::Accelerator(ui::VKEY_DBE_DBCSCHAR, ui::EF_NONE)));
-  EXPECT_EQ("mozc-jp", manager_->GetCurrentInputMethod().id());
+  EXPECT_EQ(nacl_mozc_jp_id, manager_->GetCurrentInputMethod().id());
   EXPECT_EQ("jp", xkeyboard_->last_layout_);
   EXPECT_TRUE(manager_->SwitchInputMethod(
       ui::Accelerator(ui::VKEY_DBE_DBCSCHAR, ui::EF_NONE)));
   EXPECT_EQ("xkb:jp::jpn", manager_->GetCurrentInputMethod().id());
   EXPECT_EQ("jp", xkeyboard_->last_layout_);
   EXPECT_TRUE(manager_->SwitchInputMethod(
       ui::Accelerator(ui::VKEY_CONVERT, ui::EF_NONE)));
-  EXPECT_EQ("mozc-jp", manager_->GetCurrentInputMethod().id());
+  EXPECT_EQ(nacl_mozc_jp_id, manager_->GetCurrentInputMethod().id());
   EXPECT_EQ("jp", xkeyboard_->last_layout_);
   EXPECT_TRUE(manager_->SwitchInputMethod(
       ui::Accelerator(ui::VKEY_CONVERT, ui::EF_NONE)));
-  EXPECT_EQ("mozc-jp", manager_->GetCurrentInputMethod().id());
+  EXPECT_EQ(nacl_mozc_jp_id, manager_->GetCurrentInputMethod().id());
   EXPECT_EQ("jp", xkeyboard_->last_layout_);
   EXPECT_TRUE(manager_->SwitchInputMethod(
       ui::Accelerator(ui::VKEY_NONCONVERT, ui::EF_NONE)));
   EXPECT_EQ("xkb:jp::jpn", manager_->GetCurrentInputMethod().id());
   EXPECT_EQ("jp", xkeyboard_->last_layout_);
   EXPECT_TRUE(manager_->SwitchInputMethod(
       ui::Accelerator(ui::VKEY_NONCONVERT, ui::EF_NONE)));
   EXPECT_EQ("xkb:jp::jpn", manager_->GetCurrentInputMethod().id());
   EXPECT_EQ("jp", xkeyboard_->last_layout_);
 
   // Add Dvorak.
   ids.push_back("xkb:us:dvorak:eng");
   EXPECT_TRUE(manager_->EnableInputMethods(ids));
   EXPECT_EQ("xkb:jp::jpn", manager_->GetCurrentInputMethod().id());
   EXPECT_EQ("jp", xkeyboard_->last_layout_);
   EXPECT_TRUE(manager_->SwitchInputMethod(
       ui::Accelerator(ui::VKEY_DBE_SBCSCHAR, ui::EF_NONE)));
-  EXPECT_EQ("mozc-jp", manager_->GetCurrentInputMethod().id());
+  EXPECT_EQ(nacl_mozc_jp_id, manager_->GetCurrentInputMethod().id());
   EXPECT_EQ("jp", xkeyboard_->last_layout_);
   EXPECT_TRUE(manager_->SwitchInputMethod(
       ui::Accelerator(ui::VKEY_DBE_SBCSCHAR, ui::EF_NONE)));
   EXPECT_EQ("xkb:jp::jpn", manager_->GetCurrentInputMethod().id());
   EXPECT_EQ("jp", xkeyboard_->last_layout_);
 }
 
 TEST_F(InputMethodManagerImplTest, TestSwitchInputMethodWithKoIme) {
   ComponentExtensionInitialize();
   manager_->SetState(InputMethodManager::STATE_BROWSER_SCREEN);
@@ skipping 149 matching lines @@
               methods->at(1).id());
   }
   manager_->RemoveObserver(&observer);
 }
 
 TEST_F(InputMethodManagerImplTest, TestReset) {
   ComponentExtensionInitialize();
   manager_->SetState(InputMethodManager::STATE_BROWSER_SCREEN);
   std::vector<std::string> ids;
   ids.push_back("xkb:us::eng");
-  ids.push_back("mozc");
+  ids.push_back(nacl_mozc_us_id);
   EXPECT_TRUE(manager_->EnableInputMethods(ids));
   EXPECT_EQ(2U, manager_->GetNumActiveInputMethods());
   EXPECT_EQ(1, mock_ibus_input_context_client_->reset_call_count());
-  manager_->ChangeInputMethod("mozc");
+  manager_->ChangeInputMethod(nacl_mozc_us_id);
   EXPECT_EQ(1, controller_->change_input_method_count_);
-  EXPECT_EQ("mozc", controller_->change_input_method_id_);
+  EXPECT_EQ(nacl_mozc_us_id, controller_->change_input_method_id_);
   EXPECT_EQ(1, mock_ibus_input_context_client_->reset_call_count());
   manager_->ChangeInputMethod("xkb:us::eng");
   EXPECT_EQ(2, controller_->change_input_method_count_);
-  EXPECT_EQ("mozc", controller_->change_input_method_id_);
+  EXPECT_EQ(nacl_mozc_us_id, controller_->change_input_method_id_);
   EXPECT_EQ(1, mock_ibus_input_context_client_->reset_call_count());
 }
 
 TEST_F(InputMethodManagerImplTest,
        ChangeInputMethodBeforeComponentExtensionInitialization_OneIME) {
   manager_->SetState(InputMethodManager::STATE_BROWSER_SCREEN);
   std::vector<std::string> ids;
-  ids.push_back("mozc");
+  ids.push_back(nacl_mozc_us_id);
   EXPECT_TRUE(manager_->EnableInputMethods(ids));
   EXPECT_EQ(1U, manager_->GetNumActiveInputMethods());
-  manager_->ChangeInputMethod("mozc");
+  manager_->ChangeInputMethod(nacl_mozc_us_id);
   EXPECT_EQ(0, controller_->change_input_method_count_);
 
   ComponentExtensionInitialize();
   EXPECT_EQ(1, controller_->change_input_method_count_);
-  EXPECT_EQ("mozc", controller_->change_input_method_id_);
+  EXPECT_EQ(nacl_mozc_us_id, controller_->change_input_method_id_);
 }
 
 TEST_F(InputMethodManagerImplTest,
        ChangeInputMethodBeforeComponentExtensionInitialization_TwoIME) {
   manager_->SetState(InputMethodManager::STATE_BROWSER_SCREEN);
   std::vector<std::string> ids;
-  ids.push_back("mozc");
+  ids.push_back(nacl_mozc_us_id);
   ids.push_back("m17n:kn:itrans");
   EXPECT_TRUE(manager_->EnableInputMethods(ids));
   EXPECT_EQ(2U, manager_->GetNumActiveInputMethods());
-  manager_->ChangeInputMethod("mozc");
+  manager_->ChangeInputMethod(nacl_mozc_us_id);
   EXPECT_EQ(0, controller_->change_input_method_count_);
   manager_->ChangeInputMethod("m17n:kn:itrans");
   EXPECT_EQ(0, controller_->change_input_method_count_);
 
   ComponentExtensionInitialize();
   EXPECT_EQ(1, controller_->change_input_method_count_);
   EXPECT_EQ("m17n:kn:itrans", controller_->change_input_method_id_);
 }
 
 TEST_F(InputMethodManagerImplTest,
@@ skipping 76 matching lines @@
   EXPECT_EQ(2U, manager_->GetNumActiveInputMethods());
   EXPECT_EQ(1, controller_->change_input_method_count_);
   EXPECT_EQ(ext_id1, controller_->change_input_method_id_);
   manager_->ChangeInputMethod(ext_id2);
   EXPECT_EQ(2, controller_->change_input_method_count_);
   EXPECT_EQ(ext_id2, controller_->change_input_method_id_);
 }
 
 }  // namespace input_method
 }  // namespace chromeos