OLD | NEW |
1 // Copyright 2017 The Chromium Authors. All rights reserved. | 1 // Copyright 2017 The Chromium Authors. All rights reserved. |
2 // Use of this source code is governed by a BSD-style license that can be | 2 // Use of this source code is governed by a BSD-style license that can be |
3 // found in the LICENSE file. | 3 // found in the LICENSE file. |
4 | 4 |
5 #include "chrome/browser/chromeos/lock_screen_apps/state_controller.h" | 5 #include "chrome/browser/chromeos/lock_screen_apps/state_controller.h" |
6 | 6 |
7 #include <memory> | 7 #include <memory> |
| 8 #include <string> |
8 #include <utility> | 9 #include <utility> |
9 #include <vector> | 10 #include <vector> |
10 | 11 |
11 #include "ash/public/interfaces/tray_action.mojom.h" | 12 #include "ash/public/interfaces/tray_action.mojom.h" |
| 13 #include "base/files/file_path.h" |
12 #include "base/memory/ptr_util.h" | 14 #include "base/memory/ptr_util.h" |
13 #include "base/run_loop.h" | 15 #include "base/run_loop.h" |
14 #include "base/test/scoped_command_line.h" | 16 #include "base/test/scoped_command_line.h" |
| 17 #include "chrome/browser/chromeos/lock_screen_apps/app_manager.h" |
15 #include "chrome/browser/chromeos/lock_screen_apps/state_observer.h" | 18 #include "chrome/browser/chromeos/lock_screen_apps/state_observer.h" |
| 19 #include "chrome/common/chrome_constants.h" |
| 20 #include "chrome/test/base/testing_browser_process.h" |
| 21 #include "chrome/test/base/testing_profile.h" |
| 22 #include "chrome/test/base/testing_profile_manager.h" |
| 23 #include "components/session_manager/core/session_manager.h" |
16 #include "content/public/test/test_browser_thread_bundle.h" | 24 #include "content/public/test/test_browser_thread_bundle.h" |
17 #include "testing/gtest/include/gtest/gtest.h" | 25 #include "testing/gtest/include/gtest/gtest.h" |
18 | 26 |
19 using ash::mojom::TrayActionState; | 27 using ash::mojom::TrayActionState; |
20 | 28 |
21 namespace { | 29 namespace { |
22 | 30 |
| 31 class TestAppManager : public lock_screen_apps::AppManager { |
| 32 public: |
| 33 enum class State { |
| 34 kNotInitialized, |
| 35 kStarted, |
| 36 kStopped, |
| 37 }; |
| 38 |
| 39 TestAppManager(Profile* expected_primary_profile, |
| 40 Profile* expected_lock_screen_profile) |
| 41 : expected_primary_profile_(expected_primary_profile), |
| 42 expected_lock_screen_profile_(expected_lock_screen_profile) {} |
| 43 |
| 44 ~TestAppManager() override = default; |
| 45 |
| 46 void Initialize(Profile* primary_profile, |
| 47 Profile* lock_screen_profile) override { |
| 48 ASSERT_EQ(State::kNotInitialized, state_); |
| 49 ASSERT_EQ(expected_primary_profile_, primary_profile); |
| 50 ASSERT_EQ(expected_lock_screen_profile_, lock_screen_profile); |
| 51 |
| 52 state_ = State::kStopped; |
| 53 } |
| 54 |
| 55 void Start(const base::Closure& change_callback) override { |
| 56 ASSERT_TRUE(change_callback_.is_null()); |
| 57 ASSERT_FALSE(change_callback.is_null()); |
| 58 change_callback_ = change_callback; |
| 59 state_ = State::kStarted; |
| 60 } |
| 61 |
| 62 void Stop() override { |
| 63 change_callback_.Reset(); |
| 64 state_ = State::kStopped; |
| 65 } |
| 66 |
| 67 bool LaunchNoteTaking() override { |
| 68 EXPECT_EQ(State::kStarted, state_); |
| 69 ++launch_count_; |
| 70 return app_launchable_; |
| 71 } |
| 72 |
| 73 bool IsNoteTakingAppAvailable() const override { |
| 74 return state_ == State::kStarted && !app_id_.empty(); |
| 75 } |
| 76 |
| 77 std::string GetNoteTakingAppId() const override { |
| 78 if (state_ != State::kStarted) |
| 79 return std::string(); |
| 80 return app_id_; |
| 81 } |
| 82 |
| 83 void SetInitialAppState(const std::string& app_id, bool app_launchable) { |
| 84 ASSERT_NE(State::kStarted, state_); |
| 85 |
| 86 app_launchable_ = app_launchable; |
| 87 app_id_ = app_id; |
| 88 } |
| 89 |
| 90 void UpdateApp(const std::string& app_id, bool app_launchable) { |
| 91 ASSERT_EQ(State::kStarted, state_); |
| 92 |
| 93 app_launchable_ = app_launchable; |
| 94 if (app_id == app_id_) |
| 95 return; |
| 96 app_id_ = app_id; |
| 97 |
| 98 change_callback_.Run(); |
| 99 } |
| 100 |
| 101 State state() const { return state_; } |
| 102 |
| 103 int launch_count() const { return launch_count_; } |
| 104 |
| 105 private: |
| 106 const Profile* const expected_primary_profile_; |
| 107 const Profile* const expected_lock_screen_profile_; |
| 108 |
| 109 base::Closure change_callback_; |
| 110 |
| 111 State state_ = State::kNotInitialized; |
| 112 |
| 113 // Number of requested app launches. |
| 114 int launch_count_ = 0; |
| 115 |
| 116 // Information about the test app: |
| 117 // The app ID. |
| 118 std::string app_id_; |
| 119 // Whether app launch should succeed. |
| 120 bool app_launchable_ = false; |
| 121 |
| 122 DISALLOW_COPY_AND_ASSIGN(TestAppManager); |
| 123 }; |
| 124 |
23 class TestStateObserver : public lock_screen_apps::StateObserver { | 125 class TestStateObserver : public lock_screen_apps::StateObserver { |
24 public: | 126 public: |
25 TestStateObserver() = default; | 127 TestStateObserver() = default; |
26 ~TestStateObserver() override = default; | 128 ~TestStateObserver() override = default; |
27 | 129 |
28 void OnLockScreenNoteStateChanged(TrayActionState state) override { | 130 void OnLockScreenNoteStateChanged(TrayActionState state) override { |
29 observed_states_.push_back(state); | 131 observed_states_.push_back(state); |
30 } | 132 } |
31 | 133 |
32 const std::vector<TrayActionState> observed_states() const { | 134 const std::vector<TrayActionState>& observed_states() const { |
33 return observed_states_; | 135 return observed_states_; |
34 } | 136 } |
35 | 137 |
36 void ClearObservedStates() { observed_states_.clear(); } | 138 void ClearObservedStates() { observed_states_.clear(); } |
37 | 139 |
38 private: | 140 private: |
39 std::vector<TrayActionState> observed_states_; | 141 std::vector<TrayActionState> observed_states_; |
40 | 142 |
41 DISALLOW_COPY_AND_ASSIGN(TestStateObserver); | 143 DISALLOW_COPY_AND_ASSIGN(TestStateObserver); |
42 }; | 144 }; |
(...skipping 50 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
93 } | 195 } |
94 | 196 |
95 private: | 197 private: |
96 std::unique_ptr<base::test::ScopedCommandLine> command_line_; | 198 std::unique_ptr<base::test::ScopedCommandLine> command_line_; |
97 | 199 |
98 DISALLOW_COPY_AND_ASSIGN(LockScreenAppStateNotSupportedTest); | 200 DISALLOW_COPY_AND_ASSIGN(LockScreenAppStateNotSupportedTest); |
99 }; | 201 }; |
100 | 202 |
101 class LockScreenAppStateTest : public testing::Test { | 203 class LockScreenAppStateTest : public testing::Test { |
102 public: | 204 public: |
103 LockScreenAppStateTest() = default; | 205 LockScreenAppStateTest() |
| 206 : profile_manager_(TestingBrowserProcess::GetGlobal()) {} |
104 ~LockScreenAppStateTest() override = default; | 207 ~LockScreenAppStateTest() override = default; |
105 | 208 |
106 void SetUp() override { | 209 void SetUp() override { |
107 command_line_ = base::MakeUnique<base::test::ScopedCommandLine>(); | 210 command_line_ = base::MakeUnique<base::test::ScopedCommandLine>(); |
108 command_line_->GetProcessCommandLine()->InitFromArgv( | 211 command_line_->GetProcessCommandLine()->InitFromArgv( |
109 {"", "--enable-lock-screen-apps"}); | 212 {"", "--enable-lock-screen-apps"}); |
110 | 213 |
| 214 ASSERT_TRUE(profile_manager_.SetUp()); |
| 215 |
| 216 session_manager_ = base::MakeUnique<session_manager::SessionManager>(); |
| 217 session_manager_->SetSessionState( |
| 218 session_manager::SessionState::LOGIN_PRIMARY); |
| 219 |
111 ASSERT_TRUE(lock_screen_apps::StateController::IsEnabled()); | 220 ASSERT_TRUE(lock_screen_apps::StateController::IsEnabled()); |
112 | 221 |
113 state_controller_ = base::MakeUnique<lock_screen_apps::StateController>(); | 222 state_controller_ = base::MakeUnique<lock_screen_apps::StateController>(); |
114 state_controller_->SetTrayActionPtrForTesting( | 223 state_controller_->SetTrayActionPtrForTesting( |
115 tray_action_.CreateInterfacePtrAndBind()); | 224 tray_action_.CreateInterfacePtrAndBind()); |
116 state_controller_->Initialize(); | 225 state_controller_->Initialize(); |
117 state_controller_->FlushTrayActionForTesting(); | 226 state_controller_->FlushTrayActionForTesting(); |
118 | 227 |
119 state_controller_->AddObserver(&observer_); | 228 state_controller_->AddObserver(&observer_); |
| 229 |
| 230 // Create fake sign-in profile. |
| 231 TestingProfile::Builder builder; |
| 232 builder.SetPath( |
| 233 profile_manager_.profiles_dir().AppendASCII(chrome::kInitialProfile)); |
| 234 TestingProfile* signin_profile = builder.BuildIncognito( |
| 235 profile_manager_.CreateTestingProfile(chrome::kInitialProfile)); |
| 236 |
| 237 std::unique_ptr<TestAppManager> app_manager = |
| 238 base::MakeUnique<TestAppManager>(&profile_, signin_profile); |
| 239 app_manager_ = app_manager.get(); |
| 240 state_controller_->SetAppManagerForTesting(std::move(app_manager)); |
120 } | 241 } |
121 | 242 |
122 void TearDown() override { | 243 void TearDown() override { |
123 state_controller_->RemoveObserver(&observer_); | 244 state_controller_->RemoveObserver(&observer_); |
124 state_controller_.reset(); | 245 state_controller_.reset(); |
| 246 session_manager_.reset(); |
| 247 app_manager_ = nullptr; |
| 248 } |
| 249 |
| 250 // Helper method to move state controller to available state. |
| 251 // Should be called at the begining of tests, at most once. |
| 252 bool EnableNoteTakingApp(bool enable_app_launch) { |
| 253 app_manager_->SetInitialAppState("test_app_id", enable_app_launch); |
| 254 state_controller_->SetPrimaryProfile(&profile_); |
| 255 session_manager_->SetSessionState(session_manager::SessionState::LOCKED); |
| 256 if (app_manager_->state() != TestAppManager::State::kStarted) { |
| 257 ADD_FAILURE() << "Lock app manager Start not invoked."; |
| 258 return false; |
| 259 } |
| 260 state_controller_->FlushTrayActionForTesting(); |
| 261 |
| 262 observer_.ClearObservedStates(); |
| 263 tray_action_.ClearObservedStates(); |
| 264 |
| 265 return state_controller_->GetLockScreenNoteState() == |
| 266 TrayActionState::kAvailable; |
| 267 } |
| 268 |
| 269 TestingProfile* profile() { return &profile_; } |
| 270 |
| 271 session_manager::SessionManager* session_manager() { |
| 272 return session_manager_.get(); |
125 } | 273 } |
126 | 274 |
127 TestStateObserver* observer() { return &observer_; } | 275 TestStateObserver* observer() { return &observer_; } |
128 | 276 |
129 TestTrayAction* tray_action() { return &tray_action_; } | 277 TestTrayAction* tray_action() { return &tray_action_; } |
130 | 278 |
131 lock_screen_apps::StateController* state_controller() { | 279 lock_screen_apps::StateController* state_controller() { |
132 return state_controller_.get(); | 280 return state_controller_.get(); |
133 } | 281 } |
134 | 282 |
| 283 TestAppManager* app_manager() { return app_manager_; } |
| 284 |
135 private: | 285 private: |
136 std::unique_ptr<base::test::ScopedCommandLine> command_line_; | 286 std::unique_ptr<base::test::ScopedCommandLine> command_line_; |
137 content::TestBrowserThreadBundle threads_; | 287 content::TestBrowserThreadBundle threads_; |
| 288 TestingProfileManager profile_manager_; |
| 289 TestingProfile profile_; |
| 290 |
| 291 std::unique_ptr<session_manager::SessionManager> session_manager_; |
138 | 292 |
139 std::unique_ptr<lock_screen_apps::StateController> state_controller_; | 293 std::unique_ptr<lock_screen_apps::StateController> state_controller_; |
| 294 |
140 TestStateObserver observer_; | 295 TestStateObserver observer_; |
141 TestTrayAction tray_action_; | 296 TestTrayAction tray_action_; |
| 297 TestAppManager* app_manager_ = nullptr; |
142 | 298 |
143 DISALLOW_COPY_AND_ASSIGN(LockScreenAppStateTest); | 299 DISALLOW_COPY_AND_ASSIGN(LockScreenAppStateTest); |
144 }; | 300 }; |
145 | 301 |
146 } // namespace | 302 } // namespace |
147 | 303 |
148 TEST_F(LockScreenAppStateNotSupportedTest, NoInstance) { | 304 TEST_F(LockScreenAppStateNotSupportedTest, NoInstance) { |
149 EXPECT_FALSE(lock_screen_apps::StateController::IsEnabled()); | 305 EXPECT_FALSE(lock_screen_apps::StateController::IsEnabled()); |
150 } | 306 } |
151 | 307 |
152 TEST_F(LockScreenAppStateTest, InitialState) { | 308 TEST_F(LockScreenAppStateTest, InitialState) { |
153 EXPECT_EQ(TrayActionState::kNotAvailable, | 309 EXPECT_EQ(TrayActionState::kNotAvailable, |
154 state_controller()->GetLockScreenNoteState()); | 310 state_controller()->GetLockScreenNoteState()); |
155 | 311 |
| 312 EXPECT_EQ(TestAppManager::State::kNotInitialized, app_manager()->state()); |
156 state_controller()->MoveToBackground(); | 313 state_controller()->MoveToBackground(); |
157 | 314 |
158 EXPECT_EQ(TrayActionState::kNotAvailable, | 315 EXPECT_EQ(TrayActionState::kNotAvailable, |
159 state_controller()->GetLockScreenNoteState()); | 316 state_controller()->GetLockScreenNoteState()); |
160 | 317 |
161 EXPECT_EQ(0u, observer()->observed_states().size()); | 318 EXPECT_EQ(0u, observer()->observed_states().size()); |
162 EXPECT_EQ(0u, tray_action()->observed_states().size()); | 319 EXPECT_EQ(0u, tray_action()->observed_states().size()); |
163 } | 320 } |
164 | 321 |
| 322 TEST_F(LockScreenAppStateTest, SetPrimaryProfile) { |
| 323 EXPECT_EQ(TestAppManager::State::kNotInitialized, app_manager()->state()); |
| 324 state_controller()->SetPrimaryProfile(profile()); |
| 325 |
| 326 EXPECT_EQ(TestAppManager::State::kStopped, app_manager()->state()); |
| 327 EXPECT_EQ(TrayActionState::kNotAvailable, |
| 328 state_controller()->GetLockScreenNoteState()); |
| 329 EXPECT_EQ(0u, observer()->observed_states().size()); |
| 330 } |
| 331 |
| 332 TEST_F(LockScreenAppStateTest, SetPrimaryProfileWhenSessionLocked) { |
| 333 session_manager()->SetSessionState(session_manager::SessionState::LOCKED); |
| 334 EXPECT_EQ(TrayActionState::kNotAvailable, |
| 335 state_controller()->GetLockScreenNoteState()); |
| 336 |
| 337 EXPECT_EQ(TestAppManager::State::kNotInitialized, app_manager()->state()); |
| 338 |
| 339 app_manager()->SetInitialAppState("app_id", true); |
| 340 state_controller()->SetPrimaryProfile(profile()); |
| 341 |
| 342 ASSERT_EQ(TestAppManager::State::kStarted, app_manager()->state()); |
| 343 |
| 344 EXPECT_EQ(TrayActionState::kAvailable, |
| 345 state_controller()->GetLockScreenNoteState()); |
| 346 |
| 347 state_controller()->FlushTrayActionForTesting(); |
| 348 ASSERT_EQ(1u, observer()->observed_states().size()); |
| 349 EXPECT_EQ(TrayActionState::kAvailable, observer()->observed_states()[0]); |
| 350 ASSERT_EQ(1u, tray_action()->observed_states().size()); |
| 351 EXPECT_EQ(TrayActionState::kAvailable, tray_action()->observed_states()[0]); |
| 352 } |
| 353 |
| 354 TEST_F(LockScreenAppStateTest, SessionLock) { |
| 355 app_manager()->SetInitialAppState("app_id", true); |
| 356 state_controller()->SetPrimaryProfile(profile()); |
| 357 ASSERT_EQ(TestAppManager::State::kStopped, app_manager()->state()); |
| 358 |
| 359 session_manager()->SetSessionState(session_manager::SessionState::LOCKED); |
| 360 |
| 361 ASSERT_EQ(TestAppManager::State::kStarted, app_manager()->state()); |
| 362 |
| 363 EXPECT_EQ(TrayActionState::kAvailable, |
| 364 state_controller()->GetLockScreenNoteState()); |
| 365 state_controller()->FlushTrayActionForTesting(); |
| 366 ASSERT_EQ(1u, observer()->observed_states().size()); |
| 367 EXPECT_EQ(TrayActionState::kAvailable, observer()->observed_states()[0]); |
| 368 observer()->ClearObservedStates(); |
| 369 ASSERT_EQ(1u, tray_action()->observed_states().size()); |
| 370 EXPECT_EQ(TrayActionState::kAvailable, tray_action()->observed_states()[0]); |
| 371 tray_action()->ClearObservedStates(); |
| 372 |
| 373 // When the session is unlocked again, app manager is stopped, and tray action |
| 374 // disabled again. |
| 375 session_manager()->SetSessionState(session_manager::SessionState::ACTIVE); |
| 376 |
| 377 EXPECT_EQ(TestAppManager::State::kStopped, app_manager()->state()); |
| 378 |
| 379 EXPECT_EQ(TrayActionState::kNotAvailable, |
| 380 state_controller()->GetLockScreenNoteState()); |
| 381 state_controller()->FlushTrayActionForTesting(); |
| 382 ASSERT_EQ(1u, observer()->observed_states().size()); |
| 383 EXPECT_EQ(TrayActionState::kNotAvailable, observer()->observed_states()[0]); |
| 384 observer()->ClearObservedStates(); |
| 385 ASSERT_EQ(1u, tray_action()->observed_states().size()); |
| 386 EXPECT_EQ(TrayActionState::kNotAvailable, |
| 387 tray_action()->observed_states()[0]); |
| 388 tray_action()->ClearObservedStates(); |
| 389 |
| 390 // Test that subsequent session lock works as expected. |
| 391 session_manager()->SetSessionState(session_manager::SessionState::LOCKED); |
| 392 ASSERT_EQ(TestAppManager::State::kStarted, app_manager()->state()); |
| 393 |
| 394 EXPECT_EQ(TrayActionState::kAvailable, |
| 395 state_controller()->GetLockScreenNoteState()); |
| 396 state_controller()->FlushTrayActionForTesting(); |
| 397 ASSERT_EQ(1u, observer()->observed_states().size()); |
| 398 EXPECT_EQ(TrayActionState::kAvailable, observer()->observed_states()[0]); |
| 399 ASSERT_EQ(1u, tray_action()->observed_states().size()); |
| 400 EXPECT_EQ(TrayActionState::kAvailable, tray_action()->observed_states()[0]); |
| 401 } |
| 402 |
| 403 TEST_F(LockScreenAppStateTest, SessionUnlockedWhileStartingAppManager) { |
| 404 state_controller()->SetPrimaryProfile(profile()); |
| 405 ASSERT_EQ(TestAppManager::State::kStopped, app_manager()->state()); |
| 406 |
| 407 session_manager()->SetSessionState(session_manager::SessionState::LOCKED); |
| 408 |
| 409 ASSERT_EQ(TestAppManager::State::kStarted, app_manager()->state()); |
| 410 |
| 411 session_manager()->SetSessionState(session_manager::SessionState::ACTIVE); |
| 412 ASSERT_EQ(TestAppManager::State::kStopped, app_manager()->state()); |
| 413 |
| 414 EXPECT_EQ(TrayActionState::kNotAvailable, |
| 415 state_controller()->GetLockScreenNoteState()); |
| 416 state_controller()->FlushTrayActionForTesting(); |
| 417 EXPECT_EQ(0u, observer()->observed_states().size()); |
| 418 EXPECT_EQ(0u, tray_action()->observed_states().size()); |
| 419 |
| 420 // Test that subsequent session lock works as expected. |
| 421 session_manager()->SetSessionState(session_manager::SessionState::LOCKED); |
| 422 |
| 423 ASSERT_EQ(TestAppManager::State::kStarted, app_manager()->state()); |
| 424 app_manager()->UpdateApp("app_id", true); |
| 425 |
| 426 EXPECT_EQ(TrayActionState::kAvailable, |
| 427 state_controller()->GetLockScreenNoteState()); |
| 428 state_controller()->FlushTrayActionForTesting(); |
| 429 ASSERT_EQ(1u, observer()->observed_states().size()); |
| 430 EXPECT_EQ(TrayActionState::kAvailable, observer()->observed_states()[0]); |
| 431 ASSERT_EQ(1u, tray_action()->observed_states().size()); |
| 432 EXPECT_EQ(TrayActionState::kAvailable, tray_action()->observed_states()[0]); |
| 433 } |
| 434 |
| 435 TEST_F(LockScreenAppStateTest, AppManagerNoApp) { |
| 436 state_controller()->SetPrimaryProfile(profile()); |
| 437 ASSERT_EQ(TestAppManager::State::kStopped, app_manager()->state()); |
| 438 |
| 439 session_manager()->SetSessionState(session_manager::SessionState::LOCKED); |
| 440 |
| 441 EXPECT_EQ(TestAppManager::State::kStarted, app_manager()->state()); |
| 442 |
| 443 EXPECT_EQ(TrayActionState::kNotAvailable, |
| 444 state_controller()->GetLockScreenNoteState()); |
| 445 state_controller()->FlushTrayActionForTesting(); |
| 446 EXPECT_EQ(0u, observer()->observed_states().size()); |
| 447 EXPECT_EQ(0u, tray_action()->observed_states().size()); |
| 448 |
| 449 tray_action()->SendNewNoteRequest(); |
| 450 |
| 451 EXPECT_EQ(TrayActionState::kNotAvailable, |
| 452 state_controller()->GetLockScreenNoteState()); |
| 453 state_controller()->FlushTrayActionForTesting(); |
| 454 EXPECT_EQ(0u, observer()->observed_states().size()); |
| 455 EXPECT_EQ(0u, tray_action()->observed_states().size()); |
| 456 |
| 457 // App manager should be started on next session lock. |
| 458 session_manager()->SetSessionState(session_manager::SessionState::ACTIVE); |
| 459 ASSERT_EQ(TestAppManager::State::kStopped, app_manager()->state()); |
| 460 app_manager()->SetInitialAppState("app_id", false); |
| 461 |
| 462 session_manager()->SetSessionState(session_manager::SessionState::LOCKED); |
| 463 |
| 464 EXPECT_EQ(TrayActionState::kAvailable, |
| 465 state_controller()->GetLockScreenNoteState()); |
| 466 state_controller()->FlushTrayActionForTesting(); |
| 467 ASSERT_EQ(1u, observer()->observed_states().size()); |
| 468 EXPECT_EQ(TrayActionState::kAvailable, observer()->observed_states()[0]); |
| 469 ASSERT_EQ(1u, tray_action()->observed_states().size()); |
| 470 EXPECT_EQ(TrayActionState::kAvailable, tray_action()->observed_states()[0]); |
| 471 } |
| 472 |
| 473 TEST_F(LockScreenAppStateTest, AppAvailabilityChanges) { |
| 474 state_controller()->SetPrimaryProfile(profile()); |
| 475 ASSERT_EQ(TestAppManager::State::kStopped, app_manager()->state()); |
| 476 |
| 477 app_manager()->SetInitialAppState("app_id", false); |
| 478 session_manager()->SetSessionState(session_manager::SessionState::LOCKED); |
| 479 |
| 480 EXPECT_EQ(TestAppManager::State::kStarted, app_manager()->state()); |
| 481 |
| 482 EXPECT_EQ(TrayActionState::kAvailable, |
| 483 state_controller()->GetLockScreenNoteState()); |
| 484 state_controller()->FlushTrayActionForTesting(); |
| 485 ASSERT_EQ(1u, observer()->observed_states().size()); |
| 486 EXPECT_EQ(TrayActionState::kAvailable, observer()->observed_states()[0]); |
| 487 observer()->ClearObservedStates(); |
| 488 ASSERT_EQ(1u, tray_action()->observed_states().size()); |
| 489 EXPECT_EQ(TrayActionState::kAvailable, tray_action()->observed_states()[0]); |
| 490 tray_action()->ClearObservedStates(); |
| 491 |
| 492 app_manager()->UpdateApp("", false); |
| 493 |
| 494 EXPECT_EQ(TrayActionState::kNotAvailable, |
| 495 state_controller()->GetLockScreenNoteState()); |
| 496 state_controller()->FlushTrayActionForTesting(); |
| 497 ASSERT_EQ(1u, observer()->observed_states().size()); |
| 498 EXPECT_EQ(TrayActionState::kNotAvailable, observer()->observed_states()[0]); |
| 499 observer()->ClearObservedStates(); |
| 500 ASSERT_EQ(1u, tray_action()->observed_states().size()); |
| 501 EXPECT_EQ(TrayActionState::kNotAvailable, |
| 502 tray_action()->observed_states()[0]); |
| 503 tray_action()->ClearObservedStates(); |
| 504 |
| 505 app_manager()->UpdateApp("app_id_1", true); |
| 506 |
| 507 EXPECT_EQ(TrayActionState::kAvailable, |
| 508 state_controller()->GetLockScreenNoteState()); |
| 509 state_controller()->FlushTrayActionForTesting(); |
| 510 ASSERT_EQ(1u, observer()->observed_states().size()); |
| 511 EXPECT_EQ(TrayActionState::kAvailable, observer()->observed_states()[0]); |
| 512 observer()->ClearObservedStates(); |
| 513 ASSERT_EQ(1u, tray_action()->observed_states().size()); |
| 514 EXPECT_EQ(TrayActionState::kAvailable, tray_action()->observed_states()[0]); |
| 515 tray_action()->ClearObservedStates(); |
| 516 } |
| 517 |
165 TEST_F(LockScreenAppStateTest, MoveToBackgroundFromActive) { | 518 TEST_F(LockScreenAppStateTest, MoveToBackgroundFromActive) { |
| 519 ASSERT_TRUE(EnableNoteTakingApp(true /* enable_app_launch */)); |
| 520 |
166 state_controller()->SetLockScreenNoteStateForTesting( | 521 state_controller()->SetLockScreenNoteStateForTesting( |
167 TrayActionState::kActive); | 522 TrayActionState::kActive); |
168 | 523 |
169 state_controller()->MoveToBackground(); | 524 state_controller()->MoveToBackground(); |
170 state_controller()->FlushTrayActionForTesting(); | 525 state_controller()->FlushTrayActionForTesting(); |
171 | 526 |
172 EXPECT_EQ(TrayActionState::kBackground, | 527 EXPECT_EQ(TrayActionState::kBackground, |
173 state_controller()->GetLockScreenNoteState()); | 528 state_controller()->GetLockScreenNoteState()); |
174 | 529 |
175 ASSERT_EQ(1u, observer()->observed_states().size()); | 530 ASSERT_EQ(1u, observer()->observed_states().size()); |
176 EXPECT_EQ(TrayActionState::kBackground, observer()->observed_states()[0]); | 531 EXPECT_EQ(TrayActionState::kBackground, observer()->observed_states()[0]); |
177 ASSERT_EQ(1u, tray_action()->observed_states().size()); | 532 ASSERT_EQ(1u, tray_action()->observed_states().size()); |
178 EXPECT_EQ(TrayActionState::kBackground, tray_action()->observed_states()[0]); | 533 EXPECT_EQ(TrayActionState::kBackground, tray_action()->observed_states()[0]); |
179 } | 534 } |
180 | 535 |
181 TEST_F(LockScreenAppStateTest, MoveToForeground) { | 536 TEST_F(LockScreenAppStateTest, MoveToForeground) { |
| 537 ASSERT_TRUE(EnableNoteTakingApp(true /* enable_app_launch */)); |
| 538 |
182 state_controller()->SetLockScreenNoteStateForTesting( | 539 state_controller()->SetLockScreenNoteStateForTesting( |
183 TrayActionState::kBackground); | 540 TrayActionState::kBackground); |
184 | 541 |
185 state_controller()->MoveToForeground(); | 542 state_controller()->MoveToForeground(); |
186 state_controller()->FlushTrayActionForTesting(); | 543 state_controller()->FlushTrayActionForTesting(); |
187 | 544 |
188 EXPECT_EQ(TrayActionState::kActive, | 545 EXPECT_EQ(TrayActionState::kActive, |
189 state_controller()->GetLockScreenNoteState()); | 546 state_controller()->GetLockScreenNoteState()); |
190 | 547 |
191 ASSERT_EQ(1u, observer()->observed_states().size()); | 548 ASSERT_EQ(1u, observer()->observed_states().size()); |
192 EXPECT_EQ(TrayActionState::kActive, observer()->observed_states()[0]); | 549 EXPECT_EQ(TrayActionState::kActive, observer()->observed_states()[0]); |
193 ASSERT_EQ(1u, tray_action()->observed_states().size()); | 550 ASSERT_EQ(1u, tray_action()->observed_states().size()); |
194 EXPECT_EQ(TrayActionState::kActive, tray_action()->observed_states()[0]); | 551 EXPECT_EQ(TrayActionState::kActive, tray_action()->observed_states()[0]); |
195 } | 552 } |
196 | 553 |
197 TEST_F(LockScreenAppStateTest, MoveToForegroundFromNonBackgroundState) { | 554 TEST_F(LockScreenAppStateTest, MoveToForegroundFromNonBackgroundState) { |
198 state_controller()->SetLockScreenNoteStateForTesting( | 555 ASSERT_TRUE(EnableNoteTakingApp(true /* enable_app_launch */)); |
199 TrayActionState::kAvailable); | |
200 | 556 |
201 state_controller()->MoveToForeground(); | 557 state_controller()->MoveToForeground(); |
202 state_controller()->FlushTrayActionForTesting(); | 558 state_controller()->FlushTrayActionForTesting(); |
203 | 559 |
204 EXPECT_EQ(TrayActionState::kAvailable, | 560 EXPECT_EQ(TrayActionState::kAvailable, |
205 state_controller()->GetLockScreenNoteState()); | 561 state_controller()->GetLockScreenNoteState()); |
206 | 562 |
207 EXPECT_EQ(0u, observer()->observed_states().size()); | 563 EXPECT_EQ(0u, observer()->observed_states().size()); |
208 EXPECT_EQ(0u, tray_action()->observed_states().size()); | 564 EXPECT_EQ(0u, tray_action()->observed_states().size()); |
209 } | 565 } |
210 | 566 |
211 TEST_F(LockScreenAppStateTest, HandleActionWhenNotAvaiable) { | 567 TEST_F(LockScreenAppStateTest, HandleActionWhenNotAvaiable) { |
212 ASSERT_EQ(TrayActionState::kNotAvailable, | 568 ASSERT_EQ(TrayActionState::kNotAvailable, |
213 state_controller()->GetLockScreenNoteState()); | 569 state_controller()->GetLockScreenNoteState()); |
214 | 570 |
215 tray_action()->SendNewNoteRequest(); | 571 tray_action()->SendNewNoteRequest(); |
216 state_controller()->FlushTrayActionForTesting(); | 572 state_controller()->FlushTrayActionForTesting(); |
217 | 573 |
218 EXPECT_EQ(0u, observer()->observed_states().size()); | 574 EXPECT_EQ(0u, observer()->observed_states().size()); |
219 EXPECT_EQ(0u, tray_action()->observed_states().size()); | 575 EXPECT_EQ(0u, tray_action()->observed_states().size()); |
220 } | 576 } |
221 | 577 |
222 TEST_F(LockScreenAppStateTest, HandleAction) { | 578 TEST_F(LockScreenAppStateTest, HandleAction) { |
223 state_controller()->SetLockScreenNoteStateForTesting( | 579 ASSERT_TRUE(EnableNoteTakingApp(true /* enable_app_launch */)); |
224 TrayActionState::kAvailable); | |
225 | 580 |
226 tray_action()->SendNewNoteRequest(); | 581 tray_action()->SendNewNoteRequest(); |
227 state_controller()->FlushTrayActionForTesting(); | 582 state_controller()->FlushTrayActionForTesting(); |
228 | 583 |
229 EXPECT_EQ(TrayActionState::kActive, | 584 EXPECT_EQ(TrayActionState::kLaunching, |
230 state_controller()->GetLockScreenNoteState()); | 585 state_controller()->GetLockScreenNoteState()); |
231 ASSERT_EQ(1u, observer()->observed_states().size()); | 586 ASSERT_EQ(1u, observer()->observed_states().size()); |
232 EXPECT_EQ(TrayActionState::kActive, observer()->observed_states()[0]); | 587 EXPECT_EQ(TrayActionState::kLaunching, observer()->observed_states()[0]); |
233 observer()->ClearObservedStates(); | 588 observer()->ClearObservedStates(); |
234 ASSERT_EQ(1u, tray_action()->observed_states().size()); | 589 ASSERT_EQ(1u, tray_action()->observed_states().size()); |
235 EXPECT_EQ(TrayActionState::kActive, tray_action()->observed_states()[0]); | 590 EXPECT_EQ(TrayActionState::kLaunching, tray_action()->observed_states()[0]); |
236 tray_action()->ClearObservedStates(); | 591 tray_action()->ClearObservedStates(); |
237 | 592 |
| 593 EXPECT_EQ(1, app_manager()->launch_count()); |
| 594 |
238 tray_action()->SendNewNoteRequest(); | 595 tray_action()->SendNewNoteRequest(); |
239 state_controller()->FlushTrayActionForTesting(); | 596 state_controller()->FlushTrayActionForTesting(); |
240 | 597 |
241 // There should be no state change - the state_controller was already in | 598 // There should be no state change - the state_controller was already in |
242 // active state when the request was received. | 599 // launching state when the request was received. |
243 EXPECT_EQ(0u, observer()->observed_states().size()); | 600 EXPECT_EQ(0u, observer()->observed_states().size()); |
244 EXPECT_EQ(0u, tray_action()->observed_states().size()); | 601 EXPECT_EQ(0u, tray_action()->observed_states().size()); |
| 602 EXPECT_EQ(1, app_manager()->launch_count()); |
245 } | 603 } |
| 604 |
| 605 TEST_F(LockScreenAppStateTest, HandleActionWithLaunchFailure) { |
| 606 ASSERT_TRUE(EnableNoteTakingApp(false /* enable_app_launch */)); |
| 607 |
| 608 tray_action()->SendNewNoteRequest(); |
| 609 state_controller()->FlushTrayActionForTesting(); |
| 610 |
| 611 EXPECT_EQ(TrayActionState::kAvailable, |
| 612 state_controller()->GetLockScreenNoteState()); |
| 613 ASSERT_EQ(2u, observer()->observed_states().size()); |
| 614 EXPECT_EQ(TrayActionState::kLaunching, observer()->observed_states()[0]); |
| 615 EXPECT_EQ(TrayActionState::kAvailable, observer()->observed_states()[1]); |
| 616 observer()->ClearObservedStates(); |
| 617 ASSERT_EQ(2u, tray_action()->observed_states().size()); |
| 618 EXPECT_EQ(TrayActionState::kLaunching, tray_action()->observed_states()[0]); |
| 619 EXPECT_EQ(TrayActionState::kAvailable, tray_action()->observed_states()[1]); |
| 620 tray_action()->ClearObservedStates(); |
| 621 |
| 622 EXPECT_EQ(1, app_manager()->launch_count()); |
| 623 |
| 624 tray_action()->SendNewNoteRequest(); |
| 625 state_controller()->FlushTrayActionForTesting(); |
| 626 |
| 627 EXPECT_EQ(TrayActionState::kAvailable, |
| 628 state_controller()->GetLockScreenNoteState()); |
| 629 |
| 630 // There should be no state change - the state_controller was already in |
| 631 // launching state when the request was received. |
| 632 EXPECT_EQ(2u, observer()->observed_states().size()); |
| 633 EXPECT_EQ(2u, tray_action()->observed_states().size()); |
| 634 EXPECT_EQ(2, app_manager()->launch_count()); |
| 635 } |
OLD | NEW |