Add member variables to VirtualKeyboardSelector

chrome/browser/chromeos/input_method/virtual_keyboard_selector_unittest.cc

Index: chrome/browser/chromeos/input_method/virtual_keyboard_selector_unittest.cc
diff --git a/chrome/browser/chromeos/input_method/virtual_keyboard_selector_unittest.cc b/chrome/browser/chromeos/input_method/virtual_keyboard_selector_unittest.cc
index 3e3b89f394de78318eaa12bced637324308a4136..f2c3fcd7331eaf5e3aef3fc1b4c4104619b4b32b 100644
--- a/chrome/browser/chromeos/input_method/virtual_keyboard_selector_unittest.cc
+++ b/chrome/browser/chromeos/input_method/virtual_keyboard_selector_unittest.cc
@@ -7,14 +7,37 @@
 #include "base/logging.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
+namespace ime = ::chromeos::input_method;
+
 // For EXPECT_TRUE calls below. The operator has to be in the global namespace.
-static bool operator==(const chromeos::input_method::VirtualKeyboard& lhs,
-                       const chromeos::input_method::VirtualKeyboard& rhs) {
+static bool operator==(
+    const ime::VirtualKeyboard& lhs, const ime::VirtualKeyboard& rhs) {
   return lhs.GetURLForLayout("") == rhs.GetURLForLayout("");
 }
 
 namespace {
 
+typedef std::multimap<
+  std::string, const ime::VirtualKeyboard*> LayoutToKeyboard;
+
+// Returns true if [start, end) contains all of the |urls|.

[mazda, 2011/08/09 02:28:24]

The comment sounds differently from the actual behavior.
For example, if [start, end) contains "aaa.com" and "bbb.com" and |urls| equals
to ["aaa.com"], the comment implies this function returns true, but actually
not.

[Yusuke Sato, 2011/08/09 05:25:49]

Done.

+template <size_t L> bool CheckUrls(LayoutToKeyboard::const_iterator start,
+                                   LayoutToKeyboard::const_iterator end,
+                                   const char* (&urls)[L]) {
+  std::set<GURL> url_set;
+  for (size_t i = 0; i < L; ++i) {
+    url_set.insert(GURL(urls[i]));
+  }
+  LayoutToKeyboard::const_iterator iter;
+  for (iter = start; iter != end; ++iter) {
+    if (url_set.erase(iter->second->url()) != 1) {
+      LOG(ERROR) << "Unexpected URL: " << iter->second->url().spec();
+      return false;
+    }
+  }
+  return url_set.empty();
+}
+
 template <size_t L>
 std::set<std::string> CreateLayoutSet(const char* (&layouts)[L]) {
   std::set<std::string> result;
@@ -47,30 +70,34 @@ TEST(VirtualKeyboardSelectorTest, TestAddVirtualKeyboard) {
 
   // The first two keyboards have the same URL.
   VirtualKeyboard virtual_keyboard_1(
-      GURL("http://url1"), CreateLayoutSet(layouts), true /* is_system */);
+      GURL("http://url1"), "", CreateLayoutSet(layouts), true /* is_system */);
   VirtualKeyboard virtual_keyboard_2(
-      GURL("http://url1"), CreateLayoutSet(layouts), false /* is_system */);
+      GURL("http://url1"), "", CreateLayoutSet(layouts), false /* is_system */);
   VirtualKeyboard virtual_keyboard_3(
-      GURL("http://url2"), CreateLayoutSet(layouts), false /* is_system */);
+      GURL("http://url2"), "", CreateLayoutSet(layouts), false /* is_system */);
 
   TestableVirtualKeyboardSelector selector;
   EXPECT_TRUE(selector.AddVirtualKeyboard(
       virtual_keyboard_1.url(),
+      virtual_keyboard_1.name(),
       virtual_keyboard_1.supported_layouts(),
       virtual_keyboard_1.is_system()));
 
   // You can't add the same keyboard twice.
   EXPECT_FALSE(selector.AddVirtualKeyboard(
       virtual_keyboard_1.url(),
+      virtual_keyboard_1.name(),
       virtual_keyboard_1.supported_layouts(),
       virtual_keyboard_1.is_system()));
   EXPECT_FALSE(selector.AddVirtualKeyboard(
       virtual_keyboard_2.url(),
+      virtual_keyboard_2.name(),
       virtual_keyboard_2.supported_layouts(),
       virtual_keyboard_2.is_system()));
 
   EXPECT_TRUE(selector.AddVirtualKeyboard(
       virtual_keyboard_3.url(),
+      virtual_keyboard_3.name(),
       virtual_keyboard_3.supported_layouts(),
       virtual_keyboard_3.is_system()));
 }
