| OLD | NEW |
|---|
| (Empty) |
| 1 // Copyright 2016 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 "components/mus/ws/user_activity_monitor.h" | |
| 6 | |
| 7 #include "base/message_loop/message_loop.h" | |
| 8 #include "base/run_loop.h" | |
| 9 #include "base/test/simple_test_tick_clock.h" | |
| 10 #include "base/test/test_mock_time_task_runner.h" | |
| 11 #include "components/mus/ws/test_utils.h" | |
| 12 #include "mojo/public/cpp/bindings/interface_request.h" | |
| 13 #include "testing/gtest/include/gtest/gtest.h" | |
| 14 | |
| 15 using mus::mojom::UserIdleObserver; | |
| 16 | |
| 17 namespace mus { | |
| 18 namespace ws { | |
| 19 namespace test { | |
| 20 | |
| 21 class TestUserActivityObserver : public mojom::UserActivityObserver { | |
| 22 public: | |
| 23 TestUserActivityObserver() : binding_(this) {} | |
| 24 ~TestUserActivityObserver() override {} | |
| 25 | |
| 26 mojom::UserActivityObserverPtr GetPtr() { | |
| 27 return binding_.CreateInterfacePtrAndBind(); | |
| 28 } | |
| 29 | |
| 30 bool GetAndResetReceivedUserActivity() { | |
| 31 bool val = received_user_activity_; | |
| 32 received_user_activity_ = false; | |
| 33 return val; | |
| 34 } | |
| 35 | |
| 36 private: | |
| 37 // mojom::UserActivityObserver: | |
| 38 void OnUserActivity() override { received_user_activity_ = true; } | |
| 39 | |
| 40 mojo::Binding<mojom::UserActivityObserver> binding_; | |
| 41 bool received_user_activity_ = false; | |
| 42 | |
| 43 DISALLOW_COPY_AND_ASSIGN(TestUserActivityObserver); | |
| 44 }; | |
| 45 | |
| 46 class TestUserIdleObserver : public mojom::UserIdleObserver { | |
| 47 public: | |
| 48 TestUserIdleObserver() : binding_(this) {} | |
| 49 ~TestUserIdleObserver() override {} | |
| 50 | |
| 51 mojom::UserIdleObserverPtr GetPtr() { | |
| 52 return binding_.CreateInterfacePtrAndBind(); | |
| 53 } | |
| 54 | |
| 55 bool GetAndResetIdleState(UserIdleObserver::IdleState* state) { | |
| 56 if (!received_idle_state_) | |
| 57 return false; | |
| 58 received_idle_state_ = false; | |
| 59 *state = idle_state_; | |
| 60 return true; | |
| 61 } | |
| 62 | |
| 63 private: | |
| 64 // mojom::UserIdleObserver: | |
| 65 void OnUserIdleStateChanged(UserIdleObserver::IdleState new_state) override { | |
| 66 received_idle_state_ = true; | |
| 67 idle_state_ = new_state; | |
| 68 } | |
| 69 | |
| 70 mojo::Binding<mojom::UserIdleObserver> binding_; | |
| 71 bool received_idle_state_ = false; | |
| 72 UserIdleObserver::IdleState idle_state_ = UserIdleObserver::IdleState::ACTIVE; | |
| 73 | |
| 74 DISALLOW_COPY_AND_ASSIGN(TestUserIdleObserver); | |
| 75 }; | |
| 76 | |
| 77 class UserActivityMonitorTest : public testing::Test { | |
| 78 public: | |
| 79 UserActivityMonitorTest() {} | |
| 80 ~UserActivityMonitorTest() override {} | |
| 81 | |
| 82 UserActivityMonitor* monitor() { return monitor_.get(); } | |
| 83 | |
| 84 void FastForwardBy(base::TimeDelta delta) { | |
| 85 task_runner_->FastForwardBy(delta); | |
| 86 } | |
| 87 void RunUntilIdle() { task_runner_->RunUntilIdle(); } | |
| 88 | |
| 89 private: | |
| 90 // testing::Test: | |
| 91 void SetUp() override { | |
| 92 task_runner_ = make_scoped_refptr(new base::TestMockTimeTaskRunner( | |
| 93 base::Time::Now(), base::TimeTicks::Now())); | |
| 94 message_loop_.SetTaskRunner(task_runner_); | |
| 95 monitor_.reset(new UserActivityMonitor(task_runner_->GetMockTickClock())); | |
| 96 } | |
| 97 | |
| 98 base::MessageLoop message_loop_; | |
| 99 scoped_refptr<base::TestMockTimeTaskRunner> task_runner_; | |
| 100 std::unique_ptr<UserActivityMonitor> monitor_; | |
| 101 | |
| 102 DISALLOW_COPY_AND_ASSIGN(UserActivityMonitorTest); | |
| 103 }; | |
| 104 | |
| 105 TEST_F(UserActivityMonitorTest, UserActivityObserver) { | |
| 106 TestUserActivityObserver first_observer, second_observer; | |
| 107 monitor()->AddUserActivityObserver(3, first_observer.GetPtr()); | |
| 108 monitor()->AddUserActivityObserver(4, second_observer.GetPtr()); | |
| 109 | |
| 110 // The first activity should notify both observers. | |
| 111 monitor()->OnUserActivity(); | |
| 112 RunUntilIdle(); | |
| 113 EXPECT_TRUE(first_observer.GetAndResetReceivedUserActivity()); | |
| 114 EXPECT_TRUE(second_observer.GetAndResetReceivedUserActivity()); | |
| 115 | |
| 116 // The next activity after just one second should not notify either observer. | |
| 117 FastForwardBy(base::TimeDelta::FromSeconds(1)); | |
| 118 monitor()->OnUserActivity(); | |
| 119 RunUntilIdle(); | |
| 120 EXPECT_FALSE(first_observer.GetAndResetReceivedUserActivity()); | |
| 121 EXPECT_FALSE(second_observer.GetAndResetReceivedUserActivity()); | |
| 122 | |
| 123 FastForwardBy(base::TimeDelta::FromMilliseconds(2001)); | |
| 124 monitor()->OnUserActivity(); | |
| 125 RunUntilIdle(); | |
| 126 EXPECT_TRUE(first_observer.GetAndResetReceivedUserActivity()); | |
| 127 EXPECT_FALSE(second_observer.GetAndResetReceivedUserActivity()); | |
| 128 | |
| 129 FastForwardBy(base::TimeDelta::FromSeconds(1)); | |
| 130 monitor()->OnUserActivity(); | |
| 131 RunUntilIdle(); | |
| 132 EXPECT_FALSE(first_observer.GetAndResetReceivedUserActivity()); | |
| 133 EXPECT_TRUE(second_observer.GetAndResetReceivedUserActivity()); | |
| 134 } | |
| 135 | |
| 136 // Tests that idleness observers receive the correct notification upon | |
| 137 // connection. | |
| 138 TEST_F(UserActivityMonitorTest, UserIdleObserverConnectNotification) { | |
| 139 UserIdleObserver::IdleState idle_state; | |
| 140 | |
| 141 // If an observer is added without any user activity, then it still receives | |
| 142 // an ACTIVE notification immediately. | |
| 143 TestUserIdleObserver first_observer; | |
| 144 monitor()->AddUserIdleObserver(1, first_observer.GetPtr()); | |
| 145 RunUntilIdle(); | |
| 146 EXPECT_TRUE(first_observer.GetAndResetIdleState(&idle_state)); | |
| 147 EXPECT_EQ(UserIdleObserver::IdleState::ACTIVE, idle_state); | |
| 148 | |
| 149 // If an observer is added without any user activity and the system has been | |
| 150 // idle, then the observer receives an IDLE notification immediately. | |
| 151 FastForwardBy(base::TimeDelta::FromMinutes(5)); | |
| 152 TestUserIdleObserver second_observer; | |
| 153 monitor()->AddUserIdleObserver(4, second_observer.GetPtr()); | |
| 154 RunUntilIdle(); | |
| 155 EXPECT_TRUE(second_observer.GetAndResetIdleState(&idle_state)); | |
| 156 EXPECT_EQ(UserIdleObserver::IdleState::IDLE, idle_state); | |
| 157 EXPECT_TRUE(first_observer.GetAndResetIdleState(&idle_state)); | |
| 158 EXPECT_EQ(UserIdleObserver::IdleState::IDLE, idle_state); | |
| 159 | |
| 160 // If an observer is added after some user activity, then it receives an | |
| 161 // immediate ACTIVE notification. | |
| 162 monitor()->OnUserActivity(); | |
| 163 TestUserIdleObserver third_observer; | |
| 164 monitor()->AddUserIdleObserver(1, third_observer.GetPtr()); | |
| 165 RunUntilIdle(); | |
| 166 EXPECT_TRUE(third_observer.GetAndResetIdleState(&idle_state)); | |
| 167 EXPECT_EQ(UserIdleObserver::IdleState::ACTIVE, idle_state); | |
| 168 EXPECT_TRUE(second_observer.GetAndResetIdleState(&idle_state)); | |
| 169 EXPECT_EQ(UserIdleObserver::IdleState::ACTIVE, idle_state); | |
| 170 EXPECT_TRUE(first_observer.GetAndResetIdleState(&idle_state)); | |
| 171 EXPECT_EQ(UserIdleObserver::IdleState::ACTIVE, idle_state); | |
| 172 | |
| 173 FastForwardBy(base::TimeDelta::FromMinutes(10)); | |
| 174 TestUserIdleObserver fourth_observer; | |
| 175 monitor()->AddUserIdleObserver(1, fourth_observer.GetPtr()); | |
| 176 RunUntilIdle(); | |
| 177 EXPECT_TRUE(fourth_observer.GetAndResetIdleState(&idle_state)); | |
| 178 EXPECT_EQ(UserIdleObserver::IdleState::IDLE, idle_state); | |
| 179 EXPECT_TRUE(third_observer.GetAndResetIdleState(&idle_state)); | |
| 180 EXPECT_EQ(UserIdleObserver::IdleState::IDLE, idle_state); | |
| 181 EXPECT_TRUE(second_observer.GetAndResetIdleState(&idle_state)); | |
| 182 EXPECT_EQ(UserIdleObserver::IdleState::IDLE, idle_state); | |
| 183 EXPECT_TRUE(first_observer.GetAndResetIdleState(&idle_state)); | |
| 184 EXPECT_EQ(UserIdleObserver::IdleState::IDLE, idle_state); | |
| 185 | |
| 186 // All observers are idle. These should not receive any IDLE notifications as | |
| 187 // more time passes by. | |
| 188 FastForwardBy(base::TimeDelta::FromMinutes(100)); | |
| 189 RunUntilIdle(); | |
| 190 EXPECT_FALSE(first_observer.GetAndResetIdleState(&idle_state)); | |
| 191 EXPECT_FALSE(second_observer.GetAndResetIdleState(&idle_state)); | |
| 192 EXPECT_FALSE(third_observer.GetAndResetIdleState(&idle_state)); | |
| 193 EXPECT_FALSE(fourth_observer.GetAndResetIdleState(&idle_state)); | |
| 194 | |
| 195 // Some activity would notify ACTIVE to all observers. | |
| 196 monitor()->OnUserActivity(); | |
| 197 RunUntilIdle(); | |
| 198 EXPECT_TRUE(fourth_observer.GetAndResetIdleState(&idle_state)); | |
| 199 EXPECT_EQ(UserIdleObserver::IdleState::ACTIVE, idle_state); | |
| 200 EXPECT_TRUE(third_observer.GetAndResetIdleState(&idle_state)); | |
| 201 EXPECT_EQ(UserIdleObserver::IdleState::ACTIVE, idle_state); | |
| 202 EXPECT_TRUE(second_observer.GetAndResetIdleState(&idle_state)); | |
| 203 EXPECT_EQ(UserIdleObserver::IdleState::ACTIVE, idle_state); | |
| 204 EXPECT_TRUE(first_observer.GetAndResetIdleState(&idle_state)); | |
| 205 EXPECT_EQ(UserIdleObserver::IdleState::ACTIVE, idle_state); | |
| 206 | |
| 207 // Yet more activity should not send any notifications. | |
| 208 monitor()->OnUserActivity(); | |
| 209 RunUntilIdle(); | |
| 210 EXPECT_FALSE(first_observer.GetAndResetIdleState(&idle_state)); | |
| 211 EXPECT_FALSE(second_observer.GetAndResetIdleState(&idle_state)); | |
| 212 EXPECT_FALSE(third_observer.GetAndResetIdleState(&idle_state)); | |
| 213 EXPECT_FALSE(fourth_observer.GetAndResetIdleState(&idle_state)); | |
| 214 } | |
| 215 | |
| 216 } // namespace test | |
| 217 } // namespace ws | |
| 218 } // namespace mus | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 2119963002:
Move mus to //services/ui (Closed)
Base URL: https://chromium.googlesource.com/chromium/src.git@master