chrome/browser/chromeos/input_method/ refactoring [part 6 of 6]

chrome/browser/chromeos/input_method/browser_state_monitor_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/browser_state_monitor.h"
+
+#include "chrome/browser/chromeos/input_method/mock_input_method_manager.h"
+#include "chrome/browser/prefs/pref_member.h"
+#include "chrome/common/chrome_notification_types.h"
+#include "chrome/common/pref_names.h"
+#include "chrome/test/base/testing_pref_service.h"
+#include "content/public/browser/notification_details.h"
+#include "content/public/browser/notification_service.h"
+#include "testing/gtest/include/gtest/gtest.h"
+
+namespace chromeos {
+namespace input_method {
+namespace {
+
+void RegisterTestPrefs(PrefService* prefs) {
+  prefs->RegisterStringPref(prefs::kLanguagePreviousInputMethod,
+                            "",
+                            PrefService::UNSYNCABLE_PREF);
+  prefs->RegisterStringPref(prefs::kLanguageCurrentInputMethod,
+                            "",
+                            PrefService::UNSYNCABLE_PREF);
+}
+
+class TestableBrowserStateMonitor : public BrowserStateMonitor {
+ public:
+  using BrowserStateMonitor::InputMethodChanged;
+  using BrowserStateMonitor::Observe;
+
+  explicit TestableBrowserStateMonitor(InputMethodManager* manager)
+      : BrowserStateMonitor(manager) {
+    ResetCounters();
+  }
+
+  virtual ~TestableBrowserStateMonitor() {
+  }
+
+  void ResetCounters() {
+    update_local_state_count_ = 0;
+    last_local_state_.clear();
+    update_user_pref_count_ = 0;
+    last_user_pref_.clear();
+  }
+
+  int update_local_state_count() const { return update_local_state_count_; }
+  const std::string& last_local_state() const { return last_local_state_; }
+  int update_user_pref_count() const { return update_user_pref_count_; }
+  const std::string& last_user_pref() const { return last_user_pref_; }
+
+ protected:
+  virtual void UpdateLocalState(
+      const std::string& current_input_method) OVERRIDE {
+    ++update_local_state_count_;
+    last_local_state_ = current_input_method;
+    // Do not call the parent class' method since it depends on the global
+    // browser object which is a bit difficult to mock. This should be okay
+    // since the method is really simple.
+  }
+
+  virtual void UpdateUserPreferences(
+      const std::string& current_input_method) OVERRIDE {
+    ++update_user_pref_count_;
+    last_user_pref_ = current_input_method;
+    BrowserStateMonitor::UpdateUserPreferences(current_input_method);
+  }
+
+ private:
+  int update_local_state_count_;
+  std::string last_local_state_;
+  int update_user_pref_count_;
+  std::string last_user_pref_;
+
+  DISALLOW_COPY_AND_ASSIGN(TestableBrowserStateMonitor);
+};
+
+}  // anonymous namespace
+
+TEST(BrowserStateMonitorTest, TestConstruction) {
+  TestingPrefService prefs;
+  RegisterTestPrefs(&prefs);
+  MockInputMethodManager mock_manager;
+  TestableBrowserStateMonitor monitor(&mock_manager);
+  monitor.SetPrefServiceForTesting(&prefs);
+
+  // Check the initial state of the |mock_manager| and |monitor| objects.
+  EXPECT_EQ(1, mock_manager.add_observer_count_);
+  EXPECT_EQ(1, mock_manager.set_state_count_);
+  EXPECT_EQ(InputMethodManager::STATE_LOGIN_SCREEN, mock_manager.last_state_);
+  EXPECT_EQ(InputMethodManager::STATE_LOGIN_SCREEN, monitor.state());
+}
+
+TEST(BrowserStateMonitorTest, TestDestruction) {
+  TestingPrefService prefs;
+  RegisterTestPrefs(&prefs);
+  MockInputMethodManager mock_manager;
+  {
+    TestableBrowserStateMonitor monitor(&mock_manager);
+    monitor.SetPrefServiceForTesting(&prefs);
+  }
+  EXPECT_EQ(1, mock_manager.remove_observer_count_);
+}
+
+TEST(BrowserStateMonitorTest, TestObserveLoginUserChanged) {
+  TestingPrefService prefs;
+  RegisterTestPrefs(&prefs);
+  MockInputMethodManager mock_manager;
+  TestableBrowserStateMonitor monitor(&mock_manager);
+  monitor.SetPrefServiceForTesting(&prefs);
+
+  EXPECT_EQ(1, mock_manager.set_state_count_);
+  monitor.Observe(chrome::NOTIFICATION_LOGIN_USER_CHANGED,
+                  content::NotificationService::AllSources(),
+                  content::NotificationService::NoDetails());
+
+  // Check if the state of the |mock_manager| as well as the |monitor| are both
+  // changed.
+  EXPECT_EQ(2, mock_manager.set_state_count_);
+  EXPECT_EQ(InputMethodManager::STATE_BROWSER_SCREEN, mock_manager.last_state_);
+  EXPECT_EQ(InputMethodManager::STATE_BROWSER_SCREEN, monitor.state());
+}
+
+TEST(BrowserStateMonitorTest, TestObserveSessionStarted) {
+  TestingPrefService prefs;
+  RegisterTestPrefs(&prefs);
+  MockInputMethodManager mock_manager;
+  TestableBrowserStateMonitor monitor(&mock_manager);
+  monitor.SetPrefServiceForTesting(&prefs);
+
+  EXPECT_EQ(1, mock_manager.set_state_count_);
+  monitor.Observe(chrome::NOTIFICATION_SESSION_STARTED,
+                  content::NotificationService::AllSources(),
+                  content::NotificationService::NoDetails());
+
+  // Check if the state of the |mock_manager| as well as the |monitor| are both
+  // changed.
+  EXPECT_EQ(2, mock_manager.set_state_count_);
+  EXPECT_EQ(InputMethodManager::STATE_BROWSER_SCREEN, mock_manager.last_state_);
+  EXPECT_EQ(InputMethodManager::STATE_BROWSER_SCREEN, monitor.state());
+}
+
+TEST(BrowserStateMonitorTest, TestObserveLoginUserChangedThenSessionStarted) {
+  TestingPrefService prefs;
+  RegisterTestPrefs(&prefs);
+  MockInputMethodManager mock_manager;
+  TestableBrowserStateMonitor monitor(&mock_manager);
+  monitor.SetPrefServiceForTesting(&prefs);
+
+  EXPECT_EQ(1, mock_manager.set_state_count_);
+  monitor.Observe(chrome::NOTIFICATION_LOGIN_USER_CHANGED,
+                  content::NotificationService::AllSources(),
+                  content::NotificationService::NoDetails());
+
+  // Check if the state of the |mock_manager| as well as the |monitor| are both
+  // changed.
+  EXPECT_EQ(2, mock_manager.set_state_count_);
+  EXPECT_EQ(InputMethodManager::STATE_BROWSER_SCREEN, mock_manager.last_state_);
+  EXPECT_EQ(InputMethodManager::STATE_BROWSER_SCREEN, monitor.state());
+
+  monitor.Observe(chrome::NOTIFICATION_SESSION_STARTED,
+                  content::NotificationService::AllSources(),
+                  content::NotificationService::NoDetails());
+
+  // The second notification should be nop.
+  EXPECT_EQ(2, mock_manager.set_state_count_);
+  EXPECT_EQ(InputMethodManager::STATE_BROWSER_SCREEN, mock_manager.last_state_);
+  EXPECT_EQ(InputMethodManager::STATE_BROWSER_SCREEN, monitor.state());
+}
+
+TEST(BrowserStateMonitorTest, TestObserveScreenLockUnlock) {
+  TestingPrefService prefs;
+  RegisterTestPrefs(&prefs);
+  MockInputMethodManager mock_manager;
+  TestableBrowserStateMonitor monitor(&mock_manager);
+  monitor.SetPrefServiceForTesting(&prefs);
+
+  EXPECT_EQ(1, mock_manager.set_state_count_);
+  monitor.Observe(chrome::NOTIFICATION_LOGIN_USER_CHANGED,
+                  content::NotificationService::AllSources(),
+                  content::NotificationService::NoDetails());
+  EXPECT_EQ(2, mock_manager.set_state_count_);
+  monitor.Observe(chrome::NOTIFICATION_SESSION_STARTED,
+                  content::NotificationService::AllSources(),
+                  content::NotificationService::NoDetails());
+  EXPECT_EQ(2, mock_manager.set_state_count_);
+  bool locked = true;
+  monitor.Observe(chrome::NOTIFICATION_SCREEN_LOCK_STATE_CHANGED,
+                  content::NotificationService::AllSources(),
+                  content::Details<bool>(&locked));
+  EXPECT_EQ(3, mock_manager.set_state_count_);
+  EXPECT_EQ(InputMethodManager::STATE_LOCK_SCREEN, mock_manager.last_state_);
+  EXPECT_EQ(InputMethodManager::STATE_LOCK_SCREEN, monitor.state());
+
+  // When the screen is locked, the monitor should ignore input method changes.
+  monitor.InputMethodChanged(&mock_manager);
+  EXPECT_EQ(0, monitor.update_local_state_count());
+  EXPECT_EQ(0, monitor.update_user_pref_count());
+
+  locked = false;
+  monitor.Observe(chrome::NOTIFICATION_SCREEN_LOCK_STATE_CHANGED,
+                  content::NotificationService::AllSources(),
+                  content::Details<bool>(&locked));
+  EXPECT_EQ(4, mock_manager.set_state_count_);
+  EXPECT_EQ(InputMethodManager::STATE_BROWSER_SCREEN, mock_manager.last_state_);
+  EXPECT_EQ(InputMethodManager::STATE_BROWSER_SCREEN, monitor.state());
+
+  monitor.InputMethodChanged(&mock_manager);
+  EXPECT_EQ(0, monitor.update_local_state_count());
+  EXPECT_EQ(1, monitor.update_user_pref_count());
+}
+
+TEST(BrowserStateMonitorTest, TestObserveAppTerminating) {
+  TestingPrefService prefs;
+  RegisterTestPrefs(&prefs);
+  MockInputMethodManager mock_manager;
+  TestableBrowserStateMonitor monitor(&mock_manager);
+  monitor.SetPrefServiceForTesting(&prefs);
+
+  EXPECT_EQ(1, mock_manager.set_state_count_);
+  monitor.Observe(content::NOTIFICATION_APP_TERMINATING,
+                  content::NotificationService::AllSources(),
+                  content::NotificationService::NoDetails());
+
+  // Check if the state of the |mock_manager| as well as the |monitor| are both
+  // changed.
+  EXPECT_EQ(2, mock_manager.set_state_count_);
+  EXPECT_EQ(InputMethodManager::STATE_TERMINATING,
+            mock_manager.last_state_);
+  EXPECT_EQ(InputMethodManager::STATE_TERMINATING, monitor.state());
+
+  // In the terminating state, the monitor should ignore input method changes.
+  monitor.InputMethodChanged(&mock_manager);
+  EXPECT_EQ(0, monitor.update_local_state_count());
+  EXPECT_EQ(0, monitor.update_user_pref_count());
+}
+
+TEST(BrowserStateMonitorTest, TestObservePrefChanged) {
+  TestingPrefService prefs;
+  RegisterTestPrefs(&prefs);
+  MockInputMethodManager mock_manager;
+  TestableBrowserStateMonitor monitor(&mock_manager);
+  monitor.SetPrefServiceForTesting(&prefs);
+
+  EXPECT_EQ(1, mock_manager.set_state_count_);
+  monitor.Observe(chrome::NOTIFICATION_PREF_CHANGED,
+                  content::NotificationService::AllSources(),
+                  content::NotificationService::NoDetails());
+
+  // NOTIFICATION_PREF_CHANGED should be ignored.
+  EXPECT_EQ(1, mock_manager.set_state_count_);
+}
+
+TEST(BrowserStateMonitorTest, TestUpdatePrefOnLoginScreen) {
+  TestingPrefService prefs;
+  RegisterTestPrefs(&prefs);
+  MockInputMethodManager mock_manager;
+  TestableBrowserStateMonitor monitor(&mock_manager);
+  monitor.SetPrefServiceForTesting(&prefs);
+
+  EXPECT_EQ(InputMethodManager::STATE_LOGIN_SCREEN, monitor.state());
+  monitor.InputMethodChanged(&mock_manager);
+  EXPECT_EQ(1, monitor.update_local_state_count());
+  EXPECT_EQ(0, monitor.update_user_pref_count());
+  monitor.InputMethodChanged(&mock_manager);
+  EXPECT_EQ(2, monitor.update_local_state_count());
+  EXPECT_EQ(0, monitor.update_user_pref_count());
+}
+
+TEST(BrowserStateMonitorTest, TestUpdatePrefOnBrowserScreen) {
+  TestingPrefService prefs;
+  RegisterTestPrefs(&prefs);
+  MockInputMethodManager mock_manager;
+  TestableBrowserStateMonitor monitor(&mock_manager);
+  monitor.SetPrefServiceForTesting(&prefs);
+
+  monitor.Observe(chrome::NOTIFICATION_LOGIN_USER_CHANGED,
+                  content::NotificationService::AllSources(),
+                  content::NotificationService::NoDetails());
+  EXPECT_EQ(InputMethodManager::STATE_BROWSER_SCREEN, monitor.state());
+
+  monitor.InputMethodChanged(&mock_manager);
+  EXPECT_EQ(0, monitor.update_local_state_count());
+  EXPECT_EQ(1, monitor.update_user_pref_count());
+  monitor.InputMethodChanged(&mock_manager);
+  EXPECT_EQ(0, monitor.update_local_state_count());
+  EXPECT_EQ(2, monitor.update_user_pref_count());
+
+  monitor.Observe(chrome::NOTIFICATION_SESSION_STARTED,
+                  content::NotificationService::AllSources(),
+                  content::NotificationService::NoDetails());
+  EXPECT_EQ(InputMethodManager::STATE_BROWSER_SCREEN, monitor.state());
+
+  monitor.InputMethodChanged(&mock_manager);
+  EXPECT_EQ(0, monitor.update_local_state_count());
+  EXPECT_EQ(3, monitor.update_user_pref_count());
+  monitor.InputMethodChanged(&mock_manager);
+  EXPECT_EQ(0, monitor.update_local_state_count());
+  EXPECT_EQ(4, monitor.update_user_pref_count());
+}
+
+TEST(BrowserStateMonitorTest, TestUpdatePrefOnLoginScreenDetails) {
+  TestingPrefService prefs;
+  RegisterTestPrefs(&prefs);
+  MockInputMethodManager mock_manager;
+  TestableBrowserStateMonitor monitor(&mock_manager);
+  monitor.SetPrefServiceForTesting(&prefs);
+
+  EXPECT_EQ(InputMethodManager::STATE_LOGIN_SCREEN, monitor.state());
+  std::string input_method_id = "xkb:us:dvorak:eng";
+  mock_manager.SetCurrentInputMethodId(input_method_id);
+  monitor.InputMethodChanged(&mock_manager);
+  EXPECT_EQ(1, monitor.update_local_state_count());
+  EXPECT_EQ(0, monitor.update_user_pref_count());
+  EXPECT_EQ(input_method_id, monitor.last_local_state());
+  input_method_id = "xkb:us:colemak:eng";
+  mock_manager.SetCurrentInputMethodId(input_method_id);
+  monitor.InputMethodChanged(&mock_manager);
+  EXPECT_EQ(2, monitor.update_local_state_count());
+  EXPECT_EQ(0, monitor.update_user_pref_count());
+  EXPECT_EQ(input_method_id, monitor.last_local_state());
+}
+
+TEST(BrowserStateMonitorTest, TestUpdatePrefOnBrowserScreenDetails) {
+  TestingPrefService prefs;
+  RegisterTestPrefs(&prefs);
+  MockInputMethodManager mock_manager;
+  TestableBrowserStateMonitor monitor(&mock_manager);
+  monitor.SetPrefServiceForTesting(&prefs);
+
+  StringPrefMember previous;
+  previous.Init(prefs::kLanguagePreviousInputMethod, &prefs, NULL);
+  EXPECT_EQ("", previous.GetValue());
+  StringPrefMember current;
+  current.Init(prefs::kLanguageCurrentInputMethod, &prefs, NULL);
+  EXPECT_EQ("", current.GetValue());
+
+  monitor.Observe(chrome::NOTIFICATION_LOGIN_USER_CHANGED,
+                  content::NotificationService::AllSources(),
+                  content::NotificationService::NoDetails());
+  EXPECT_EQ(InputMethodManager::STATE_BROWSER_SCREEN, monitor.state());
+  monitor.Observe(chrome::NOTIFICATION_SESSION_STARTED,
+                  content::NotificationService::AllSources(),
+                  content::NotificationService::NoDetails());
+  EXPECT_EQ(InputMethodManager::STATE_BROWSER_SCREEN, monitor.state());
+
+  const std::string input_method_id = "xkb:us:dvorak:eng";
+  mock_manager.SetCurrentInputMethodId(input_method_id);
+  monitor.InputMethodChanged(&mock_manager);
+  EXPECT_EQ(0, monitor.update_local_state_count());
+  EXPECT_EQ(1, monitor.update_user_pref_count());
+  EXPECT_EQ(input_method_id, monitor.last_user_pref());
+  EXPECT_EQ("", previous.GetValue());
+  EXPECT_EQ(input_method_id, current.GetValue());
+
+  monitor.InputMethodChanged(&mock_manager);
+  EXPECT_EQ(0, monitor.update_local_state_count());
+  EXPECT_EQ(2, monitor.update_user_pref_count());
+  EXPECT_EQ(input_method_id, monitor.last_user_pref());
+  EXPECT_EQ("", previous.GetValue());
+  EXPECT_EQ(input_method_id, current.GetValue());
+
+  const std::string input_method_id_2 = "xkb:us:colemak:eng";
+  mock_manager.SetCurrentInputMethodId(input_method_id_2);
+  monitor.InputMethodChanged(&mock_manager);
+  EXPECT_EQ(0, monitor.update_local_state_count());
+  EXPECT_EQ(3, monitor.update_user_pref_count());
+  EXPECT_EQ(input_method_id_2, monitor.last_user_pref());
+  EXPECT_EQ(input_method_id, previous.GetValue());
+  EXPECT_EQ(input_method_id_2, current.GetValue());
+
+  const std::string input_method_id_3 = "xkb:us::eng";
+  mock_manager.SetCurrentInputMethodId(input_method_id_3);
+  monitor.InputMethodChanged(&mock_manager);
+  EXPECT_EQ(0, monitor.update_local_state_count());
+  EXPECT_EQ(4, monitor.update_user_pref_count());
+  EXPECT_EQ(input_method_id_3, monitor.last_user_pref());
+  EXPECT_EQ(input_method_id_2, previous.GetValue());
+  EXPECT_EQ(input_method_id_3, current.GetValue());
+
+  monitor.InputMethodChanged(&mock_manager);
+  EXPECT_EQ(0, monitor.update_local_state_count());
+  EXPECT_EQ(5, monitor.update_user_pref_count());
+  EXPECT_EQ(input_method_id_3, monitor.last_user_pref());
+  EXPECT_EQ(input_method_id_2, previous.GetValue());
+  EXPECT_EQ(input_method_id_3, current.GetValue());
+}
+
+}  // namespace input_method
+}  // namespace chromeos