@@ -78,11 +105,12 @@ TEST(VirtualKeyboardSelectorTest, TestAddVirtualKeyboard) {
 TEST(VirtualKeyboardSelectorTest, TestSystemKeyboard) {
   static const char* layouts[] = { "a", "b", "c" };
   VirtualKeyboard system_virtual_keyboard(
-      GURL("http://system"), CreateLayoutSet(layouts), true /* is_system */);
+      GURL("http://system"), "", CreateLayoutSet(layouts), true /* is_system */);
 
   TestableVirtualKeyboardSelector selector;
   EXPECT_TRUE(selector.AddVirtualKeyboard(
       system_virtual_keyboard.url(),
+      system_virtual_keyboard.name(),
       system_virtual_keyboard.supported_layouts(),
       system_virtual_keyboard.is_system()));
 
@@ -102,17 +130,21 @@ TEST(VirtualKeyboardSelectorTest, TestTwoSystemKeyboards) {
   static const char* layouts_2[] = { "a", "c", "d" };
 
   VirtualKeyboard system_virtual_keyboard_1(
-      GURL("http://system1"), CreateLayoutSet(layouts_1), true /* is_system */);
+      GURL("http://system1"), "", CreateLayoutSet(layouts_1),
+      true /* is_system */);
   VirtualKeyboard system_virtual_keyboard_2(
-      GURL("http://system2"), CreateLayoutSet(layouts_2), true /* is_system */);
+      GURL("http://system2"), "", CreateLayoutSet(layouts_2),
+      true /* is_system */);
 
   TestableVirtualKeyboardSelector selector;
   EXPECT_TRUE(selector.AddVirtualKeyboard(
       system_virtual_keyboard_1.url(),
+      system_virtual_keyboard_1.name(),
       system_virtual_keyboard_1.supported_layouts(),
       system_virtual_keyboard_1.is_system()));
   EXPECT_TRUE(selector.AddVirtualKeyboard(
       system_virtual_keyboard_2.url(),
+      system_virtual_keyboard_2.name(),
       system_virtual_keyboard_2.supported_layouts(),
       system_virtual_keyboard_2.is_system()));
 
@@ -158,11 +190,12 @@ TEST(VirtualKeyboardSelectorTest, TestTwoSystemKeyboards) {
 TEST(VirtualKeyboardSelectorTest, TestUserKeyboard) {
   static const char* layouts[] = { "a", "b", "c" };
   VirtualKeyboard user_virtual_keyboard(
-      GURL("http://user"), CreateLayoutSet(layouts), false /* is_system */);
+      GURL("http://user"), "", CreateLayoutSet(layouts), false /* is_system */);
 
   TestableVirtualKeyboardSelector selector;
   EXPECT_TRUE(selector.AddVirtualKeyboard(
       user_virtual_keyboard.url(),
+      user_virtual_keyboard.name(),
       user_virtual_keyboard.supported_layouts(),
       user_virtual_keyboard.is_system()));
   ASSERT_TRUE(selector.SelectVirtualKeyboardWithoutPreferences("a"));
@@ -181,17 +214,21 @@ TEST(VirtualKeyboardSelectorTest, TestTwoUserKeyboards) {
   static const char* layouts_2[] = { "a", "c", "d" };
 
   VirtualKeyboard user_virtual_keyboard_1(
-      GURL("http://user1"), CreateLayoutSet(layouts_1), false /* is_system */);
+      GURL("http://user1"), "", CreateLayoutSet(layouts_1),
+      false /* is_system */);
   VirtualKeyboard user_virtual_keyboard_2(
-      GURL("http://user2"), CreateLayoutSet(layouts_2), false /* is_system */);
+      GURL("http://user2"), "", CreateLayoutSet(layouts_2),
+      false /* is_system */);
 
   TestableVirtualKeyboardSelector selector;
   EXPECT_TRUE(selector.AddVirtualKeyboard(
       user_virtual_keyboard_1.url(),
+      user_virtual_keyboard_1.name(),
       user_virtual_keyboard_1.supported_layouts(),
       user_virtual_keyboard_1.is_system()));
   EXPECT_TRUE(selector.AddVirtualKeyboard(
       user_virtual_keyboard_2.url(),
+      user_virtual_keyboard_2.name(),
       user_virtual_keyboard_2.supported_layouts(),
       user_virtual_keyboard_2.is_system()));
 
