Support comma separated hardware keyboard layout.

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/bind.h"
@@ skipping 215 matching lines @@
   candidate_window_controller_->NotifyCandidateWindowOpened();
   EXPECT_EQ(2, observer.candidate_window_opened_count_);
   candidate_window_controller_->NotifyCandidateWindowClosed();
   EXPECT_EQ(2, observer.candidate_window_closed_count_);
   manager_->RemoveCandidateWindowObserver(&observer);
 }
 
 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);
   EXPECT_EQ(0, observer.input_method_changed_count_);
-  manager_->EnableLoginLayouts("en-US", "xkb:us::eng");
+  manager_->EnableLoginLayouts("en-US", keyboard_layouts);
   EXPECT_EQ(1, observer.input_method_changed_count_);
   EXPECT_EQ(1, observer.input_method_property_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_);
   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
@@ skipping 25 matching lines @@
       "xkb:us:dvorak:eng");
   EXPECT_TRUE(Contain(*methods.get(), *id_to_find));
   id_to_find = manager_->GetInputMethodUtil()->GetInputMethodDescriptorFromId(
       "xkb:fr::fra");
   EXPECT_TRUE(Contain(*methods.get(), *id_to_find));
 }
 
 TEST_F(InputMethodManagerImplTest, TestEnableLayouts) {
   // Currently 5 keyboard layouts are supported for en-US, and 1 for ja. See
   // ibus_input_method.txt.
+  std::vector<std::string> keyboard_layouts;
+
   InitComponentExtension();
-  manager_->EnableLoginLayouts("en-US", "");
+  manager_->EnableLoginLayouts("en-US", keyboard_layouts);
   EXPECT_EQ(5U, manager_->GetNumActiveInputMethods());
   for (size_t i = 0; i < manager_->GetActiveInputMethodIds().size(); ++i)
     LOG(ERROR) << manager_->GetActiveInputMethodIds().at(i);
 
   // For http://crbug.com/19655#c11 - (5)
   // The hardware keyboard layout "xkb:us::eng" is always active, hence 2U.
-  manager_->EnableLoginLayouts("ja", "");  // Japanese
+  manager_->EnableLoginLayouts("ja", keyboard_layouts);  // Japanese
   EXPECT_EQ(2U, manager_->GetNumActiveInputMethods());
 }
 
 TEST_F(InputMethodManagerImplTest, TestEnableLayoutsAndCurrentInputMethod) {
   // For http://crbug.com/329061
-  manager_->EnableLoginLayouts("en-US", "xkb:se::swe");
+  std::vector<std::string> keyboard_layouts;
+  keyboard_layouts.push_back("xkb:se::swe");
+
+  manager_->EnableLoginLayouts("en-US", keyboard_layouts);
   const std::string im_id = manager_->GetCurrentInputMethod().id();
   EXPECT_EQ("xkb:se::swe", im_id);
 }
 
 TEST_F(InputMethodManagerImplTest, TestEnableLayoutsNonUsHardwareKeyboard) {
+  std::vector<std::string> keyboard_layouts;
+
   // The physical layout is French.
-  delegate_->set_hardware_keyboard_layout("xkb:fr::fra");
-  manager_->EnableLoginLayouts("en-US", "");
+  keyboard_layouts.push_back("xkb:fr::fra");
+  delegate_->set_hardware_keyboard_layout(keyboard_layouts);
+  keyboard_layouts.clear();
+  manager_->EnableLoginLayouts("en-US", keyboard_layouts);
   EXPECT_EQ(6U, manager_->GetNumActiveInputMethods());  // 5 + French
   // The physical layout is Japanese.
-  delegate_->set_hardware_keyboard_layout("xkb:jp::jpn");
-  manager_->EnableLoginLayouts("ja", "");
+  manager_->GetInputMethodUtil()->InvalidateHardwareInputMethodIdsCache();
+  keyboard_layouts.push_back("xkb:jp::jpn");
+  delegate_->set_hardware_keyboard_layout(keyboard_layouts);

[Alexander Alekseev, 2014/02/12 14:45:35]

Why set_hardware_keyboard_layout() doesn't invalidate cache itself?

Let's create InputMethodUtil::SetHardwareKeyboardLayoutForTesting(const
std::string&), which would update cache.

[Seigo Nonaka, 2014/02/12 16:49:51]

To invalidate internal cache, need to include
chrome/browser/chromeos/input_method/input_method_util.h but it is not allowed
in fake_input_method_delegate due to DEPS rule.

On 2014/02/12 14:45:35, alemate wrote:

[Alexander Alekseev, 2014/02/12 17:55:52]

I mean you can replace two calls:
  GetInputMethodUtil()->InvalidateHardwareInputMethodIdsCache();
  delegate_->set_hardware_keyboard_layout(keyboard_layouts);

