Add SetUserPreference function to VirtualKeyboardSelector

BUG=None
TEST=ran unit_tests

Review URL: http://codereview.chromium.org/7497028

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@95566 0039d316-1c4b-4281-b951-d872f2087c98

3 files changed, 383 insertions, 99 deletions

diff --git a/chrome/browser/chromeos/input_method/virtual_keyboard_selector.cc b/chrome/browser/chromeos/input_method/virtual_keyboard_selector.cc
index 1e427ad..fb04aba 100644
--- a/chrome/browser/chromeos/input_method/virtual_keyboard_selector.cc
+++ b/chrome/browser/chromeos/input_method/virtual_keyboard_selector.cc
@@ -8,8 +8,26 @@
 #include "base/stl_util.h"
 
 namespace {
+
 const char kDefaultURLPath[] = "index.html";
 const size_t kDefaultURLPathLen = arraysize(kDefaultURLPath) - 1;
+
+namespace ime = ::chromeos::input_method;
+
+// Selects and returns a virtual keyboard extension from |keyboards| which
+// supports the |layout|.
+const ime::VirtualKeyboard* SelectVirtualKeyboardInternal(
+    const std::list<const ime::VirtualKeyboard*>& keyboards,
+    const std::string& layout) {
+  for (std::list<const ime::VirtualKeyboard*>::const_iterator iter =
+           keyboards.begin(); iter != keyboards.end(); ++iter) {
+    const ime::VirtualKeyboard* keyboard = *iter;
+    if (keyboard->IsLayoutSupported(layout))
+      return keyboard;
+  }
+  return NULL;
+}
+
 }  // namespace
 
 namespace chromeos {
@@ -38,6 +56,10 @@ GURL VirtualKeyboard::GetURLForLayout(const std::string& layout) const {
   return url_.ReplaceComponents(replacements);
 }
 
+bool VirtualKeyboard::IsLayoutSupported(const std::string& layout) const {
+  return supported_layouts_.count(layout) > 0;
+}
+
 VirtualKeyboardSelector::VirtualKeyboardSelector()
     : current_(NULL) {
 }
@@ -47,10 +69,13 @@ VirtualKeyboardSelector::~VirtualKeyboardSelector() {
   STLDeleteElements(&system_keyboards_);
 }
 
-void VirtualKeyboardSelector::AddVirtualKeyboard(
+bool VirtualKeyboardSelector::AddVirtualKeyboard(
     const GURL& url,
     const std::set<std::string>& supported_layouts,
     bool is_system) {
+  if (url_to_keyboard_.count(url))
+    return false;  // the URL is already in use.
+
   const VirtualKeyboard* new_keyboard = new VirtualKeyboard(url,
                                                             supported_layouts,
                                                             is_system);
@@ -59,6 +84,9 @@ void VirtualKeyboardSelector::AddVirtualKeyboard(
   } else {
     keyboards_.push_front(new_keyboard);
   }
+
+  url_to_keyboard_.insert(std::make_pair(url, new_keyboard));
+  return true;
 }
 
 const VirtualKeyboard* VirtualKeyboardSelector::SelectVirtualKeyboard(
@@ -68,12 +96,22 @@ const VirtualKeyboard* VirtualKeyboardSelector::SelectVirtualKeyboard(
     return NULL;
   }
 
-  // First, check whether the current keyboard supports the layout.
-  if (current_ && current_->supported_layouts().count(layout) > 0) {
+  // First, check the user pref.
+  std::map<std::string, const VirtualKeyboard*>::const_iterator iter =
+      user_preference_.find(layout);
+  if (iter != user_preference_.end() &&
+      iter->second->IsLayoutSupported(layout)) {
+    current_ = iter->second;
     return current_;
   }
 
-  const VirtualKeyboard* keyboard = SelectVirtualKeyboardInternal(layout);
+  // Second, check whether the current keyboard supports the layout.
+  if (current_ && current_->IsLayoutSupported(layout)) {
+    return current_;
+  }
+
+  const VirtualKeyboard* keyboard =
+      SelectVirtualKeyboardWithoutPreferences(layout);
   if (!keyboard) {
     VLOG(1) << "No virtual keyboard for " << layout << " is found";
     return NULL;
@@ -83,21 +121,38 @@ const VirtualKeyboard* VirtualKeyboardSelector::SelectVirtualKeyboard(
   return keyboard;
 }
 
-const VirtualKeyboard* VirtualKeyboardSelector::SelectVirtualKeyboardInternal(
-    const std::string& layout) {
-  std::list<const VirtualKeyboard*>::const_iterator iter;
-  for (iter = keyboards_.begin(); iter != keyboards_.end(); ++iter) {
-    if ((*iter)->supported_layouts().count(layout) > 0) {
-      return *iter;
-    }
+bool VirtualKeyboardSelector::SetUserPreference(
+    const std::string& layout, const GURL& url) {
+  std::map<GURL, const VirtualKeyboard*>::const_iterator iter =
+      url_to_keyboard_.find(url);
+  if (iter == url_to_keyboard_.end()) {
+    VLOG(1) << "Can't set user preference: unknown URL";
+    return false;
   }
-  for (iter = system_keyboards_.begin();
-       iter != system_keyboards_.end(); ++iter) {
-    if ((*iter)->supported_layouts().count(layout) > 0) {
-      return *iter;
-    }
+
+  const VirtualKeyboard* keyboard = iter->second;
+  if (!keyboard->IsLayoutSupported(layout)) {
+    VLOG(1) << "Requested layout is not supported by requested URL";
+    return false;
   }
-  return NULL;
+
+  RemoveUserPreference(layout);
+  user_preference_.insert(std::make_pair(layout, keyboard));
+  return true;
+}
+
+void VirtualKeyboardSelector::RemoveUserPreference(const std::string& layout) {
+  user_preference_.erase(layout);
+}
+
+const VirtualKeyboard*
+VirtualKeyboardSelector::SelectVirtualKeyboardWithoutPreferences(
+    const std::string& layout) {
+  const VirtualKeyboard* keyboard =
+      SelectVirtualKeyboardInternal(keyboards_, layout);
+  if (!keyboard)
+    keyboard = SelectVirtualKeyboardInternal(system_keyboards_, layout);
+  return keyboard;
 }
 
 }  // namespace input_method
diff --git a/chrome/browser/chromeos/input_method/virtual_keyboard_selector.h b/chrome/browser/chromeos/input_method/virtual_keyboard_selector.h
index 72cda91..9da69d9 100644
--- a/chrome/browser/chromeos/input_method/virtual_keyboard_selector.h
+++ b/chrome/browser/chromeos/input_method/virtual_keyboard_selector.h
@@ -7,6 +7,7 @@
 #pragma once
 
 #include <list>
+#include <map>
 #include <set>
 #include <string>
 
@@ -32,6 +33,9 @@ class VirtualKeyboard {
   // in this case.
   GURL GetURLForLayout(const std::string& layout) const;
 
+  // Returns true if the virtual keyboard extension supports the |layout|.
+  bool IsLayoutSupported(const std::string& layout) const;
+
   const GURL& url() const { return url_; }
   const std::set<std::string>& supported_layouts() const {
     return supported_layouts_;
@@ -54,15 +58,18 @@ class VirtualKeyboardSelector {
 
   // Adds a new virtual keyboard extension. If |keyboard.is_system_| is true,
   // the virtual keyboard extension will have lower priority than non-system
-  // keyboard extensions.
+  // keyboard extensions. Returns false if a virtual keyboard extension
+  // specified by the |url| is already added.
   // TODO(yusukes): Add RemoveVirtualKeyboard() as well.
-  void AddVirtualKeyboard(const GURL& url,
+  bool AddVirtualKeyboard(const GURL& url,
                           const std::set<std::string>& supported_layouts,
                           bool is_system);
 
   // Selects and returns the most suitable virtual keyboard extension for the
   // |layout|. Returns NULL if no virtual keyboard extension for the layout
-  // is found. If |current_|, which is the virtual keyboard extension currently
+  // is found. If a specific virtual keyboard extension for the |layout| is
+  // already set by SetUserPreference, the virtual keyboard extension is always
+  // returned. If |current_|, which is the virtual keyboard extension currently
   // in use, supports the |layout|, the current one will be returned. Otherwise
   // the function scans the list of |keyboards_| and then the list of
   // |system_keyboards_|. The most recently added keyboards to each list take
@@ -75,27 +82,48 @@ class VirtualKeyboardSelector {
   //   currently using.
   const VirtualKeyboard* SelectVirtualKeyboard(const std::string& layout);
 
-  // TODO(yusukes): Add a function something like
-  //   void SetUserPreference(const std::string& layout,
-  //                          const VirtualKeyboard& keyboard);
-  // so that users could use a specific virtual keyboard extension for the
-  // |layout|.
+  // Sets user preferences on virtual keyboard selection so that the virtual
+  // keyboard extension specified by the |url| is always selected for the
+  // |layout|. Returns false if a virtual keyboard extension whose address is
+  // |url| is not registered, or the extension specified by the |url| does not
+  // support the |layout|.
+  bool SetUserPreference(const std::string& layout, const GURL& url);
+
+  // Removes the preference for the |layout| added by SetUserPreference.
+  void RemoveUserPreference(const std::string& layout);
 
  protected:
-  // This function neither checks |current_| nor updates the variable. The
-  // function is protected for testability.
-  const VirtualKeyboard* SelectVirtualKeyboardInternal(
+  // Selects and returns the most suitable virtual keyboard extension for the
+  // |layout|. Unlike SelectVirtualKeyboard(), this function only scans
+  // |keyboards_| and |system_keyboards_| (in this order), and never updates
+  // |current_|. The function is protected for testability.
+  const VirtualKeyboard* SelectVirtualKeyboardWithoutPreferences(
       const std::string& layout);
 
+  // The function is protected for testability.
+  const std::map<std::string, const VirtualKeyboard*>& user_preference() const {
+    return user_preference_;
+  }
+
  private:
   // A list of third party virtual keyboard extensions.
   std::list<const VirtualKeyboard*> keyboards_;
   // A list of system virtual keyboard extensions.
   std::list<const VirtualKeyboard*> system_keyboards_;
 
+  // A map from layout name to virtual keyboard extension.
+  std::map<std::string, const VirtualKeyboard*> user_preference_;
+
+  // TODO(yusukes): Support per-site preference. e.g. always use virtual
+  // keyboard ABC on https://mail.google.com/, XYZ on http://www.google.com/.
+
   // The virtual keyboard currently in use.
   const VirtualKeyboard* current_;
 
+  // A map from URL to virtual keyboard extension. The map is for making
+  // SetUserPreference() faster.
+  std::map<GURL, const VirtualKeyboard*> url_to_keyboard_;
+
   DISALLOW_COPY_AND_ASSIGN(VirtualKeyboardSelector);
 };
 
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 95b8656..5eb5125 100644
--- a/chrome/browser/chromeos/input_method/virtual_keyboard_selector_unittest.cc
+++ b/chrome/browser/chromeos/input_method/virtual_keyboard_selector_unittest.cc
@@ -32,7 +32,8 @@ namespace input_method {
 class TestableVirtualKeyboardSelector : public VirtualKeyboardSelector {
  public:
   // Change access rights.
-  using VirtualKeyboardSelector::SelectVirtualKeyboardInternal;
+  using VirtualKeyboardSelector::SelectVirtualKeyboardWithoutPreferences;
+  using VirtualKeyboardSelector::user_preference;
 };
 
 TEST(VirtualKeyboardSelectorTest, TestNoKeyboard) {
@@ -41,21 +42,55 @@ TEST(VirtualKeyboardSelectorTest, TestNoKeyboard) {
   EXPECT_EQ(NULL, selector.SelectVirtualKeyboard(""));
 }
 
+TEST(VirtualKeyboardSelectorTest, TestAddVirtualKeyboard) {
+  static const char* layouts[] = { "a", "b", "c" };
+
+  // The first two keyboards have the same URL.
+  VirtualKeyboard virtual_keyboard_1(
+      GURL("http://url1"), CreateLayoutSet(layouts), true /* is_system */);
+  VirtualKeyboard virtual_keyboard_2(
+      GURL("http://url1"), CreateLayoutSet(layouts), false /* is_system */);
+  VirtualKeyboard virtual_keyboard_3(
+      GURL("http://url2"), CreateLayoutSet(layouts), false /* is_system */);
+
+  TestableVirtualKeyboardSelector selector;
+  EXPECT_TRUE(selector.AddVirtualKeyboard(
+      virtual_keyboard_1.url(),
+      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.supported_layouts(),
+      virtual_keyboard_1.is_system()));
+  EXPECT_FALSE(selector.AddVirtualKeyboard(
+      virtual_keyboard_2.url(),
+      virtual_keyboard_2.supported_layouts(),
+      virtual_keyboard_2.is_system()));
+
+  EXPECT_TRUE(selector.AddVirtualKeyboard(
+      virtual_keyboard_3.url(),
+      virtual_keyboard_3.supported_layouts(),
+      virtual_keyboard_3.is_system()));
+}
+
 TEST(VirtualKeyboardSelectorTest, TestSystemKeyboard) {
   static const char* layouts[] = { "a", "b", "c" };
   VirtualKeyboard system_virtual_keyboard(
       GURL("http://system"), CreateLayoutSet(layouts), true /* is_system */);
 
   TestableVirtualKeyboardSelector selector;
-  selector.AddVirtualKeyboard(system_virtual_keyboard.url(),
-                              system_virtual_keyboard.supported_layouts(),
-                              system_virtual_keyboard.is_system());
+  EXPECT_TRUE(selector.AddVirtualKeyboard(
+      system_virtual_keyboard.url(),
+      system_virtual_keyboard.supported_layouts(),
+      system_virtual_keyboard.is_system()));
 
-  ASSERT_TRUE(selector.SelectVirtualKeyboardInternal("a"));
+  ASSERT_TRUE(selector.SelectVirtualKeyboardWithoutPreferences("a"));
   EXPECT_TRUE(system_virtual_keyboard == *selector.SelectVirtualKeyboard("a"));
-  ASSERT_TRUE(selector.SelectVirtualKeyboardInternal("b"));
+  ASSERT_TRUE(selector.SelectVirtualKeyboardWithoutPreferences("b"));
   EXPECT_TRUE(system_virtual_keyboard == *selector.SelectVirtualKeyboard("b"));
-  ASSERT_TRUE(selector.SelectVirtualKeyboardInternal("c"));
+  ASSERT_TRUE(selector.SelectVirtualKeyboardWithoutPreferences("c"));
   EXPECT_TRUE(system_virtual_keyboard == *selector.SelectVirtualKeyboard("c"));
   EXPECT_EQ(NULL, selector.SelectVirtualKeyboard("d"));
   EXPECT_EQ(NULL, selector.SelectVirtualKeyboard("aa"));
@@ -72,48 +107,50 @@ TEST(VirtualKeyboardSelectorTest, TestTwoSystemKeyboards) {
       GURL("http://system2"), CreateLayoutSet(layouts_2), true /* is_system */);
 
   TestableVirtualKeyboardSelector selector;
-  selector.AddVirtualKeyboard(system_virtual_keyboard_1.url(),
-                              system_virtual_keyboard_1.supported_layouts(),
-                              system_virtual_keyboard_1.is_system());
-  selector.AddVirtualKeyboard(system_virtual_keyboard_2.url(),
-                              system_virtual_keyboard_2.supported_layouts(),
-                              system_virtual_keyboard_2.is_system());
+  EXPECT_TRUE(selector.AddVirtualKeyboard(
+      system_virtual_keyboard_1.url(),
+      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.supported_layouts(),
+      system_virtual_keyboard_2.is_system()));
 
   // At this point, system_virtual_keyboard_2 has higher priority since it's
   // added later than system_virtual_keyboard_1.
-  ASSERT_TRUE(selector.SelectVirtualKeyboardInternal("a"));
+  ASSERT_TRUE(selector.SelectVirtualKeyboardWithoutPreferences("a"));
   EXPECT_TRUE(system_virtual_keyboard_2 ==
               *selector.SelectVirtualKeyboard("a"));
-  ASSERT_TRUE(selector.SelectVirtualKeyboardInternal("c"));
+  ASSERT_TRUE(selector.SelectVirtualKeyboardWithoutPreferences("c"));
   EXPECT_TRUE(system_virtual_keyboard_2 ==
               *selector.SelectVirtualKeyboard("c"));
-  ASSERT_TRUE(selector.SelectVirtualKeyboardInternal("d"));
+  ASSERT_TRUE(selector.SelectVirtualKeyboardWithoutPreferences("d"));
   EXPECT_TRUE(system_virtual_keyboard_2 ==
               *selector.SelectVirtualKeyboard("d"));
 
   // Request "b". system_virtual_keyboard_1 should be returned.
-  ASSERT_TRUE(selector.SelectVirtualKeyboardInternal("b"));
+  ASSERT_TRUE(selector.SelectVirtualKeyboardWithoutPreferences("b"));
   EXPECT_TRUE(system_virtual_keyboard_1 ==
               *selector.SelectVirtualKeyboard("b"));
 
   // Now system_virtual_keyboard_1 should be selected for 'a' and 'c' since
   // it's the current virtual keyboard.
-  ASSERT_TRUE(selector.SelectVirtualKeyboardInternal("a"));
+  ASSERT_TRUE(selector.SelectVirtualKeyboardWithoutPreferences("a"));
   EXPECT_TRUE(system_virtual_keyboard_1 ==
               *selector.SelectVirtualKeyboard("a"));
-  ASSERT_TRUE(selector.SelectVirtualKeyboardInternal("c"));
+  ASSERT_TRUE(selector.SelectVirtualKeyboardWithoutPreferences("c"));
   EXPECT_TRUE(system_virtual_keyboard_1 ==
               *selector.SelectVirtualKeyboard("c"));
 
   // Request "d" again. system_virtual_keyboard_2 should be returned.
-  ASSERT_TRUE(selector.SelectVirtualKeyboardInternal("d"));
+  ASSERT_TRUE(selector.SelectVirtualKeyboardWithoutPreferences("d"));
   EXPECT_TRUE(system_virtual_keyboard_2 ==
               *selector.SelectVirtualKeyboard("d"));
   // This time, system_virtual_keyboard_2 should be selected for 'a' and 'c'.
-  ASSERT_TRUE(selector.SelectVirtualKeyboardInternal("a"));
+  ASSERT_TRUE(selector.SelectVirtualKeyboardWithoutPreferences("a"));
   EXPECT_TRUE(system_virtual_keyboard_2 ==
               *selector.SelectVirtualKeyboard("a"));
-  ASSERT_TRUE(selector.SelectVirtualKeyboardInternal("c"));
+  ASSERT_TRUE(selector.SelectVirtualKeyboardWithoutPreferences("c"));
   EXPECT_TRUE(system_virtual_keyboard_2 ==
               *selector.SelectVirtualKeyboard("c"));
 }
@@ -124,14 +161,15 @@ TEST(VirtualKeyboardSelectorTest, TestUserKeyboard) {
       GURL("http://user"), CreateLayoutSet(layouts), false /* is_system */);
 
   TestableVirtualKeyboardSelector selector;
-  selector.AddVirtualKeyboard(user_virtual_keyboard.url(),
-                              user_virtual_keyboard.supported_layouts(),
-                              user_virtual_keyboard.is_system());
-  ASSERT_TRUE(selector.SelectVirtualKeyboardInternal("a"));
+  EXPECT_TRUE(selector.AddVirtualKeyboard(
+      user_virtual_keyboard.url(),
+      user_virtual_keyboard.supported_layouts(),
+      user_virtual_keyboard.is_system()));
+  ASSERT_TRUE(selector.SelectVirtualKeyboardWithoutPreferences("a"));
   EXPECT_TRUE(user_virtual_keyboard == *selector.SelectVirtualKeyboard("a"));
-  ASSERT_TRUE(selector.SelectVirtualKeyboardInternal("b"));
+  ASSERT_TRUE(selector.SelectVirtualKeyboardWithoutPreferences("b"));
   EXPECT_TRUE(user_virtual_keyboard == *selector.SelectVirtualKeyboard("b"));
-  ASSERT_TRUE(selector.SelectVirtualKeyboardInternal("c"));
+  ASSERT_TRUE(selector.SelectVirtualKeyboardWithoutPreferences("c"));
   EXPECT_TRUE(user_virtual_keyboard == *selector.SelectVirtualKeyboard("c"));
   EXPECT_EQ(NULL, selector.SelectVirtualKeyboard("d"));
   EXPECT_EQ(NULL, selector.SelectVirtualKeyboard("aa"));
@@ -148,48 +186,50 @@ TEST(VirtualKeyboardSelectorTest, TestTwoUserKeyboards) {
       GURL("http://user2"), CreateLayoutSet(layouts_2), false /* is_system */);
 
   TestableVirtualKeyboardSelector selector;
-  selector.AddVirtualKeyboard(user_virtual_keyboard_1.url(),
-                              user_virtual_keyboard_1.supported_layouts(),
-                              user_virtual_keyboard_1.is_system());
-  selector.AddVirtualKeyboard(user_virtual_keyboard_2.url(),
-                              user_virtual_keyboard_2.supported_layouts(),
-                              user_virtual_keyboard_2.is_system());
+  EXPECT_TRUE(selector.AddVirtualKeyboard(
+      user_virtual_keyboard_1.url(),
+      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.supported_layouts(),
+      user_virtual_keyboard_2.is_system()));
 
   // At this point, user_virtual_keyboard_2 has higher priority since it's
   // added later than user_virtual_keyboard_1.
-  ASSERT_TRUE(selector.SelectVirtualKeyboardInternal("a"));
+  ASSERT_TRUE(selector.SelectVirtualKeyboardWithoutPreferences("a"));
   EXPECT_TRUE(user_virtual_keyboard_2 ==
               *selector.SelectVirtualKeyboard("a"));
-  ASSERT_TRUE(selector.SelectVirtualKeyboardInternal("c"));
+  ASSERT_TRUE(selector.SelectVirtualKeyboardWithoutPreferences("c"));
   EXPECT_TRUE(user_virtual_keyboard_2 ==
               *selector.SelectVirtualKeyboard("c"));
-  ASSERT_TRUE(selector.SelectVirtualKeyboardInternal("d"));
+  ASSERT_TRUE(selector.SelectVirtualKeyboardWithoutPreferences("d"));
   EXPECT_TRUE(user_virtual_keyboard_2 ==
               *selector.SelectVirtualKeyboard("d"));
 
   // Request "b". user_virtual_keyboard_1 should be returned.
-  ASSERT_TRUE(selector.SelectVirtualKeyboardInternal("b"));
+  ASSERT_TRUE(selector.SelectVirtualKeyboardWithoutPreferences("b"));
   EXPECT_TRUE(user_virtual_keyboard_1 ==
               *selector.SelectVirtualKeyboard("b"));
 
   // Now user_virtual_keyboard_1 should be selected for 'a' and 'c' since
   // it's the current virtual keyboard.
-  ASSERT_TRUE(selector.SelectVirtualKeyboardInternal("a"));
+  ASSERT_TRUE(selector.SelectVirtualKeyboardWithoutPreferences("a"));
   EXPECT_TRUE(user_virtual_keyboard_1 ==
               *selector.SelectVirtualKeyboard("a"));
-  ASSERT_TRUE(selector.SelectVirtualKeyboardInternal("c"));
+  ASSERT_TRUE(selector.SelectVirtualKeyboardWithoutPreferences("c"));
   EXPECT_TRUE(user_virtual_keyboard_1 ==
               *selector.SelectVirtualKeyboard("c"));
 
   // Request "d" again. user_virtual_keyboard_2 should be returned.
-  ASSERT_TRUE(selector.SelectVirtualKeyboardInternal("d"));
+  ASSERT_TRUE(selector.SelectVirtualKeyboardWithoutPreferences("d"));
   EXPECT_TRUE(user_virtual_keyboard_2 ==
               *selector.SelectVirtualKeyboard("d"));
   // This time, user_virtual_keyboard_2 should be selected for 'a' and 'c'.
-  ASSERT_TRUE(selector.SelectVirtualKeyboardInternal("a"));
+  ASSERT_TRUE(selector.SelectVirtualKeyboardWithoutPreferences("a"));
   EXPECT_TRUE(user_virtual_keyboard_2 ==
               *selector.SelectVirtualKeyboard("a"));
-  ASSERT_TRUE(selector.SelectVirtualKeyboardInternal("c"));
+  ASSERT_TRUE(selector.SelectVirtualKeyboardWithoutPreferences("c"));
   EXPECT_TRUE(user_virtual_keyboard_2 ==
               *selector.SelectVirtualKeyboard("c"));
 }
@@ -210,79 +250,83 @@ TEST(VirtualKeyboardSelectorTest, TestUserSystemMixed) {
       GURL("http://system2"), CreateLayoutSet(layouts_2), true /* is_system */);
 
   TestableVirtualKeyboardSelector selector;
-  selector.AddVirtualKeyboard(user_virtual_keyboard_1.url(),
-                              user_virtual_keyboard_1.supported_layouts(),
-                              user_virtual_keyboard_1.is_system());
-  selector.AddVirtualKeyboard(user_virtual_keyboard_2.url(),
-                              user_virtual_keyboard_2.supported_layouts(),
-                              user_virtual_keyboard_2.is_system());
-  selector.AddVirtualKeyboard(system_virtual_keyboard_1.url(),
-                              system_virtual_keyboard_1.supported_layouts(),
-                              system_virtual_keyboard_1.is_system());
-  selector.AddVirtualKeyboard(system_virtual_keyboard_2.url(),
-                              system_virtual_keyboard_2.supported_layouts(),
-                              system_virtual_keyboard_2.is_system());
+  EXPECT_TRUE(selector.AddVirtualKeyboard(
+      user_virtual_keyboard_1.url(),
+      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.supported_layouts(),
+      user_virtual_keyboard_2.is_system()));
+  EXPECT_TRUE(selector.AddVirtualKeyboard(
+      system_virtual_keyboard_1.url(),
+      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.supported_layouts(),
+      system_virtual_keyboard_2.is_system()));
 
   // At this point, user_virtual_keyboard_2 has the highest priority.
-  ASSERT_TRUE(selector.SelectVirtualKeyboardInternal("a"));
+  ASSERT_TRUE(selector.SelectVirtualKeyboardWithoutPreferences("a"));
   EXPECT_TRUE(user_virtual_keyboard_2 ==
               *selector.SelectVirtualKeyboard("a"));
-  ASSERT_TRUE(selector.SelectVirtualKeyboardInternal("c"));
+  ASSERT_TRUE(selector.SelectVirtualKeyboardWithoutPreferences("c"));
   EXPECT_TRUE(user_virtual_keyboard_2 ==
               *selector.SelectVirtualKeyboard("c"));
-  ASSERT_TRUE(selector.SelectVirtualKeyboardInternal("d"));
+  ASSERT_TRUE(selector.SelectVirtualKeyboardWithoutPreferences("d"));
   EXPECT_TRUE(user_virtual_keyboard_2 ==
               *selector.SelectVirtualKeyboard("d"));
 
   // Request "b". user_virtual_keyboard_1 should be returned.
-  ASSERT_TRUE(selector.SelectVirtualKeyboardInternal("b"));
+  ASSERT_TRUE(selector.SelectVirtualKeyboardWithoutPreferences("b"));
   EXPECT_TRUE(user_virtual_keyboard_1 ==
               *selector.SelectVirtualKeyboard("b"));
   // Now user_virtual_keyboard_1 should be selected for 'a' and 'c' since
   // it's the current virtual keyboard.
-  ASSERT_TRUE(selector.SelectVirtualKeyboardInternal("a"));
+  ASSERT_TRUE(selector.SelectVirtualKeyboardWithoutPreferences("a"));
   EXPECT_TRUE(user_virtual_keyboard_1 ==
               *selector.SelectVirtualKeyboard("a"));
-  ASSERT_TRUE(selector.SelectVirtualKeyboardInternal("c"));
+  ASSERT_TRUE(selector.SelectVirtualKeyboardWithoutPreferences("c"));
   EXPECT_TRUE(user_virtual_keyboard_1 ==
               *selector.SelectVirtualKeyboard("c"));
 
   // Request "x". system_virtual_keyboard_2 should be returned (since it's
   // added later than system_virtual_keyboard_1).
-  ASSERT_TRUE(selector.SelectVirtualKeyboardInternal("x"));
+  ASSERT_TRUE(selector.SelectVirtualKeyboardWithoutPreferences("x"));
   EXPECT_TRUE(system_virtual_keyboard_1 ==
               *selector.SelectVirtualKeyboard("x"));
-  ASSERT_TRUE(selector.SelectVirtualKeyboardInternal("y"));
+  ASSERT_TRUE(selector.SelectVirtualKeyboardWithoutPreferences("y"));
   EXPECT_TRUE(system_virtual_keyboard_1 ==
               *selector.SelectVirtualKeyboard("y"));
-  ASSERT_TRUE(selector.SelectVirtualKeyboardInternal("a"));
+  ASSERT_TRUE(selector.SelectVirtualKeyboardWithoutPreferences("a"));
   EXPECT_TRUE(system_virtual_keyboard_1 ==
               *selector.SelectVirtualKeyboard("a"));
 
   // Switch to system_virtual_keyboard_2.
-  ASSERT_TRUE(selector.SelectVirtualKeyboardInternal("z"));
+  ASSERT_TRUE(selector.SelectVirtualKeyboardWithoutPreferences("z"));
   EXPECT_TRUE(system_virtual_keyboard_2 ==
               *selector.SelectVirtualKeyboard("z"));
-  ASSERT_TRUE(selector.SelectVirtualKeyboardInternal("y"));
+  ASSERT_TRUE(selector.SelectVirtualKeyboardWithoutPreferences("y"));
   EXPECT_TRUE(system_virtual_keyboard_2 ==
               *selector.SelectVirtualKeyboard("y"));
-  ASSERT_TRUE(selector.SelectVirtualKeyboardInternal("a"));
+  ASSERT_TRUE(selector.SelectVirtualKeyboardWithoutPreferences("a"));
   EXPECT_TRUE(system_virtual_keyboard_2 ==
               *selector.SelectVirtualKeyboard("a"));
 
   // Switch back to system_virtual_keyboard_2.
-  ASSERT_TRUE(selector.SelectVirtualKeyboardInternal("x"));
+  ASSERT_TRUE(selector.SelectVirtualKeyboardWithoutPreferences("x"));
   EXPECT_TRUE(system_virtual_keyboard_1 ==
               *selector.SelectVirtualKeyboard("x"));
-  ASSERT_TRUE(selector.SelectVirtualKeyboardInternal("y"));
+  ASSERT_TRUE(selector.SelectVirtualKeyboardWithoutPreferences("y"));
   EXPECT_TRUE(system_virtual_keyboard_1 ==
               *selector.SelectVirtualKeyboard("y"));
-  ASSERT_TRUE(selector.SelectVirtualKeyboardInternal("a"));
+  ASSERT_TRUE(selector.SelectVirtualKeyboardWithoutPreferences("a"));
   EXPECT_TRUE(system_virtual_keyboard_1 ==
               *selector.SelectVirtualKeyboard("a"));
 
   // Switch back to user_virtual_keyboard_1.
-  ASSERT_TRUE(selector.SelectVirtualKeyboardInternal("c"));
+  ASSERT_TRUE(selector.SelectVirtualKeyboardWithoutPreferences("c"));
   EXPECT_TRUE(user_virtual_keyboard_2 ==
               *selector.SelectVirtualKeyboard("c"));
 }
@@ -306,5 +350,162 @@ TEST(VirtualKeyboardTest, TestUrl) {
             system_virtual_keyboard.GetURLForLayout("").spec());
 }
 
+TEST(VirtualKeyboardSelectorTest, TestSetUserPreference1) {
+  static const char* layouts[] = { "a", "b", "c" };
+
+  VirtualKeyboard user_virtual_keyboard(
+      GURL("http://user"), CreateLayoutSet(layouts), false /* is_system */);
+
+  TestableVirtualKeyboardSelector selector;
+  EXPECT_TRUE(selector.AddVirtualKeyboard(
+      user_virtual_keyboard.url(),
+      user_virtual_keyboard.supported_layouts(),
+      user_virtual_keyboard.is_system()));
+
+  EXPECT_EQ(0U, selector.user_preference().size());
+  EXPECT_FALSE(selector.SetUserPreference("bad_layout", GURL("http://user")));
+  EXPECT_EQ(0U, selector.user_preference().size());
+  EXPECT_FALSE(selector.SetUserPreference("a", GURL("http://bad_url")));
+  EXPECT_EQ(0U, selector.user_preference().size());
+  EXPECT_TRUE(selector.SetUserPreference("a", GURL("http://user")));
+  EXPECT_EQ(1U, selector.user_preference().size());
+  EXPECT_TRUE(selector.SetUserPreference("b", GURL("http://user")));
+  EXPECT_EQ(2U, selector.user_preference().size());
+  EXPECT_TRUE(selector.SetUserPreference("c", GURL("http://user")));
+  EXPECT_EQ(3U, selector.user_preference().size());
+}
+
+TEST(VirtualKeyboardSelectorTest, TestSetUserPreference2) {
+  static const char* layouts[] = { "a", "b", "c" };
+
+  VirtualKeyboard system_virtual_keyboard(
+      GURL("http://system"), CreateLayoutSet(layouts), true /* is_system */);
+
+  TestableVirtualKeyboardSelector selector;
+  EXPECT_TRUE(selector.AddVirtualKeyboard(
+      system_virtual_keyboard.url(),
+      system_virtual_keyboard.supported_layouts(),
+      system_virtual_keyboard.is_system()));
+
+  EXPECT_EQ(0U, selector.user_preference().size());
+  EXPECT_FALSE(selector.SetUserPreference("bad_layout", GURL("http://system")));
+  EXPECT_EQ(0U, selector.user_preference().size());
+  EXPECT_FALSE(selector.SetUserPreference("a", GURL("http://bad_url")));
+  EXPECT_EQ(0U, selector.user_preference().size());
+  EXPECT_TRUE(selector.SetUserPreference("a", GURL("http://system")));
+  EXPECT_EQ(1U, selector.user_preference().size());
+  EXPECT_TRUE(selector.SetUserPreference("b", GURL("http://system")));
+  EXPECT_EQ(2U, selector.user_preference().size());
+  EXPECT_TRUE(selector.SetUserPreference("c", GURL("http://system")));
+  EXPECT_EQ(3U, selector.user_preference().size());
+}
+
+TEST(VirtualKeyboardSelectorTest, TestSetUserPreferenceUserSystemMixed) {
+  static const char* ulayouts_1[] = { "a", "b", "c" };
+  static const char* ulayouts_2[] = { "a", "c", "d" };
+  static const char* layouts_1[] = { "a", "x", "y" };
+  static const char* layouts_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(layouts_1), true /* is_system */);
+  VirtualKeyboard system_virtual_keyboard_2(
+      GURL("http://system2"), CreateLayoutSet(layouts_2), true /* is_system */);
+
+  TestableVirtualKeyboardSelector selector;
+  EXPECT_TRUE(selector.AddVirtualKeyboard(
+      user_virtual_keyboard_1.url(),
+      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.supported_layouts(),
+      user_virtual_keyboard_2.is_system()));
+  EXPECT_TRUE(selector.AddVirtualKeyboard(
+      system_virtual_keyboard_1.url(),
+      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.supported_layouts(),
+      system_virtual_keyboard_2.is_system()));
+
+  // Set and then remove user pref (=NOP).
+  EXPECT_TRUE(selector.SetUserPreference("a", GURL("http://system1")));
+  selector.RemoveUserPreference("a");
+
+  // At this point, user_virtual_keyboard_2 has the highest priority.
+  ASSERT_TRUE(selector.SelectVirtualKeyboardWithoutPreferences("a"));
+  EXPECT_TRUE(user_virtual_keyboard_2 ==
+              *selector.SelectVirtualKeyboard("a"));
+  ASSERT_TRUE(selector.SelectVirtualKeyboardWithoutPreferences("c"));
+  EXPECT_TRUE(user_virtual_keyboard_2 ==
+              *selector.SelectVirtualKeyboard("c"));
+  ASSERT_TRUE(selector.SelectVirtualKeyboardWithoutPreferences("d"));
+  EXPECT_TRUE(user_virtual_keyboard_2 ==
+              *selector.SelectVirtualKeyboard("d"));
+
+  // Request "b". user_virtual_keyboard_1 should be returned.
+  ASSERT_TRUE(selector.SelectVirtualKeyboardWithoutPreferences("b"));
+  EXPECT_TRUE(user_virtual_keyboard_1 ==
+              *selector.SelectVirtualKeyboard("b"));
+
+  // Set user pref.
+  EXPECT_TRUE(selector.SetUserPreference("a", GURL("http://user2")));
+
+  ASSERT_TRUE(selector.SelectVirtualKeyboardWithoutPreferences("a"));
+  EXPECT_TRUE(user_virtual_keyboard_2 ==  // follow the user pref.
+              *selector.SelectVirtualKeyboard("a"));
+  ASSERT_TRUE(selector.SelectVirtualKeyboardWithoutPreferences("c"));
+  EXPECT_TRUE(user_virtual_keyboard_2 ==
+              *selector.SelectVirtualKeyboard("c"));
+
+  // Request "x". system_virtual_keyboard_2 should be returned (since it's
+  // added later than system_virtual_keyboard_1).
+  ASSERT_TRUE(selector.SelectVirtualKeyboardWithoutPreferences("x"));
+  EXPECT_TRUE(system_virtual_keyboard_1 ==
+              *selector.SelectVirtualKeyboard("x"));
+  ASSERT_TRUE(selector.SelectVirtualKeyboardWithoutPreferences("y"));
+  EXPECT_TRUE(system_virtual_keyboard_1 ==
+              *selector.SelectVirtualKeyboard("y"));
+  ASSERT_TRUE(selector.SelectVirtualKeyboardWithoutPreferences("a"));
+  EXPECT_TRUE(user_virtual_keyboard_2 ==  // follow the user pref.
+              *selector.SelectVirtualKeyboard("a"));
+
+  // Switch to system_virtual_keyboard_2.
+  ASSERT_TRUE(selector.SelectVirtualKeyboardWithoutPreferences("z"));
+  EXPECT_TRUE(system_virtual_keyboard_2 ==
+              *selector.SelectVirtualKeyboard("z"));
+  ASSERT_TRUE(selector.SelectVirtualKeyboardWithoutPreferences("y"));
+  EXPECT_TRUE(system_virtual_keyboard_2 ==
+              *selector.SelectVirtualKeyboard("y"));
+  ASSERT_TRUE(selector.SelectVirtualKeyboardWithoutPreferences("a"));
+  EXPECT_TRUE(user_virtual_keyboard_2 ==  // follow the user pref.
+              *selector.SelectVirtualKeyboard("a"));
+
+  // Switch back to system_virtual_keyboard_2.
+  ASSERT_TRUE(selector.SelectVirtualKeyboardWithoutPreferences("x"));
+  EXPECT_TRUE(system_virtual_keyboard_1 ==
+              *selector.SelectVirtualKeyboard("x"));
+  ASSERT_TRUE(selector.SelectVirtualKeyboardWithoutPreferences("y"));
+  EXPECT_TRUE(system_virtual_keyboard_1 ==
+              *selector.SelectVirtualKeyboard("y"));
+
+  // Remove it.
+  selector.RemoveUserPreference("a");
+
+  ASSERT_TRUE(selector.SelectVirtualKeyboardWithoutPreferences("a"));
+  EXPECT_TRUE(system_virtual_keyboard_1 ==   // user pref is no longer available
+              *selector.SelectVirtualKeyboard("a"));
+
+  // Switch back to user_virtual_keyboard_1.
+  ASSERT_TRUE(selector.SelectVirtualKeyboardWithoutPreferences("c"));
+  EXPECT_TRUE(user_virtual_keyboard_2 ==
+              *selector.SelectVirtualKeyboard("c"));
+}
+
 }  // namespace input_method
 }  // namespace chromeos