@@ -241,29 +278,37 @@ TEST(VirtualKeyboardSelectorTest, TestUserSystemMixed) {
   static const char* layouts_2[] = { "a", "y", "z" };
 
   VirtualKeyboard user_virtual_keyboard_1(
-      GURL("http://user1"), CreateLayoutSet(ulayouts_1), false /* is_system */);
+      GURL("http://user1"), "", CreateLayoutSet(ulayouts_1),
+      false /* is_system */);
   VirtualKeyboard user_virtual_keyboard_2(
-      GURL("http://user2"), CreateLayoutSet(ulayouts_2), false /* is_system */);
+      GURL("http://user2"), "", CreateLayoutSet(ulayouts_2),
+      false /* is_system */);
   VirtualKeyboard system_virtual_keyboard_1(
-      GURL("http://system1"), CreateLayoutSet(layouts_1), true /* is_system */);
+      GURL("http://system1"), "", CreateLayoutSet(layouts_1),
+      true /* is_system */);
   VirtualKeyboard system_virtual_keyboard_2(
-      GURL("http://system2"), CreateLayoutSet(layouts_2), true /* is_system */);
+      GURL("http://system2"), "", CreateLayoutSet(layouts_2),
+      true /* is_system */);
 
   TestableVirtualKeyboardSelector selector;
   EXPECT_TRUE(selector.AddVirtualKeyboard(
       user_virtual_keyboard_1.url(),
+      user_virtual_keyboard_1.name(),
       user_virtual_keyboard_1.supported_layouts(),
       user_virtual_keyboard_1.is_system()));
   EXPECT_TRUE(selector.AddVirtualKeyboard(
       user_virtual_keyboard_2.url(),
+      user_virtual_keyboard_2.name(),
       user_virtual_keyboard_2.supported_layouts(),
       user_virtual_keyboard_2.is_system()));
   EXPECT_TRUE(selector.AddVirtualKeyboard(
       system_virtual_keyboard_1.url(),
+      system_virtual_keyboard_1.name(),
       system_virtual_keyboard_1.supported_layouts(),
       system_virtual_keyboard_1.is_system()));
   EXPECT_TRUE(selector.AddVirtualKeyboard(
       system_virtual_keyboard_2.url(),
+      system_virtual_keyboard_2.name(),
       system_virtual_keyboard_2.supported_layouts(),
       system_virtual_keyboard_2.is_system()));
 