by
  GetInputMethodUtil()->SetHardwareKeyboardLayoutForTesting(keyboard_layouts);


I'm afraid that if cache synchronization relies upon external (against
InputMethodUtil class) actions, it would break once someone would modify this
code.

[Seigo Nonaka, 2014/02/13 04:36:05]

Done.

+  keyboard_layouts.clear();
+  manager_->EnableLoginLayouts("ja", keyboard_layouts);
   // "xkb:us::eng" is not needed, hence 1.
   EXPECT_EQ(1U, manager_->GetNumActiveInputMethods());
 
   // The physical layout is Russian.
-  delegate_->set_hardware_keyboard_layout("xkb:ru::rus");
-  manager_->EnableLoginLayouts("ru", "");
+  manager_->GetInputMethodUtil()->InvalidateHardwareInputMethodIdsCache();
+  keyboard_layouts.push_back("xkb:ru::rus");
+  delegate_->set_hardware_keyboard_layout(keyboard_layouts);
+  keyboard_layouts.clear();
+  manager_->EnableLoginLayouts("ru", keyboard_layouts);
   // "xkb:us::eng" only.
   EXPECT_EQ(1U, manager_->GetNumActiveInputMethods());
   EXPECT_EQ("xkb:us::eng", manager_->GetActiveInputMethodIds().front());
 }
 
