1// Copyright (c) 2012 The Chromium Authors. All rights reserved.
2// Use of this source code is governed by a BSD-style license that can be
3// found in the LICENSE file.
4
5#include "chrome/browser/chromeos/input_method/browser_state_monitor.h"
6
7#include <string>
8
9#include "base/basictypes.h"
10#include "base/bind.h"
11#include "chrome/browser/chrome_notification_types.h"
12#include "content/public/browser/notification_details.h"
13#include "content/public/browser/notification_service.h"
14#include "testing/gtest/include/gtest/gtest.h"
15
16namespace chromeos {
17namespace input_method {
18namespace {
19
20class MockObserver {
21 public:
22  MockObserver()
23      : ui_session_(InputMethodManager::STATE_TERMINATING),
24        update_ui_session_count_(0) {}
25
26  void SetState(InputMethodManager::UISessionState new_ui_session) {
27    ++update_ui_session_count_;
28    ui_session_ = new_ui_session;
29  }
30
31  base::Callback<void(InputMethodManager::UISessionState new_ui_session)>
32  AsCallback() {
33    return base::Bind(&MockObserver::SetState, base::Unretained(this));
34  }
35
36  int update_ui_session_count() const { return update_ui_session_count_; }
37
38  InputMethodManager::UISessionState ui_session() const { return ui_session_; }
39
40 private:
41  InputMethodManager::UISessionState ui_session_;
42  int update_ui_session_count_;
43
44  DISALLOW_COPY_AND_ASSIGN(MockObserver);
45};
46
47}  // anonymous namespace
48
49TEST(BrowserStateMonitorLifetimeTest, TestConstruction) {
50  MockObserver mock_observer;
51  BrowserStateMonitor monitor(mock_observer.AsCallback());
52
53  // Check the initial ui_session_ of the |mock_observer| and |monitor| objects.
54  EXPECT_EQ(1, mock_observer.update_ui_session_count());
55  EXPECT_EQ(InputMethodManager::STATE_LOGIN_SCREEN, mock_observer.ui_session());
56  EXPECT_EQ(InputMethodManager::STATE_LOGIN_SCREEN, monitor.ui_session());
57}
58
59namespace {
60
61class BrowserStateMonitorTest :  public testing::Test {
62 public:
63  BrowserStateMonitorTest()
64      : monitor_(mock_observer_.AsCallback()) {
65  }
66
67 protected:
68  MockObserver mock_observer_;
69  BrowserStateMonitor monitor_;
70
71 private:
72  DISALLOW_COPY_AND_ASSIGN(BrowserStateMonitorTest);
73};
74
75}  // anonymous namespace
76
77TEST_F(BrowserStateMonitorTest, TestObserveLoginUserChanged) {
78  EXPECT_EQ(1, mock_observer_.update_ui_session_count());
79  monitor_.Observe(chrome::NOTIFICATION_LOGIN_USER_CHANGED,
80                   content::NotificationService::AllSources(),
81                   content::NotificationService::NoDetails());
82
83  // Check if the ui_session of the |mock_observer_| as well as the |monitor|
84  // are
85  // both changed.
86  EXPECT_EQ(2, mock_observer_.update_ui_session_count());
87  EXPECT_EQ(InputMethodManager::STATE_BROWSER_SCREEN,
88            mock_observer_.ui_session());
89  EXPECT_EQ(InputMethodManager::STATE_BROWSER_SCREEN, monitor_.ui_session());
90}
91
92TEST_F(BrowserStateMonitorTest, TestObserveSessionStarted) {
93  EXPECT_EQ(1, mock_observer_.update_ui_session_count());
94  monitor_.Observe(chrome::NOTIFICATION_SESSION_STARTED,
95                   content::NotificationService::AllSources(),
96                   content::NotificationService::NoDetails());
97
98  // Check if the state of the |mock_observer_| as well as the |monitor| are
99  // both changed.
100  EXPECT_EQ(2, mock_observer_.update_ui_session_count());
101  EXPECT_EQ(InputMethodManager::STATE_BROWSER_SCREEN,
102            mock_observer_.ui_session());
103  EXPECT_EQ(InputMethodManager::STATE_BROWSER_SCREEN, monitor_.ui_session());
104}
105
106TEST_F(BrowserStateMonitorTest, TestObserveLoginUserChangedThenSessionStarted) {
107  EXPECT_EQ(1, mock_observer_.update_ui_session_count());
108  monitor_.Observe(chrome::NOTIFICATION_LOGIN_USER_CHANGED,
109                   content::NotificationService::AllSources(),
110                   content::NotificationService::NoDetails());
111
112  // Check if the state of the |mock_observer_| as well as the |monitor| are
113  // both changed.
114  EXPECT_EQ(2, mock_observer_.update_ui_session_count());
115  EXPECT_EQ(InputMethodManager::STATE_BROWSER_SCREEN,
116            mock_observer_.ui_session());
117  EXPECT_EQ(InputMethodManager::STATE_BROWSER_SCREEN, monitor_.ui_session());
118
119  monitor_.Observe(chrome::NOTIFICATION_SESSION_STARTED,
120                   content::NotificationService::AllSources(),
121                   content::NotificationService::NoDetails());
122
123  // The second notification should be nop.
124  EXPECT_EQ(2, mock_observer_.update_ui_session_count());
125  EXPECT_EQ(InputMethodManager::STATE_BROWSER_SCREEN,
126            mock_observer_.ui_session());
127  EXPECT_EQ(InputMethodManager::STATE_BROWSER_SCREEN, monitor_.ui_session());
128}
129
130TEST_F(BrowserStateMonitorTest, TestObserveScreenLockUnlock) {
131  EXPECT_EQ(1, mock_observer_.update_ui_session_count());
132  monitor_.Observe(chrome::NOTIFICATION_LOGIN_USER_CHANGED,
133                   content::NotificationService::AllSources(),
134                   content::NotificationService::NoDetails());
135  EXPECT_EQ(2, mock_observer_.update_ui_session_count());
136  monitor_.Observe(chrome::NOTIFICATION_SESSION_STARTED,
137                   content::NotificationService::AllSources(),
138                   content::NotificationService::NoDetails());
139  EXPECT_EQ(2, mock_observer_.update_ui_session_count());
140  bool locked = true;
141  monitor_.Observe(chrome::NOTIFICATION_SCREEN_LOCK_STATE_CHANGED,
142                   content::NotificationService::AllSources(),
143                   content::Details<bool>(&locked));
144  EXPECT_EQ(3, mock_observer_.update_ui_session_count());
145  EXPECT_EQ(InputMethodManager::STATE_LOCK_SCREEN, mock_observer_.ui_session());
146  EXPECT_EQ(InputMethodManager::STATE_LOCK_SCREEN, monitor_.ui_session());
147
148  locked = false;
149  monitor_.Observe(chrome::NOTIFICATION_SCREEN_LOCK_STATE_CHANGED,
150                   content::NotificationService::AllSources(),
151                   content::Details<bool>(&locked));
152  EXPECT_EQ(4, mock_observer_.update_ui_session_count());
153  EXPECT_EQ(InputMethodManager::STATE_BROWSER_SCREEN,
154            mock_observer_.ui_session());
155  EXPECT_EQ(InputMethodManager::STATE_BROWSER_SCREEN, monitor_.ui_session());
156}
157
158TEST_F(BrowserStateMonitorTest, TestObserveAppTerminating) {
159  EXPECT_EQ(1, mock_observer_.update_ui_session_count());
160  monitor_.Observe(chrome::NOTIFICATION_APP_TERMINATING,
161                   content::NotificationService::AllSources(),
162                   content::NotificationService::NoDetails());
163
164  // Check if the state of the |mock_observer_| as well as the |monitor| are
165  // both changed.
166  EXPECT_EQ(2, mock_observer_.update_ui_session_count());
167  EXPECT_EQ(InputMethodManager::STATE_TERMINATING, mock_observer_.ui_session());
168  EXPECT_EQ(InputMethodManager::STATE_TERMINATING, monitor_.ui_session());
169}
170
171}  // namespace input_method
172}  // namespace chromeos
173