@@ -334,7 +379,7 @@ TEST(VirtualKeyboardSelectorTest, TestUserSystemMixed) {
 TEST(VirtualKeyboardTest, TestUrl) {
   static const char* layouts[] = { "a", "b", "c" };
   VirtualKeyboard system_virtual_keyboard(
-      GURL("http://system"), CreateLayoutSet(layouts), true);
+      GURL("http://system"), "", CreateLayoutSet(layouts), true);
 
   EXPECT_EQ("http://system/index.html#a",
             system_virtual_keyboard.GetURLForLayout("a").spec());
@@ -354,11 +399,12 @@ TEST(VirtualKeyboardSelectorTest, TestSetUserPreference1) {
   static const char* layouts[] = { "a", "b", "c" };
 
   VirtualKeyboard user_virtual_keyboard(
-      GURL("http://user"), CreateLayoutSet(layouts), false /* is_system */);
+      GURL("http://user"), "", CreateLayoutSet(layouts), false /* is_system */);
 
   TestableVirtualKeyboardSelector selector;
   EXPECT_TRUE(selector.AddVirtualKeyboard(
       user_virtual_keyboard.url(),
+      user_virtual_keyboard.name(),
       user_virtual_keyboard.supported_layouts(),
       user_virtual_keyboard.is_system()));
 
@@ -379,11 +425,13 @@ TEST(VirtualKeyboardSelectorTest, TestSetUserPreference2) {
   static const char* layouts[] = { "a", "b", "c" };
 
   VirtualKeyboard system_virtual_keyboard(
-      GURL("http://system"), CreateLayoutSet(layouts), true /* is_system */);
+      GURL("http://system"), "", CreateLayoutSet(layouts),
+      true /* is_system */);
 
   TestableVirtualKeyboardSelector selector;
   EXPECT_TRUE(selector.AddVirtualKeyboard(
       system_virtual_keyboard.url(),
+      system_virtual_keyboard.name(),
       system_virtual_keyboard.supported_layouts(),
       system_virtual_keyboard.is_system()));
 
@@ -404,17 +452,21 @@ TEST(VirtualKeyboardSelectorTest, TestRemoveUserPreference) {
   static const char* layouts[] = { "a", "b", "c" };
 
   VirtualKeyboard user_virtual_keyboard_1(
-      GURL("http://user1"), CreateLayoutSet(layouts), false /* is_system */);
+      GURL("http://user1"), "", CreateLayoutSet(layouts),
+      false /* is_system */);
   VirtualKeyboard user_virtual_keyboard_2(
-      GURL("http://user2"), CreateLayoutSet(layouts), false /* is_system */);
+      GURL("http://user2"), "", CreateLayoutSet(layouts),
+      false /* is_system */);
 
   TestableVirtualKeyboardSelector selector;
   EXPECT_TRUE(selector.AddVirtualKeyboard(
       user_virtual_keyboard_1.url(),
+      user_virtual_keyboard_1.name(),
       user_virtual_keyboard_1.supported_layouts(),
       user_virtual_keyboard_1.is_system()));
   EXPECT_TRUE(selector.AddVirtualKeyboard(
       user_virtual_keyboard_2.url(),
+      user_virtual_keyboard_2.name(),
       user_virtual_keyboard_2.supported_layouts(),
       user_virtual_keyboard_2.is_system()));
 