+TEST_F(InputMethodManagerImplTest, TestEnableMultipleHardwareKeyboardLayout) {
+  std::vector<std::string> keyboard_layouts;
+
+  // The physical layouts are French and Hungarian.
+  keyboard_layouts.push_back("xkb:fr::fra");
+  keyboard_layouts.push_back("xkb:hu::hun");
+  delegate_->set_hardware_keyboard_layout(keyboard_layouts);
+  keyboard_layouts.clear();
+  manager_->EnableLoginLayouts("en-US", keyboard_layouts);
+  // 5 + French + Hungarian
+  EXPECT_EQ(7U, manager_->GetNumActiveInputMethods());
+}
+
+TEST_F(InputMethodManagerImplTest,
+       TestEnableMultipleHardwareKeyboardLayout_NoLoginKeyboard) {
+  std::vector<std::string> keyboard_layouts;
+
+  // The physical layouts are French and Hungarian.

[Alexander Alekseev, 2014/02/12 14:45:35]

English (US) and Russian.

[Seigo Nonaka, 2014/02/12 16:49:51]

Done.

+  keyboard_layouts.push_back("xkb:us::eng");
+  keyboard_layouts.push_back("xkb:ru::rus");
+  delegate_->set_hardware_keyboard_layout(keyboard_layouts);
+  keyboard_layouts.clear();
+  manager_->EnableLoginLayouts("ru", keyboard_layouts);
+  // xkb:us:eng
+  EXPECT_EQ(1U, manager_->GetNumActiveInputMethods());
+}
+
 TEST_F(InputMethodManagerImplTest, TestActiveInputMethods) {
-  manager_->EnableLoginLayouts("ja", "");  // Japanese
+  std::vector<std::string> keyboard_layouts;
+  manager_->EnableLoginLayouts("ja", keyboard_layouts);  // Japanese
   EXPECT_EQ(2U, manager_->GetNumActiveInputMethods());
   scoped_ptr<InputMethodDescriptors> methods(
       manager_->GetActiveInputMethods());
   ASSERT_TRUE(methods.get());
   EXPECT_EQ(2U, methods->size());
   const InputMethodDescriptor* id_to_find =
       manager_->GetInputMethodUtil()->GetInputMethodDescriptorFromId(
           "xkb:us::eng");
   EXPECT_TRUE(Contain(*methods.get(), *id_to_find));
   id_to_find = manager_->GetInputMethodUtil()->GetInputMethodDescriptorFromId(
@@ skipping 333 matching lines @@
   manager_->SetCurrentInputMethodProperties(current_property_list);
   ASSERT_EQ(1U, manager_->GetCurrentInputMethodProperties().size());
   EXPECT_EQ("key-chewing",
             manager_->GetCurrentInputMethodProperties().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", "xkb:us::eng");
+  manager_->EnableLoginLayouts("en-US", keyboard_layouts);
   EXPECT_EQ(5U, manager_->GetNumActiveInputMethods());
   EXPECT_EQ("xkb:us::eng", manager_->GetCurrentInputMethod().id());
   EXPECT_EQ("us", xkeyboard_->last_layout_);
   manager_->SwitchToNextInputMethod();
   EXPECT_TRUE(observer.last_show_message_);
   EXPECT_EQ("xkb:us:intl:eng", manager_->GetCurrentInputMethod().id());
   EXPECT_EQ("us(intl)", xkeyboard_->last_layout_);
   manager_->SwitchToNextInputMethod();
   EXPECT_TRUE(observer.last_show_message_);
   EXPECT_EQ("xkb:us:altgr-intl:eng", manager_->GetCurrentInputMethod().id());
@@ skipping 17 matching lines @@
 TEST_F(InputMethodManagerImplTest, TestPreviousInputMethod) {
   TestObserver observer;
   manager_->AddObserver(&observer);
   InitComponentExtension();
 
   ui::Accelerator keydown_accelerator(ui::VKEY_SPACE, ui::EF_CONTROL_DOWN);
   keydown_accelerator.set_type(ui::ET_KEY_PRESSED);
   ui::Accelerator keyup_accelerator(ui::VKEY_SPACE, ui::EF_CONTROL_DOWN);
   keyup_accelerator.set_type(ui::ET_KEY_RELEASED);
 
-  manager_->EnableLoginLayouts("en-US", "xkb:us::eng");
+  std::vector<std::string> keyboard_layouts;
+  keyboard_layouts.push_back("xkb:us::eng");
+  manager_->EnableLoginLayouts("en-US", keyboard_layouts);
   EXPECT_EQ(5U, manager_->GetNumActiveInputMethods());
   EXPECT_EQ("xkb:us::eng", manager_->GetCurrentInputMethod().id());
   EXPECT_EQ("us", xkeyboard_->last_layout_);
   EXPECT_TRUE(manager_->SwitchToNextInputMethod());
   EXPECT_TRUE(observer.last_show_message_);
   EXPECT_EQ("xkb:us:intl:eng", manager_->GetCurrentInputMethod().id());
   EXPECT_EQ("us(intl)", xkeyboard_->last_layout_);
   EXPECT_TRUE(manager_->SwitchToPreviousInputMethod(keydown_accelerator));
   EXPECT_TRUE(manager_->SwitchToPreviousInputMethod(keyup_accelerator));
   EXPECT_TRUE(observer.last_show_message_);
@@ skipping 52 matching lines @@
   EXPECT_FALSE(manager_->SwitchToPreviousInputMethod(keydown_accelerator));
   EXPECT_FALSE(manager_->SwitchToPreviousInputMethod(keyup_accelerator));
 
   manager_->RemoveObserver(&observer);
 }
 
 TEST_F(InputMethodManagerImplTest, TestSwitchInputMethodWithUsLayouts) {
   TestObserver observer;
   manager_->AddObserver(&observer);
   InitComponentExtension();
-  manager_->EnableLoginLayouts("en-US", "xkb:us::eng");
+  std::vector<std::string> keyboard_layouts;
+  keyboard_layouts.push_back("xkb:us::eng");
+  manager_->EnableLoginLayouts("en-US", keyboard_layouts);
   EXPECT_EQ(5U, manager_->GetNumActiveInputMethods());
   EXPECT_EQ("xkb:us::eng", manager_->GetCurrentInputMethod().id());
   EXPECT_EQ("us", xkeyboard_->last_layout_);
 
   // Henkan, Muhenkan, ZenkakuHankaku should be ignored when no Japanese IMEs
   // and keyboards are enabled.
   EXPECT_FALSE(manager_->SwitchInputMethod(
       ui::Accelerator(ui::VKEY_CONVERT, ui::EF_NONE)));
   EXPECT_FALSE(observer.last_show_message_);
   EXPECT_EQ("xkb:us::eng", manager_->GetCurrentInputMethod().id());
@@ skipping 16 matching lines @@
 
 TEST_F(InputMethodManagerImplTest, TestSwitchInputMethodWithJpLayout) {
   // Enable "xkb:jp::jpn" and press Muhenkan/ZenkakuHankaku.
   InitComponentExtension();
 
   ui::Accelerator keydown_accelerator(ui::VKEY_SPACE, ui::EF_CONTROL_DOWN);
   keydown_accelerator.set_type(ui::ET_KEY_PRESSED);
   ui::Accelerator keyup_accelerator(ui::VKEY_SPACE, ui::EF_CONTROL_DOWN);
   keyup_accelerator.set_type(ui::ET_KEY_RELEASED);
 
-  manager_->EnableLoginLayouts("ja", "xkb:us::eng");
+  std::vector<std::string> keyboard_layouts;
+  keyboard_layouts.push_back("xkb:us::eng");
+  manager_->EnableLoginLayouts("ja", keyboard_layouts);
   EXPECT_EQ(2U, manager_->GetNumActiveInputMethods());
   EXPECT_EQ("xkb:us::eng", manager_->GetCurrentInputMethod().id());
   EXPECT_EQ("us", 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_->SwitchToPreviousInputMethod(keydown_accelerator));
   EXPECT_TRUE(manager_->SwitchToPreviousInputMethod(keyup_accelerator));
   EXPECT_EQ("xkb:us::eng", manager_->GetCurrentInputMethod().id());
@@ skipping 304 matching lines @@
   ids.push_back(ext_id2);
   EXPECT_TRUE(manager_->EnableInputMethods(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