@@ -441,29 +493,37 @@ TEST(VirtualKeyboardSelectorTest, TestSetUserPreferenceUserSystemMixed) {
   static const char* layouts_2[] = { "a", "y", "z" };
 
   VirtualKeyboard user_virtual_keyboard_1(
-      GURL("http://user1"), CreateLayoutSet(ulayouts_1), false /* is_system */);
+      GURL("http://user1"), "", CreateLayoutSet(ulayouts_1),
+      false /* is_system */);
   VirtualKeyboard user_virtual_keyboard_2(
-      GURL("http://user2"), CreateLayoutSet(ulayouts_2), false /* is_system */);
+      GURL("http://user2"), "", CreateLayoutSet(ulayouts_2),
+      false /* is_system */);
   VirtualKeyboard system_virtual_keyboard_1(
-      GURL("http://system1"), CreateLayoutSet(layouts_1), true /* is_system */);
+      GURL("http://system1"), "", CreateLayoutSet(layouts_1),
+      true /* is_system */);
   VirtualKeyboard system_virtual_keyboard_2(
-      GURL("http://system2"), CreateLayoutSet(layouts_2), true /* is_system */);
+      GURL("http://system2"), "", CreateLayoutSet(layouts_2),
+      true /* is_system */);
 
   TestableVirtualKeyboardSelector selector;
   EXPECT_TRUE(selector.AddVirtualKeyboard(
       user_virtual_keyboard_1.url(),
+      user_virtual_keyboard_1.name(),
       user_virtual_keyboard_1.supported_layouts(),
       user_virtual_keyboard_1.is_system()));
   EXPECT_TRUE(selector.AddVirtualKeyboard(
       user_virtual_keyboard_2.url(),
+      user_virtual_keyboard_2.name(),
       user_virtual_keyboard_2.supported_layouts(),
       user_virtual_keyboard_2.is_system()));
   EXPECT_TRUE(selector.AddVirtualKeyboard(
       system_virtual_keyboard_1.url(),
+      system_virtual_keyboard_1.name(),
       system_virtual_keyboard_1.supported_layouts(),
       system_virtual_keyboard_1.is_system()));
   EXPECT_TRUE(selector.AddVirtualKeyboard(
       system_virtual_keyboard_2.url(),
+      system_virtual_keyboard_2.name(),
       system_virtual_keyboard_2.supported_layouts(),
       system_virtual_keyboard_2.is_system()));
 
@@ -542,5 +602,133 @@ TEST(VirtualKeyboardSelectorTest, TestSetUserPreferenceUserSystemMixed) {
               *selector.SelectVirtualKeyboard("c"));
 }
 
+TEST(VirtualKeyboardSelectorTest, TestUrlToExtensionMapping) {
+  static const char* ulayouts_1[] = { "a", "b", "c" };
+  static const char* ulayouts_2[] = { "a", "c", "d" };
+  static const char* slayouts_1[] = { "a", "x", "y" };
+
+  VirtualKeyboard user_virtual_keyboard_1(
+      GURL("http://user1"), "", CreateLayoutSet(ulayouts_1),
+      false /* is_system */);
+  VirtualKeyboard user_virtual_keyboard_2(
+      GURL("http://user2"), "", CreateLayoutSet(ulayouts_2),
+      false /* is_system */);
+  VirtualKeyboard system_virtual_keyboard_1(
+      GURL("http://system1"), "", CreateLayoutSet(slayouts_1),
+      true /* is_system */);
+
+  TestableVirtualKeyboardSelector selector;
+
+  const std::map<GURL, const VirtualKeyboard*>& result1 =
+      selector.url_to_keyboard();
+  EXPECT_TRUE(result1.empty());
+
+  EXPECT_TRUE(selector.AddVirtualKeyboard(
+      user_virtual_keyboard_1.url(),
+      user_virtual_keyboard_1.name(),
+      user_virtual_keyboard_1.supported_layouts(),
+      user_virtual_keyboard_1.is_system()));
+  EXPECT_TRUE(selector.AddVirtualKeyboard(
+      user_virtual_keyboard_2.url(),
+      user_virtual_keyboard_2.name(),
+      user_virtual_keyboard_2.supported_layouts(),
+      user_virtual_keyboard_2.is_system()));
+  EXPECT_TRUE(selector.AddVirtualKeyboard(
+      system_virtual_keyboard_1.url(),
+      system_virtual_keyboard_1.name(),
+      system_virtual_keyboard_1.supported_layouts(),
+      system_virtual_keyboard_1.is_system()));
+
+  const std::map<GURL, const VirtualKeyboard*>& result2 =
+      selector.url_to_keyboard();
+  EXPECT_EQ(3U, result2.size());
+  ASSERT_EQ(1U, result2.count(GURL("http://user1")));
+  EXPECT_TRUE(user_virtual_keyboard_1 ==
+              *result2.find(GURL("http://user1"))->second);
+  ASSERT_EQ(1U, result2.count(GURL("http://user2")));
+  EXPECT_TRUE(user_virtual_keyboard_2 ==
+              *result2.find(GURL("http://user2"))->second);
+  ASSERT_EQ(1U, result2.count(GURL("http://system1")));
+  EXPECT_TRUE(system_virtual_keyboard_1 ==
+              *result2.find(GURL("http://system1"))->second);
+  EXPECT_EQ(0U, result2.count(GURL("http://system2")));
+}
+
+TEST(VirtualKeyboardSelectorTest, TestLayoutToExtensionMapping) {
+  static const char* ulayouts_1[] = { "a", "b", "c" };
+  static const char* ulayouts_2[] = { "a", "c", "d" };
+  static const char* slayouts_1[] = { "a", "x", "y" };
+  static const char* slayouts_2[] = { "a", "y", "z" };
+
+  VirtualKeyboard user_virtual_keyboard_1(
+      GURL("http://user1"), "", CreateLayoutSet(ulayouts_1),
+      false /* is_system */);
+  VirtualKeyboard user_virtual_keyboard_2(
+      GURL("http://user2"), "", CreateLayoutSet(ulayouts_2),
+      false /* is_system */);
+  VirtualKeyboard system_virtual_keyboard_1(
+      GURL("http://system1"), "", CreateLayoutSet(slayouts_1),
+      true /* is_system */);
+  VirtualKeyboard system_virtual_keyboard_2(
+      GURL("http://system2"), "", CreateLayoutSet(slayouts_2),
+      true /* is_system */);
+
+  TestableVirtualKeyboardSelector selector;
+
+  const LayoutToKeyboard& result1 = selector.layout_to_keyboard();
+  EXPECT_TRUE(result1.empty());
+
+  EXPECT_TRUE(selector.AddVirtualKeyboard(
+      user_virtual_keyboard_1.url(),
+      user_virtual_keyboard_1.name(),
+      user_virtual_keyboard_1.supported_layouts(),
+      user_virtual_keyboard_1.is_system()));
+  EXPECT_TRUE(selector.AddVirtualKeyboard(
+      user_virtual_keyboard_2.url(),
+      user_virtual_keyboard_2.name(),
+      user_virtual_keyboard_2.supported_layouts(),
+      user_virtual_keyboard_2.is_system()));
+  EXPECT_TRUE(selector.AddVirtualKeyboard(
+      system_virtual_keyboard_1.url(),
+      system_virtual_keyboard_1.name(),
+      system_virtual_keyboard_1.supported_layouts(),
+      system_virtual_keyboard_1.is_system()));
+  EXPECT_TRUE(selector.AddVirtualKeyboard(
+      system_virtual_keyboard_2.url(),
+      system_virtual_keyboard_2.name(),
+      system_virtual_keyboard_2.supported_layouts(),
+      system_virtual_keyboard_2.is_system()));
+
+  const LayoutToKeyboard& result2 = selector.layout_to_keyboard();
+  EXPECT_EQ(arraysize(ulayouts_1) +
+            arraysize(ulayouts_2) +
+            arraysize(slayouts_1) +
+            arraysize(slayouts_2),
+            result2.size());
+
+  std::pair<LayoutToKeyboard::const_iterator,
+      LayoutToKeyboard::const_iterator> range;
+  EXPECT_EQ(4U, result2.count("a"));
+  {
+    static const char* urls[] = { "http://user1", "http://user2",
+                                  "http://system1", "http://system2" };
+    range = result2.equal_range("a");
+    EXPECT_TRUE(CheckUrls(range.first, range.second, urls));
+  }
+  EXPECT_EQ(2U, result2.count("c"));
+  {
+    static const char* urls[] = { "http://user1", "http://user2" };
+    range = result2.equal_range("c");
+    EXPECT_TRUE(CheckUrls(range.first, range.second, urls));
+  }
+  EXPECT_EQ(1U, result2.count("z"));
+  {
+    static const char* urls[] = { "http://system2" };
+    range = result2.equal_range("z");
+    EXPECT_TRUE(CheckUrls(range.first, range.second, urls));
+  }
+  EXPECT_EQ(0U, result2.count("Z"));
+}
+
 }  // namespace input_method
 }  // namespace chromeos