1 // Copyright (c) 2013 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/system/automatic_reboot_manager.h" 6 7 #include <string> 8 #include <utility> 9 10 #include "ash/shell.h" 11 #include "ash/test/test_shell_delegate.h" 12 #include "base/compiler_specific.h" 13 #include "base/files/file_path.h" 14 #include "base/files/file_util.h" 15 #include "base/files/scoped_temp_dir.h" 16 #include "base/memory/ref_counted.h" 17 #include "base/message_loop/message_loop.h" 18 #include "base/path_service.h" 19 #include "base/prefs/pref_registry_simple.h" 20 #include "base/prefs/testing_pref_service.h" 21 #include "base/run_loop.h" 22 #include "base/single_thread_task_runner.h" 23 #include "base/strings/string_number_conversions.h" 24 #include "base/test/simple_test_tick_clock.h" 25 #include "base/thread_task_runner_handle.h" 26 #include "base/threading/sequenced_worker_pool.h" 27 #include "base/time/tick_clock.h" 28 #include "base/values.h" 29 #include "chrome/browser/chrome_notification_types.h" 30 #include "chrome/browser/chromeos/login/users/mock_user_manager.h" 31 #include "chrome/browser/chromeos/login/users/scoped_user_manager_enabler.h" 32 #include "chrome/common/pref_names.h" 33 #include "chrome/test/base/testing_browser_process.h" 34 #include "chromeos/chromeos_paths.h" 35 #include "chromeos/dbus/dbus_thread_manager.h" 36 #include "chromeos/dbus/fake_power_manager_client.h" 37 #include "chromeos/dbus/fake_update_engine_client.h" 38 #include "content/public/browser/browser_thread.h" 39 #include "content/public/browser/notification_details.h" 40 #include "content/public/browser/notification_service.h" 41 #include "content/public/browser/notification_source.h" 42 #include "content/public/test/test_browser_thread.h" 43 #include "testing/gmock/include/gmock/gmock.h" 44 #include "testing/gtest/include/gtest/gtest.h" 45 #include "ui/message_center/message_center.h" 46 47 using ::testing::ReturnPointee; 48 49 namespace chromeos { 50 namespace system { 51 52 namespace { 53 54 // A SingleThreadTaskRunner that mocks the current time and allows it to be 55 // fast-forwarded. The current time in ticks is returned by Now(). The 56 // corresponding device uptime is written to |uptime_file_|, providing a mock 57 // for /proc/uptime. 58 class MockTimeSingleThreadTaskRunner : public base::SingleThreadTaskRunner { 59 public: 60 MockTimeSingleThreadTaskRunner(); 61 62 // base::SingleThreadTaskRunner: 63 virtual bool RunsTasksOnCurrentThread() const OVERRIDE; 64 virtual bool PostDelayedTask(const tracked_objects::Location& from_here, 65 const base::Closure& task, 66 base::TimeDelta delay) OVERRIDE; 67 virtual bool PostNonNestableDelayedTask( 68 const tracked_objects::Location& from_here, 69 const base::Closure& task, 70 base::TimeDelta delay) OVERRIDE; 71 72 void SetUptimeFile(const base::FilePath& uptime_file); 73 void SetUptime(const base::TimeDelta& uptime); 74 75 const base::TimeDelta& Uptime() const; 76 const base::TimeTicks& Now() const; 77 78 void FastForwardBy(const base::TimeDelta& delta); 79 void FastForwardUntilNoTasksRemain(); 80 void RunUntilIdle(); 81 82 private: 83 // Strict weak temporal ordering of tasks. 84 class TemporalOrder { 85 public: 86 bool operator()( 87 const std::pair<base::TimeTicks, base::Closure>& first_task, 88 const std::pair<base::TimeTicks, base::Closure>& second_task) const; 89 }; 90 91 virtual ~MockTimeSingleThreadTaskRunner(); 92 93 base::FilePath uptime_file_; 94 base::TimeDelta uptime_; 95 base::TimeTicks now_; 96 std::priority_queue<std::pair<base::TimeTicks, base::Closure>, 97 std::vector<std::pair<base::TimeTicks, base::Closure> >, 98 TemporalOrder> tasks_; 99 100 DISALLOW_COPY_AND_ASSIGN(MockTimeSingleThreadTaskRunner); 101 }; 102 103 class MockTimeTickClock : public base::TickClock { 104 public: 105 explicit MockTimeTickClock( 106 scoped_refptr<MockTimeSingleThreadTaskRunner> task_runner); 107 virtual ~MockTimeTickClock(); 108 109 // base::TickClock: 110 virtual base::TimeTicks NowTicks() OVERRIDE; 111 112 private: 113 scoped_refptr<MockTimeSingleThreadTaskRunner> task_runner_; 114 115 DISALLOW_COPY_AND_ASSIGN(MockTimeTickClock); 116 }; 117 118 } // namespace 119 120 class AutomaticRebootManagerBasicTest : public testing::Test { 121 protected: 122 typedef base::OneShotTimer<AutomaticRebootManager> Timer; 123 124 AutomaticRebootManagerBasicTest(); 125 virtual ~AutomaticRebootManagerBasicTest(); 126 127 // testing::Test: 128 virtual void SetUp() OVERRIDE; 129 virtual void TearDown() OVERRIDE; 130 131 void SetUpdateRebootNeededUptime(const base::TimeDelta& uptime); 132 void SetRebootAfterUpdate(bool reboot_after_update, bool expect_reboot); 133 void SetUptimeLimit(const base::TimeDelta& limit, bool expect_reboot); 134 void NotifyUpdateRebootNeeded(); 135 void NotifyResumed(bool expect_reboot); 136 void NotifyTerminating(bool expect_reboot); 137 138 void FastForwardBy(const base::TimeDelta& delta, bool expect_reboot); 139 void FastForwardUntilNoTasksRemain(bool expect_reboot); 140 141 void CreateAutomaticRebootManager(bool expect_reboot); 142 143 bool ReadUpdateRebootNeededUptimeFromFile(base::TimeDelta* uptime); 144 void VerifyLoginScreenIdleTimerIsStopped() const; 145 void VerifyNoGracePeriod() const; 146 void VerifyGracePeriod(const base::TimeDelta& start_uptime) const; 147 148 bool is_user_logged_in_; 149 bool is_logged_in_as_kiosk_app_; 150 151 // The uptime is read in the blocking thread pool and then processed on the 152 // UI thread. This causes the UI thread to start processing the uptime when it 153 // has increased by a small offset already. The offset is calculated and 154 // stored in |uptime_processing_delay_| so that tests can accurately determine 155 // the uptime seen by the UI thread. 156 base::TimeDelta uptime_processing_delay_; 157 base::TimeDelta update_reboot_needed_uptime_; 158 base::TimeDelta uptime_limit_; 159 160 scoped_refptr<MockTimeSingleThreadTaskRunner> task_runner_; 161 162 scoped_ptr<AutomaticRebootManager> automatic_reboot_manager_; 163 164 protected: 165 FakePowerManagerClient* power_manager_client_; // Not owned. 166 FakeUpdateEngineClient* update_engine_client_; // Not owned. 167 168 // Sets the status of |update_engine_client_| to NEED_REBOOT for tests. 169 void SetUpdateStatusNeedReboot(); 170 171 private: 172 void VerifyTimerIsStopped(const Timer* timer) const; 173 void VerifyTimerIsRunning(const Timer* timer, 174 const base::TimeDelta& delay) const; 175 void VerifyLoginScreenIdleTimerIsRunning() const; 176 177 base::ScopedTempDir temp_dir_; 178 base::FilePath update_reboot_needed_uptime_file_; 179 180 bool reboot_after_update_; 181 182 base::ThreadTaskRunnerHandle ui_thread_task_runner_handle_; 183 184 TestingPrefServiceSimple local_state_; 185 MockUserManager* mock_user_manager_; // Not owned. 186 ScopedUserManagerEnabler user_manager_enabler_; 187 }; 188 189 enum AutomaticRebootManagerTestScenario { 190 AUTOMATIC_REBOOT_MANAGER_TEST_SCENARIO_LOGIN_SCREEN, 191 AUTOMATIC_REBOOT_MANAGER_TEST_SCENARIO_KIOSK_APP_SESSION, 192 AUTOMATIC_REBOOT_MANAGER_TEST_SCENARIO_NON_KIOSK_APP_SESSION, 193 }; 194 195 // This class runs each test case three times: 196 // * once while the login screen is being shown 197 // * once while a kiosk app session is in progress 198 // * once while a non-kiosk-app session is in progress 199 class AutomaticRebootManagerTest 200 : public AutomaticRebootManagerBasicTest, 201 public testing::WithParamInterface<AutomaticRebootManagerTestScenario> { 202 protected: 203 AutomaticRebootManagerTest(); 204 virtual ~AutomaticRebootManagerTest(); 205 }; 206 207 void SaveUptimeToFile(const base::FilePath& path, 208 const base::TimeDelta& uptime) { 209 if (path.empty() || uptime == base::TimeDelta()) 210 return; 211 212 const std::string uptime_seconds = base::DoubleToString(uptime.InSecondsF()); 213 ASSERT_EQ(static_cast<int>(uptime_seconds.size()), 214 base::WriteFile(path, uptime_seconds.c_str(), 215 uptime_seconds.size())); 216 } 217 218 MockTimeSingleThreadTaskRunner::MockTimeSingleThreadTaskRunner() { 219 } 220 221 bool MockTimeSingleThreadTaskRunner::RunsTasksOnCurrentThread() const { 222 return true; 223 } 224 225 bool MockTimeSingleThreadTaskRunner::PostDelayedTask( 226 const tracked_objects::Location& from_here, 227 const base::Closure& task, 228 base::TimeDelta delay) { 229 tasks_.push(std::pair<base::TimeTicks, base::Closure>(now_ + delay, task)); 230 return true; 231 } 232 233 bool MockTimeSingleThreadTaskRunner::PostNonNestableDelayedTask( 234 const tracked_objects::Location& from_here, 235 const base::Closure& task, 236 base::TimeDelta delay) { 237 NOTREACHED(); 238 return false; 239 } 240 241 void MockTimeSingleThreadTaskRunner::SetUptimeFile( 242 const base::FilePath& uptime_file) { 243 uptime_file_ = uptime_file; 244 SaveUptimeToFile(uptime_file_, uptime_); 245 } 246 247 void MockTimeSingleThreadTaskRunner::SetUptime(const base::TimeDelta& uptime) { 248 uptime_ = uptime; 249 SaveUptimeToFile(uptime_file_, uptime_); 250 } 251 252 const base::TimeDelta& MockTimeSingleThreadTaskRunner::Uptime() const { 253 return uptime_; 254 } 255 256 const base::TimeTicks& MockTimeSingleThreadTaskRunner::Now() const { 257 return now_; 258 } 259 260 void MockTimeSingleThreadTaskRunner::FastForwardBy( 261 const base::TimeDelta& delta) { 262 const base::TimeTicks latest = now_ + delta; 263 base::SequencedWorkerPool* blocking_pool = 264 content::BrowserThread::GetBlockingPool(); 265 blocking_pool->FlushForTesting(); 266 while (!tasks_.empty() && tasks_.top().first <= latest) { 267 uptime_ += tasks_.top().first - now_; 268 SaveUptimeToFile(uptime_file_, uptime_); 269 now_ = tasks_.top().first; 270 base::Closure task = tasks_.top().second; 271 tasks_.pop(); 272 task.Run(); 273 blocking_pool->FlushForTesting(); 274 } 275 uptime_ += latest - now_; 276 SaveUptimeToFile(uptime_file_, uptime_); 277 now_ = latest; 278 } 279 280 void MockTimeSingleThreadTaskRunner::FastForwardUntilNoTasksRemain() { 281 base::SequencedWorkerPool* blocking_pool = 282 content::BrowserThread::GetBlockingPool(); 283 blocking_pool->FlushForTesting(); 284 while (!tasks_.empty()) { 285 uptime_ += tasks_.top().first - now_; 286 SaveUptimeToFile(uptime_file_, uptime_); 287 now_ = tasks_.top().first; 288 base::Closure task = tasks_.top().second; 289 tasks_.pop(); 290 task.Run(); 291 blocking_pool->FlushForTesting(); 292 } 293 } 294 295 void MockTimeSingleThreadTaskRunner::RunUntilIdle() { 296 base::SequencedWorkerPool* blocking_pool = 297 content::BrowserThread::GetBlockingPool(); 298 blocking_pool->FlushForTesting(); 299 while (!tasks_.empty() && tasks_.top().first <= now_) { 300 base::Closure task = tasks_.top().second; 301 tasks_.pop(); 302 task.Run(); 303 blocking_pool->FlushForTesting(); 304 } 305 } 306 307 bool MockTimeSingleThreadTaskRunner::TemporalOrder::operator()( 308 const std::pair<base::TimeTicks, base::Closure>& first_task, 309 const std::pair<base::TimeTicks, base::Closure>& second_task) const { 310 return first_task.first > second_task.first; 311 } 312 313 MockTimeSingleThreadTaskRunner::~MockTimeSingleThreadTaskRunner() { 314 } 315 316 MockTimeTickClock::MockTimeTickClock( 317 scoped_refptr<MockTimeSingleThreadTaskRunner> task_runner) 318 : task_runner_(task_runner) { 319 } 320 321 MockTimeTickClock::~MockTimeTickClock() { 322 } 323 324 base::TimeTicks MockTimeTickClock::NowTicks() { 325 return task_runner_->Now(); 326 } 327 328 AutomaticRebootManagerBasicTest::AutomaticRebootManagerBasicTest() 329 : is_user_logged_in_(false), 330 is_logged_in_as_kiosk_app_(false), 331 task_runner_(new MockTimeSingleThreadTaskRunner), 332 power_manager_client_(NULL), 333 update_engine_client_(NULL), 334 reboot_after_update_(false), 335 ui_thread_task_runner_handle_(task_runner_), 336 mock_user_manager_(new MockUserManager), 337 user_manager_enabler_(mock_user_manager_) { 338 } 339 340 AutomaticRebootManagerBasicTest::~AutomaticRebootManagerBasicTest() { 341 } 342 343 void AutomaticRebootManagerBasicTest::SetUp() { 344 ASSERT_TRUE(temp_dir_.CreateUniqueTempDir()); 345 const base::FilePath& temp_dir = temp_dir_.path(); 346 const base::FilePath uptime_file = temp_dir.Append("uptime"); 347 task_runner_->SetUptimeFile(uptime_file); 348 ASSERT_FALSE(base::WriteFile(uptime_file, NULL, 0)); 349 update_reboot_needed_uptime_file_ = 350 temp_dir.Append("update_reboot_needed_uptime"); 351 ASSERT_FALSE(base::WriteFile(update_reboot_needed_uptime_file_, NULL, 0)); 352 ASSERT_TRUE(PathService::Override(chromeos::FILE_UPTIME, uptime_file)); 353 ASSERT_TRUE(PathService::Override(chromeos::FILE_UPDATE_REBOOT_NEEDED_UPTIME, 354 update_reboot_needed_uptime_file_)); 355 356 TestingBrowserProcess::GetGlobal()->SetLocalState(&local_state_); 357 AutomaticRebootManager::RegisterPrefs(local_state_.registry()); 358 359 scoped_ptr<DBusThreadManagerSetter> dbus_setter = 360 chromeos::DBusThreadManager::GetSetterForTesting(); 361 power_manager_client_ = new FakePowerManagerClient; 362 dbus_setter->SetPowerManagerClient( 363 scoped_ptr<PowerManagerClient>(power_manager_client_)); 364 update_engine_client_ = new FakeUpdateEngineClient; 365 dbus_setter->SetUpdateEngineClient( 366 scoped_ptr<UpdateEngineClient>(update_engine_client_)); 367 368 EXPECT_CALL(*mock_user_manager_, IsUserLoggedIn()) 369 .WillRepeatedly(ReturnPointee(&is_user_logged_in_)); 370 EXPECT_CALL(*mock_user_manager_, IsLoggedInAsKioskApp()) 371 .WillRepeatedly(ReturnPointee(&is_logged_in_as_kiosk_app_)); 372 } 373 374 void AutomaticRebootManagerBasicTest::TearDown() { 375 // Let the AutomaticRebootManager, if any, unregister itself as an observer of 376 // several subsystems. 377 automatic_reboot_manager_.reset(); 378 task_runner_->RunUntilIdle(); 379 380 DBusThreadManager::Shutdown(); 381 TestingBrowserProcess::GetGlobal()->SetLocalState(NULL); 382 } 383 384 void AutomaticRebootManagerBasicTest::SetUpdateRebootNeededUptime( 385 const base::TimeDelta& uptime) { 386 update_reboot_needed_uptime_ = uptime; 387 SaveUptimeToFile(update_reboot_needed_uptime_file_, uptime); 388 } 389 390 391 void AutomaticRebootManagerBasicTest::SetRebootAfterUpdate( 392 bool reboot_after_update, 393 bool expect_reboot) { 394 reboot_after_update_ = reboot_after_update; 395 local_state_.SetManagedPref(prefs::kRebootAfterUpdate, 396 new base::FundamentalValue(reboot_after_update)); 397 task_runner_->RunUntilIdle(); 398 EXPECT_EQ(expect_reboot ? 1 : 0, 399 power_manager_client_->num_request_restart_calls()); 400 } 401 402 void AutomaticRebootManagerBasicTest::SetUptimeLimit( 403 const base::TimeDelta& limit, 404 bool expect_reboot) { 405 uptime_limit_ = limit; 406 if (limit == base::TimeDelta()) { 407 local_state_.RemoveManagedPref(prefs::kUptimeLimit); 408 } else { 409 local_state_.SetManagedPref( 410 prefs::kUptimeLimit, 411 new base::FundamentalValue(static_cast<int>(limit.InSeconds()))); 412 } 413 task_runner_->RunUntilIdle(); 414 EXPECT_EQ(expect_reboot ? 1 : 0, 415 power_manager_client_->num_request_restart_calls()); 416 } 417 418 void AutomaticRebootManagerBasicTest::NotifyUpdateRebootNeeded() { 419 SetUpdateStatusNeedReboot(); 420 automatic_reboot_manager_->UpdateStatusChanged( 421 update_engine_client_->GetLastStatus()); 422 task_runner_->RunUntilIdle(); 423 EXPECT_EQ(0, power_manager_client_->num_request_restart_calls()); 424 } 425 426 void AutomaticRebootManagerBasicTest::NotifyResumed(bool expect_reboot) { 427 automatic_reboot_manager_->SuspendDone(base::TimeDelta::FromHours(1)); 428 task_runner_->RunUntilIdle(); 429 EXPECT_EQ(expect_reboot ? 1 : 0, 430 power_manager_client_->num_request_restart_calls()); 431 } 432 433 void AutomaticRebootManagerBasicTest::NotifyTerminating(bool expect_reboot) { 434 automatic_reboot_manager_->Observe( 435 chrome::NOTIFICATION_APP_TERMINATING, 436 content::Source<AutomaticRebootManagerBasicTest>(this), 437 content::NotificationService::NoDetails()); 438 task_runner_->RunUntilIdle(); 439 EXPECT_EQ(expect_reboot ? 1 : 0, 440 power_manager_client_->num_request_restart_calls()); 441 } 442 443 void AutomaticRebootManagerBasicTest::FastForwardBy( 444 const base::TimeDelta& delta, 445 bool expect_reboot) { 446 task_runner_->FastForwardBy(delta); 447 EXPECT_EQ(expect_reboot ? 1 : 0, 448 power_manager_client_->num_request_restart_calls()); 449 } 450 451 void AutomaticRebootManagerBasicTest::FastForwardUntilNoTasksRemain( 452 bool expect_reboot) { 453 task_runner_->FastForwardUntilNoTasksRemain(); 454 EXPECT_EQ(expect_reboot ? 1 : 0, 455 power_manager_client_->num_request_restart_calls()); 456 } 457 458 void AutomaticRebootManagerBasicTest::CreateAutomaticRebootManager( 459 bool expect_reboot) { 460 automatic_reboot_manager_.reset(new AutomaticRebootManager( 461 scoped_ptr<base::TickClock>(new MockTimeTickClock(task_runner_)))); 462 task_runner_->RunUntilIdle(); 463 EXPECT_EQ(expect_reboot ? 1 : 0, 464 power_manager_client_->num_request_restart_calls()); 465 466 uptime_processing_delay_ = 467 base::TimeTicks() - automatic_reboot_manager_->boot_time_ - 468 task_runner_->Uptime(); 469 EXPECT_GE(uptime_processing_delay_, base::TimeDelta()); 470 EXPECT_LE(uptime_processing_delay_, base::TimeDelta::FromSeconds(1)); 471 472 if (is_user_logged_in_ || expect_reboot) 473 VerifyLoginScreenIdleTimerIsStopped(); 474 else 475 VerifyLoginScreenIdleTimerIsRunning(); 476 } 477 478 bool AutomaticRebootManagerBasicTest::ReadUpdateRebootNeededUptimeFromFile( 479 base::TimeDelta* uptime) { 480 std::string contents; 481 if (!base::ReadFileToString(update_reboot_needed_uptime_file_, &contents)) { 482 return false; 483 } 484 double seconds; 485 if (!base::StringToDouble(contents.substr(0, contents.find(' ')), &seconds) || 486 seconds < 0.0) { 487 return false; 488 } 489 *uptime = base::TimeDelta::FromMilliseconds(seconds * 1000.0); 490 return true; 491 } 492 493 void AutomaticRebootManagerBasicTest:: 494 VerifyLoginScreenIdleTimerIsStopped() const { 495 VerifyTimerIsStopped( 496 automatic_reboot_manager_->login_screen_idle_timer_.get()); 497 } 498 499 void AutomaticRebootManagerBasicTest::VerifyNoGracePeriod() const { 500 EXPECT_FALSE(automatic_reboot_manager_->reboot_requested_); 501 VerifyTimerIsStopped(automatic_reboot_manager_->grace_start_timer_.get()); 502 VerifyTimerIsStopped(automatic_reboot_manager_->grace_end_timer_.get()); 503 } 504 505 void AutomaticRebootManagerBasicTest::VerifyGracePeriod( 506 const base::TimeDelta& start_uptime) const { 507 const base::TimeDelta start = 508 start_uptime - task_runner_->Uptime() - uptime_processing_delay_; 509 const base::TimeDelta end = start + base::TimeDelta::FromHours(24); 510 if (start <= base::TimeDelta()) { 511 EXPECT_TRUE(automatic_reboot_manager_->reboot_requested_); 512 VerifyTimerIsStopped(automatic_reboot_manager_->grace_start_timer_.get()); 513 VerifyTimerIsRunning(automatic_reboot_manager_->grace_end_timer_.get(), 514 end); 515 } else { 516 EXPECT_FALSE(automatic_reboot_manager_->reboot_requested_); 517 VerifyTimerIsRunning(automatic_reboot_manager_->grace_start_timer_.get(), 518 start); 519 VerifyTimerIsRunning(automatic_reboot_manager_->grace_end_timer_.get(), 520 end); 521 } 522 } 523 524 void AutomaticRebootManagerBasicTest::VerifyTimerIsStopped( 525 const Timer* timer) const { 526 if (timer) 527 EXPECT_FALSE(timer->IsRunning()); 528 } 529 530 void AutomaticRebootManagerBasicTest::VerifyTimerIsRunning( 531 const Timer* timer, 532 const base::TimeDelta& delay) const { 533 ASSERT_TRUE(timer); 534 EXPECT_TRUE(timer->IsRunning()); 535 EXPECT_EQ(delay.ToInternalValue(), 536 timer->GetCurrentDelay().ToInternalValue()); 537 } 538 539 void AutomaticRebootManagerBasicTest:: 540 VerifyLoginScreenIdleTimerIsRunning() const { 541 VerifyTimerIsRunning( 542 automatic_reboot_manager_->login_screen_idle_timer_.get(), 543 base::TimeDelta::FromSeconds(60)); 544 } 545 546 void AutomaticRebootManagerBasicTest::SetUpdateStatusNeedReboot() { 547 UpdateEngineClient::Status client_status; 548 client_status.status = UpdateEngineClient::UPDATE_STATUS_UPDATED_NEED_REBOOT; 549 update_engine_client_->set_default_status(client_status); 550 } 551 552 AutomaticRebootManagerTest::AutomaticRebootManagerTest() { 553 switch (GetParam()) { 554 case AUTOMATIC_REBOOT_MANAGER_TEST_SCENARIO_LOGIN_SCREEN: 555 is_user_logged_in_ = false; 556 is_logged_in_as_kiosk_app_ = false; 557 break; 558 case AUTOMATIC_REBOOT_MANAGER_TEST_SCENARIO_KIOSK_APP_SESSION: 559 is_user_logged_in_ = true; 560 is_logged_in_as_kiosk_app_ = true; 561 break; 562 case AUTOMATIC_REBOOT_MANAGER_TEST_SCENARIO_NON_KIOSK_APP_SESSION: 563 is_user_logged_in_ = true; 564 is_logged_in_as_kiosk_app_ = false; 565 break; 566 } 567 } 568 569 AutomaticRebootManagerTest::~AutomaticRebootManagerTest() { 570 } 571 572 // Chrome is showing the login screen. The current uptime is 12 hours. 573 // Verifies that the idle timer is running. Further verifies that when a kiosk 574 // app session begins, the idle timer is stopped. 575 TEST_F(AutomaticRebootManagerBasicTest, LoginStopsIdleTimer) { 576 task_runner_->SetUptime(base::TimeDelta::FromHours(12)); 577 578 // Verify that the device does not reboot immediately and the login screen 579 // idle timer is started. 580 CreateAutomaticRebootManager(false); 581 582 // Notify that a kiosk app session has been started. 583 is_user_logged_in_ = true; 584 is_logged_in_as_kiosk_app_ = true; 585 automatic_reboot_manager_->Observe( 586 chrome::NOTIFICATION_LOGIN_USER_CHANGED, 587 content::Source<AutomaticRebootManagerBasicTest>(this), 588 content::NotificationService::NoDetails()); 589 590 // Verify that the login screen idle timer is stopped. 591 VerifyLoginScreenIdleTimerIsStopped(); 592 593 // Verify that the device does not reboot eventually. 594 FastForwardUntilNoTasksRemain(false); 595 } 596 597 // Chrome is showing the login screen. The current uptime is 12 hours. 598 // Verifies that the idle timer is running. Further verifies that when a 599 // non-kiosk-app session begins, the idle timer is stopped. 600 TEST_F(AutomaticRebootManagerBasicTest, NonKioskLoginStopsIdleTimer) { 601 task_runner_->SetUptime(base::TimeDelta::FromHours(12)); 602 603 // Verify that the device does not reboot immediately and the login screen 604 // idle timer is started. 605 CreateAutomaticRebootManager(false); 606 607 // Notify that a non-kiosk-app session has been started. 608 is_user_logged_in_ = true; 609 automatic_reboot_manager_->Observe( 610 chrome::NOTIFICATION_LOGIN_USER_CHANGED, 611 content::Source<AutomaticRebootManagerBasicTest>(this), 612 content::NotificationService::NoDetails()); 613 614 // Verify that the login screen idle timer is stopped. 615 VerifyLoginScreenIdleTimerIsStopped(); 616 617 // Verify that the device does not reboot eventually. 618 FastForwardUntilNoTasksRemain(false); 619 } 620 621 // Chrome is showing the login screen. The uptime limit is 6 hours. The current 622 // uptime is 12 hours. 623 // Verifies that user activity prevents the device from rebooting. Further 624 // verifies that when user activity ceases, the devices reboots. 625 TEST_F(AutomaticRebootManagerBasicTest, UserActivityResetsIdleTimer) { 626 task_runner_->SetUptime(base::TimeDelta::FromHours(12)); 627 628 // Verify that the device does not reboot immediately and the login screen 629 // idle timer is started. 630 CreateAutomaticRebootManager(false); 631 632 // Set the uptime limit. Verify that the device does not reboot immediately. 633 SetUptimeLimit(base::TimeDelta::FromHours(6), false); 634 635 // Verify that a grace period has started. 636 VerifyGracePeriod(uptime_limit_); 637 638 // Fast forward the uptime by 25 minutes while simulating user activity every 639 // 50 seconds. 640 for (int i = 0; i < 30; ++i) { 641 // Fast forward uptime by 50 seconds. Verify that the device does not reboot 642 // immediately. 643 FastForwardBy(base::TimeDelta::FromSeconds(50), false); 644 645 // Simulate user activity. 646 automatic_reboot_manager_->OnUserActivity(NULL); 647 } 648 649 // Fast forward the uptime by 60 seconds without simulating user activity. 650 // Verify that the device reboots immediately. 651 FastForwardBy(base::TimeDelta::FromSeconds(60), true); 652 } 653 654 // Chrome is running a kiosk app session. The current uptime is 10 days. 655 // Verifies that when the device is suspended and then resumes, it does not 656 // immediately reboot. 657 TEST_F(AutomaticRebootManagerBasicTest, ResumeNoPolicy) { 658 is_user_logged_in_ = true; 659 is_logged_in_as_kiosk_app_ = true; 660 task_runner_->SetUptime(base::TimeDelta::FromDays(10)); 661 662 // Verify that the device does not reboot immediately. 663 CreateAutomaticRebootManager(false); 664 665 // Verify that no grace period has started. 666 VerifyNoGracePeriod(); 667 668 // Notify that the device has resumed from 1 hour of sleep. Verify that the 669 // device does not reboot immediately. 670 NotifyResumed(false); 671 672 // Verify that the device does not reboot eventually. 673 FastForwardUntilNoTasksRemain(false); 674 } 675 676 // Chrome is running a non-kiosk-app session. The current uptime is 10 days. 677 // Verifies that when the device is suspended and then resumes, it does not 678 // immediately reboot. 679 TEST_F(AutomaticRebootManagerBasicTest, NonKioskResumeAppNoPolicy) { 680 is_user_logged_in_ = true; 681 task_runner_->SetUptime(base::TimeDelta::FromDays(10)); 682 683 // Verify that the device does not reboot immediately. 684 CreateAutomaticRebootManager(false); 685 686 // Verify that no grace period has started. 687 VerifyNoGracePeriod(); 688 689 // Notify that the device has resumed from 1 hour of sleep. Verify that the 690 // device does not reboot immediately. 691 NotifyResumed(false); 692 693 // Verify that the device does not reboot eventually. 694 FastForwardUntilNoTasksRemain(false); 695 } 696 697 // Chrome is running a kiosk app session. The uptime limit is 24 hours. The 698 // current uptime is 12 hours. 699 // Verifies that when the device is suspended and then resumes, it does not 700 // immediately reboot. 701 TEST_F(AutomaticRebootManagerBasicTest, ResumeBeforeGracePeriod) { 702 is_user_logged_in_ = true; 703 is_logged_in_as_kiosk_app_ = true; 704 task_runner_->SetUptime(base::TimeDelta::FromHours(12)); 705 706 // Verify that the device does not reboot immediately. 707 CreateAutomaticRebootManager(false); 708 709 // Set the uptime limit. Verify that the device does not reboot immediately. 710 SetUptimeLimit(base::TimeDelta::FromHours(24), false); 711 712 // Verify that a grace period has been scheduled to start in the future. 713 VerifyGracePeriod(uptime_limit_); 714 715 // Notify that the device has resumed from 1 hour of sleep. Verify that the 716 // device does not reboot immediately. 717 NotifyResumed(false); 718 719 // Verify that the device eventually reboots. 720 FastForwardUntilNoTasksRemain(true); 721 } 722 723 // Chrome is running a non-kiosk-app session. The uptime limit is 24 hours. The 724 // current uptime is 12 hours. 725 // Verifies that when the device is suspended and then resumes, it does not 726 // immediately reboot. 727 TEST_F(AutomaticRebootManagerBasicTest, NonKioskResumeBeforeGracePeriod) { 728 is_user_logged_in_ = true; 729 task_runner_->SetUptime(base::TimeDelta::FromHours(12)); 730 731 // Verify that the device does not reboot immediately. 732 CreateAutomaticRebootManager(false); 733 734 // Set the uptime limit. Verify that the device does not reboot immediately. 735 SetUptimeLimit(base::TimeDelta::FromHours(24), false); 736 737 // Verify that a grace period has been scheduled to start in the future. 738 VerifyGracePeriod(uptime_limit_); 739 740 // Notify that the device has resumed from 1 hour of sleep. Verify that the 741 // device does not reboot immediately. 742 NotifyResumed(false); 743 744 // Verify that the device does not reboot eventually. 745 FastForwardUntilNoTasksRemain(false); 746 } 747 748 // Chrome is running a kiosk app session. The uptime limit is 6 hours. The 749 // current uptime is 12 hours. 750 // Verifies that when the device is suspended and then resumes, it immediately 751 // reboots. 752 TEST_F(AutomaticRebootManagerBasicTest, ResumeInGracePeriod) { 753 is_user_logged_in_ = true; 754 is_logged_in_as_kiosk_app_ = true; 755 task_runner_->SetUptime(base::TimeDelta::FromHours(12)); 756 757 // Verify that the device does not reboot immediately. 758 CreateAutomaticRebootManager(false); 759 760 // Set the uptime limit. Verify that the device does not reboot immediately. 761 SetUptimeLimit(base::TimeDelta::FromHours(6), false); 762 763 // Verify that a grace period has started. 764 VerifyGracePeriod(uptime_limit_); 765 766 // Notify that the device has resumed from 1 hour of sleep. Verify that the 767 // device reboots immediately. 768 NotifyResumed(true); 769 } 770 771 // Chrome is running a non-kiosk-app session. The uptime limit is 6 hours. The 772 // current uptime is 12 hours. 773 // Verifies that when the device is suspended and then resumes, it does not 774 // immediately reboot. 775 TEST_F(AutomaticRebootManagerBasicTest, NonKioskResumeInGracePeriod) { 776 is_user_logged_in_ = true; 777 task_runner_->SetUptime(base::TimeDelta::FromHours(12)); 778 779 // Verify that the device does not reboot immediately. 780 CreateAutomaticRebootManager(false); 781 782 // Set the uptime limit. Verify that the device does not reboot immediately. 783 SetUptimeLimit(base::TimeDelta::FromHours(6), false); 784 785 // Verify that a grace period has started. 786 VerifyGracePeriod(uptime_limit_); 787 788 // Notify that the device has resumed from 1 hour of sleep. Verify that the 789 // device does not reboot immediately. 790 NotifyResumed(false); 791 792 // Verify that the device does not reboot eventually. 793 FastForwardUntilNoTasksRemain(false); 794 } 795 796 // Chrome is running a kiosk app session. The uptime limit is 6 hours. The 797 // current uptime is 29 hours 30 minutes. 798 // Verifies that when the device is suspended and then resumes, it immediately 799 // reboots. 800 TEST_F(AutomaticRebootManagerBasicTest, ResumeAfterGracePeriod) { 801 is_user_logged_in_ = true; 802 is_logged_in_as_kiosk_app_ = true; 803 task_runner_->SetUptime(base::TimeDelta::FromHours(29) + 804 base::TimeDelta::FromMinutes(30)); 805 806 // Verify that the device does not reboot immediately. 807 CreateAutomaticRebootManager(false); 808 809 // Set the uptime limit. Verify that the device does not reboot immediately. 810 SetUptimeLimit(base::TimeDelta::FromHours(6), false); 811 812 // Verify that a grace period has started. 813 VerifyGracePeriod(uptime_limit_); 814 815 // Notify that the device has resumed from 1 hour of sleep. Verify that the 816 // device reboots immediately. 817 NotifyResumed(true); 818 } 819 820 // Chrome is running a non-kiosk-app session. The uptime limit is 6 hours. The 821 // current uptime is 29 hours 30 minutes. 822 // Verifies that when the device is suspended and then resumes, it does not 823 // immediately reboot. 824 TEST_F(AutomaticRebootManagerBasicTest, NonKioskResumeAfterGracePeriod) { 825 is_user_logged_in_ = true; 826 task_runner_->SetUptime(base::TimeDelta::FromHours(29) + 827 base::TimeDelta::FromMinutes(30)); 828 829 // Verify that the device does not reboot immediately. 830 CreateAutomaticRebootManager(false); 831 832 // Set the uptime limit. Verify that the device does not reboot immediately. 833 SetUptimeLimit(base::TimeDelta::FromHours(6), false); 834 835 // Verify that a grace period has started. 836 VerifyGracePeriod(uptime_limit_); 837 838 // Notify that the device has resumed from 1 hour of sleep. Verify that the 839 // device does not reboot immediately. 840 NotifyResumed(false); 841 842 // Verify that the device does not reboot eventually. 843 FastForwardUntilNoTasksRemain(false); 844 } 845 846 // Chrome is running. The current uptime is 10 days. 847 // Verifies that when the browser terminates, the device does not immediately 848 // reboot. 849 TEST_P(AutomaticRebootManagerTest, TerminateNoPolicy) { 850 task_runner_->SetUptime(base::TimeDelta::FromDays(10)); 851 852 // Verify that the device does not reboot immediately. 853 CreateAutomaticRebootManager(false); 854 855 // Verify that no grace period has started. 856 VerifyNoGracePeriod(); 857 858 // Notify that the browser is terminating. Verify that the device does not 859 // reboot immediately. 860 NotifyTerminating(false); 861 862 // Verify that the device does not reboot eventually. 863 FastForwardUntilNoTasksRemain(false); 864 } 865 866 // Chrome is running. The uptime limit is set to 24 hours. The current uptime is 867 // 12 hours. 868 // Verifies that when the browser terminates, it does not immediately reboot. 869 TEST_P(AutomaticRebootManagerTest, TerminateBeforeGracePeriod) { 870 task_runner_->SetUptime(base::TimeDelta::FromHours(12)); 871 872 // Verify that the device does not reboot immediately. 873 CreateAutomaticRebootManager(false); 874 875 // Set the uptime limit. Verify that the device does not reboot immediately. 876 SetUptimeLimit(base::TimeDelta::FromHours(24), false); 877 878 // Verify that a grace period has been scheduled to start in the future. 879 VerifyGracePeriod(uptime_limit_); 880 881 // Notify that the browser is terminating. Verify that the device does not 882 // reboot immediately. 883 NotifyTerminating(false); 884 885 // Verify that unless a non-kiosk-app session is in progress, the device 886 // eventually reboots. 887 FastForwardUntilNoTasksRemain(!is_user_logged_in_ || 888 is_logged_in_as_kiosk_app_); 889 } 890 891 // Chrome is running. The uptime limit is set to 6 hours. The current uptime is 892 // 12 hours. 893 // Verifies that when the browser terminates, the device immediately reboots if 894 // a kiosk app session is in progress. 895 TEST_P(AutomaticRebootManagerTest, TerminateInGracePeriod) { 896 task_runner_->SetUptime(base::TimeDelta::FromHours(12)); 897 898 // Verify that the device does not reboot immediately. 899 CreateAutomaticRebootManager(false); 900 901 // Set the uptime limit. Verify that the device does not reboot immediately. 902 SetUptimeLimit(base::TimeDelta::FromHours(6), false); 903 904 // Verify that a grace period has started. 905 VerifyGracePeriod(uptime_limit_); 906 907 // Notify that the browser is terminating. Verify that the device immediately 908 // reboots if a kiosk app session is in progress. 909 NotifyTerminating(is_logged_in_as_kiosk_app_); 910 911 // Verify that if a non-kiosk-app session is in progress, the device does not 912 // reboot eventually. 913 FastForwardUntilNoTasksRemain(!is_user_logged_in_ || 914 is_logged_in_as_kiosk_app_); 915 } 916 917 // Chrome is running. The current uptime is 12 hours. 918 // Verifies that when the uptime limit is set to 24 hours, no reboot occurs and 919 // a grace period is scheduled to begin after 24 hours of uptime. 920 TEST_P(AutomaticRebootManagerTest, BeforeUptimeLimitGracePeriod) { 921 task_runner_->SetUptime(base::TimeDelta::FromHours(12)); 922 923 // Verify that the device does not reboot immediately. 924 CreateAutomaticRebootManager(false); 925 926 // Verify that no grace period has started. 927 VerifyNoGracePeriod(); 928 929 // Set the uptime limit. Verify that the device does not reboot immediately. 930 SetUptimeLimit(base::TimeDelta::FromHours(24), false); 931 932 // Verify that a grace period has been scheduled to start in the future. 933 VerifyGracePeriod(uptime_limit_); 934 935 // Verify that unless a non-kiosk-app session is in progress, the device 936 // eventually reboots. 937 FastForwardUntilNoTasksRemain(!is_user_logged_in_ || 938 is_logged_in_as_kiosk_app_); 939 } 940 941 // Chrome is running. The current uptime is 12 hours. 942 // Verifies that when the uptime limit is set to 6 hours, a reboot is requested 943 // and a grace period is started that will end after 6 + 24 hours of uptime. 944 TEST_P(AutomaticRebootManagerTest, InUptimeLimitGracePeriod) { 945 task_runner_->SetUptime(base::TimeDelta::FromHours(12)); 946 947 // Verify that the device does not reboot immediately. 948 CreateAutomaticRebootManager(false); 949 950 // Verify that no grace period has started. 951 VerifyNoGracePeriod(); 952 953 // Set the uptime limit. Verify that the device does not reboot immediately. 954 SetUptimeLimit(base::TimeDelta::FromHours(6), false); 955 956 // Verify that a grace period has started. 957 VerifyGracePeriod(uptime_limit_); 958 959 // Verify that unless a non-kiosk-app session is in progress, the device 960 // eventually reboots. 961 FastForwardUntilNoTasksRemain(!is_user_logged_in_ || 962 is_logged_in_as_kiosk_app_); 963 } 964 965 // Chrome is running. The current uptime is 10 days. 966 // Verifies that when the uptime limit is set to 6 hours, the device reboots 967 // immediately if no non-kiosk-app-session is in progress because the grace 968 // period ended after 6 + 24 hours of uptime. 969 TEST_P(AutomaticRebootManagerTest, AfterUptimeLimitGracePeriod) { 970 task_runner_->SetUptime(base::TimeDelta::FromDays(10)); 971 972 // Verify that the device does not reboot immediately. 973 CreateAutomaticRebootManager(false); 974 975 // Verify that no grace period has started. 976 VerifyNoGracePeriod(); 977 978 // Set the uptime limit. Verify that unless a non-kiosk-app session is in 979 // progress, the the device immediately reboots. 980 SetUptimeLimit(base::TimeDelta::FromHours(6), !is_user_logged_in_ || 981 is_logged_in_as_kiosk_app_); 982 983 // Verify that if a non-kiosk-app session is in progress, the device does not 984 // reboot eventually. 985 FastForwardUntilNoTasksRemain(!is_user_logged_in_ || 986 is_logged_in_as_kiosk_app_); 987 } 988 989 // Chrome is running. The uptime limit is set to 12 hours. The current uptime is 990 // 6 hours. 991 // Verifies that when the uptime limit is removed, the grace period is removed. 992 TEST_P(AutomaticRebootManagerTest, UptimeLimitOffBeforeGracePeriod) { 993 task_runner_->SetUptime(base::TimeDelta::FromHours(6)); 994 995 // Verify that the device does not reboot immediately. 996 CreateAutomaticRebootManager(false); 997 998 // Set the uptime limit. Verify that the device does not reboot immediately. 999 SetUptimeLimit(base::TimeDelta::FromHours(12), false); 1000 1001 // Verify that a grace period has been scheduled to start in the future. 1002 VerifyGracePeriod(uptime_limit_); 1003 1004 // Fast forward the uptime by 1 hour. Verify that the device does not reboot 1005 // immediately. 1006 FastForwardBy(base::TimeDelta::FromHours(1), false); 1007 1008 // Remove the uptime limit. Verify that the device does not reboot 1009 // immediately. 1010 SetUptimeLimit(base::TimeDelta(), false); 1011 1012 // Verify that the grace period has been removed. 1013 VerifyNoGracePeriod(); 1014 1015 // Verify that the device does not reboot eventually. 1016 FastForwardUntilNoTasksRemain(false); 1017 } 1018 1019 // Chrome is running. The uptime limit is set to 12 hours. The current uptime is 1020 // 24 hours. 1021 // Verifies that when the uptime limit is removed, the grace period is removed. 1022 TEST_P(AutomaticRebootManagerTest, UptimeLimitOffInGracePeriod) { 1023 task_runner_->SetUptime(base::TimeDelta::FromHours(24)); 1024 1025 // Verify that the device does not reboot immediately. 1026 CreateAutomaticRebootManager(false); 1027 1028 // Set the uptime limit. Verify that the device does not reboot immediately. 1029 SetUptimeLimit(base::TimeDelta::FromHours(12), false); 1030 1031 // Verify that a grace period has started. 1032 VerifyGracePeriod(uptime_limit_); 1033 1034 // Fast forward the uptime by 20 seconds. Verify that the device does not 1035 // reboot immediately. 1036 FastForwardBy(base::TimeDelta::FromSeconds(20), false); 1037 1038 // Remove the uptime limit. Verify that the device does not reboot 1039 // immediately. 1040 SetUptimeLimit(base::TimeDelta(), false); 1041 1042 // Verify that the grace period has been removed. 1043 VerifyNoGracePeriod(); 1044 1045 // Verify that the device does not reboot eventually. 1046 FastForwardUntilNoTasksRemain(false); 1047 } 1048 1049 // Chrome is running. The uptime limit is set to 12 hours. The current uptime is 1050 // 6 hours. 1051 // Verifies that when the uptime limit is extended to 24 hours, the grace period 1052 // is rescheduled to start further in the future. 1053 TEST_P(AutomaticRebootManagerTest, ExtendUptimeLimitBeforeGracePeriod) { 1054 task_runner_->SetUptime(base::TimeDelta::FromHours(6)); 1055 1056 // Verify that the device does not reboot immediately. 1057 CreateAutomaticRebootManager(false); 1058 1059 // Set the uptime limit. Verify that the device does not reboot immediately. 1060 SetUptimeLimit(base::TimeDelta::FromHours(12), false); 1061 1062 // Verify that a grace period has been scheduled to start in the future. 1063 VerifyGracePeriod(uptime_limit_); 1064 1065 // Fast forward the uptime by 20 seconds. Verify that the device does not 1066 // reboot immediately. 1067 FastForwardBy(base::TimeDelta::FromSeconds(20), false); 1068 1069 // Extend the uptime limit. Verify that the device does not reboot 1070 // immediately. 1071 SetUptimeLimit(base::TimeDelta::FromHours(24), false); 1072 1073 // Verify that the grace period has been rescheduled to start further in the 1074 // future. 1075 VerifyGracePeriod(uptime_limit_); 1076 1077 // Verify that unless a non-kiosk-app session is in progress, the device 1078 // eventually reboots. 1079 FastForwardUntilNoTasksRemain(!is_user_logged_in_ || 1080 is_logged_in_as_kiosk_app_); 1081 } 1082 1083 // Chrome is running. The uptime limit is set to 12 hours. The current uptime is 1084 // 18 hours. 1085 // Verifies that when the uptime limit is extended to 24 hours, the grace period 1086 // is rescheduled to start in the future. 1087 TEST_P(AutomaticRebootManagerTest, ExtendUptimeLimitInGracePeriod) { 1088 task_runner_->SetUptime(base::TimeDelta::FromHours(18)); 1089 1090 // Verify that the device does not reboot immediately. 1091 CreateAutomaticRebootManager(false); 1092 1093 // Set the uptime limit. Verify that the device does not reboot immediately. 1094 SetUptimeLimit(base::TimeDelta::FromHours(12), false); 1095 1096 // Verify that a grace period has started. 1097 VerifyGracePeriod(uptime_limit_); 1098 1099 // Fast forward the uptime by 20 seconds. Verify that the device does not 1100 // reboot immediately. 1101 FastForwardBy(base::TimeDelta::FromSeconds(20), false); 1102 1103 // Extend the uptime limit. Verify that the device does not reboot 1104 // immediately. 1105 SetUptimeLimit(base::TimeDelta::FromHours(24), false); 1106 1107 // Verify that the grace period has been rescheduled to start in the future. 1108 VerifyGracePeriod(uptime_limit_); 1109 1110 // Verify that unless a non-kiosk-app session is in progress, the device 1111 // eventually reboots. 1112 FastForwardUntilNoTasksRemain(!is_user_logged_in_ || 1113 is_logged_in_as_kiosk_app_); 1114 } 1115 1116 // Chrome is running. The uptime limit is set to 18 hours. The current uptime is 1117 // 12 hours. 1118 // Verifies that when the uptime limit is shortened to 6 hours, the grace period 1119 // is rescheduled to have already started. 1120 TEST_P(AutomaticRebootManagerTest, ShortenUptimeLimitBeforeToInGracePeriod) { 1121 task_runner_->SetUptime(base::TimeDelta::FromHours(12)); 1122 1123 // Verify that the device does not reboot immediately. 1124 CreateAutomaticRebootManager(false); 1125 1126 // Set the uptime limit. Verify that the device does not reboot immediately. 1127 SetUptimeLimit(base::TimeDelta::FromHours(18), false); 1128 1129 // Verify that a grace period has been scheduled to start in the future. 1130 VerifyGracePeriod(uptime_limit_); 1131 1132 // Fast forward the uptime by 20 seconds. Verify that the device does not 1133 // reboot immediately. 1134 FastForwardBy(base::TimeDelta::FromSeconds(20), false); 1135 1136 // Shorten the uptime limit. Verify that the device does not reboot 1137 // immediately. 1138 SetUptimeLimit(base::TimeDelta::FromHours(6), false); 1139 1140 // Verify that the grace period has been rescheduled and has started already. 1141 VerifyGracePeriod(uptime_limit_); 1142 1143 // Verify that unless a non-kiosk-app session is in progress, the device 1144 // eventually reboots. 1145 FastForwardUntilNoTasksRemain(!is_user_logged_in_ || 1146 is_logged_in_as_kiosk_app_); 1147 } 1148 1149 // Chrome is running. The uptime limit is set to 24 hours. The current uptime is 1150 // 36 hours. 1151 // Verifies that when the uptime limit is shortened to 18 hours, the grace 1152 // period is rescheduled to have started earlier. 1153 TEST_P(AutomaticRebootManagerTest, ShortenUptimeLimitInToInGracePeriod) { 1154 task_runner_->SetUptime(base::TimeDelta::FromHours(36)); 1155 1156 // Verify that the device does not reboot immediately. 1157 CreateAutomaticRebootManager(false); 1158 1159 // Set the uptime limit. Verify that the device does not reboot immediately. 1160 SetUptimeLimit(base::TimeDelta::FromHours(24), false); 1161 1162 // Verify that a grace period has started. 1163 VerifyGracePeriod(uptime_limit_); 1164 1165 // Fast forward the uptime by 20 seconds. Verify that the device does not 1166 // reboot immediately. 1167 FastForwardBy(base::TimeDelta::FromSeconds(20), false); 1168 1169 // Shorten the uptime limit. Verify that the device does not reboot 1170 // immediately. 1171 SetUptimeLimit(base::TimeDelta::FromHours(18), false); 1172 1173 // Verify that the grace period has been rescheduled to have started earlier. 1174 VerifyGracePeriod(uptime_limit_); 1175 1176 // Verify that unless a non-kiosk-app session is in progress, the device 1177 // eventually reboots. 1178 FastForwardUntilNoTasksRemain(!is_user_logged_in_ || 1179 is_logged_in_as_kiosk_app_); 1180 } 1181 1182 // Chrome is running. The uptime limit is set to 24 hours. The current uptime is 1183 // 36 hours. 1184 // Verifies that when the uptime limit is shortened to 6 hours, the device 1185 // reboots immediately if no non-kiosk-app session is in progress because the 1186 // grace period ended after 6 + 24 hours of uptime. 1187 TEST_P(AutomaticRebootManagerTest, ShortenUptimeLimitInToAfterGracePeriod) { 1188 task_runner_->SetUptime(base::TimeDelta::FromHours(36)); 1189 1190 // Verify that the device does not reboot immediately. 1191 CreateAutomaticRebootManager(false); 1192 1193 // Set the uptime limit. Verify that the device does not reboot immediately. 1194 SetUptimeLimit(base::TimeDelta::FromHours(24), false); 1195 1196 // Verify that a grace period has started. 1197 VerifyGracePeriod(uptime_limit_); 1198 1199 // Fast forward the uptime by 20 seconds. Verify that the device does not 1200 // reboot immediately. 1201 FastForwardBy(base::TimeDelta::FromSeconds(20), false); 1202 1203 // Shorten the uptime limit. Verify that unless a non-kiosk-app session is in 1204 // progress, the the device immediately reboots. 1205 SetUptimeLimit(base::TimeDelta::FromHours(6), !is_user_logged_in_ || 1206 is_logged_in_as_kiosk_app_); 1207 1208 // Verify that if a non-kiosk-app session is in progress, the device does not 1209 // reboot eventually. 1210 FastForwardUntilNoTasksRemain(!is_user_logged_in_ || 1211 is_logged_in_as_kiosk_app_); 1212 } 1213 1214 // Chrome is running. The current uptime is 12 hours. 1215 // Verifies that when an update is applied, the current uptime is persisted as 1216 // the time at which a reboot became necessary. Further verifies that when the 1217 // policy to automatically reboot after an update is not enabled, no reboot 1218 // occurs and no grace period is scheduled. 1219 TEST_P(AutomaticRebootManagerTest, UpdateNoPolicy) { 1220 task_runner_->SetUptime(base::TimeDelta::FromHours(12)); 1221 1222 // Verify that the device does not reboot immediately. 1223 CreateAutomaticRebootManager(false); 1224 1225 // Verify that no grace period has started. 1226 VerifyNoGracePeriod(); 1227 1228 // Notify that an update has been applied and a reboot is necessary. Verify 1229 // that the device does not reboot immediately. 1230 NotifyUpdateRebootNeeded(); 1231 1232 // Verify that the current uptime has been persisted as the time at which a 1233 // reboot became necessary. 1234 EXPECT_TRUE(ReadUpdateRebootNeededUptimeFromFile( 1235 &update_reboot_needed_uptime_)); 1236 EXPECT_EQ(task_runner_->Uptime(), update_reboot_needed_uptime_); 1237 1238 // Verify that no grace period has started. 1239 VerifyNoGracePeriod(); 1240 1241 // Verify that the device does not reboot eventually. 1242 FastForwardUntilNoTasksRemain(false); 1243 } 1244 1245 // Chrome is running. The current uptime is 12 hours. 1246 // Verifies that when an update is applied, the current uptime is persisted as 1247 // the time at which a reboot became necessary. Further verifies that when the 1248 // policy to automatically reboot after an update is enabled, a reboot is 1249 // requested and a grace period is started that will end 24 hours from now. 1250 TEST_P(AutomaticRebootManagerTest, Update) { 1251 task_runner_->SetUptime(base::TimeDelta::FromHours(12)); 1252 SetRebootAfterUpdate(true, false); 1253 1254 // Verify that the device does not reboot immediately. 1255 CreateAutomaticRebootManager(false); 1256 1257 // Verify that no grace period has started. 1258 VerifyNoGracePeriod(); 1259 1260 // Notify that an update has been applied and a reboot is necessary. Verify 1261 // that the device does not reboot immediately. 1262 NotifyUpdateRebootNeeded(); 1263 1264 // Verify that the current uptime has been persisted as the time at which a 1265 // reboot became necessary. 1266 EXPECT_TRUE(ReadUpdateRebootNeededUptimeFromFile( 1267 &update_reboot_needed_uptime_)); 1268 EXPECT_EQ(task_runner_->Uptime(), update_reboot_needed_uptime_); 1269 1270 // Verify that a grace period has started. 1271 VerifyGracePeriod(update_reboot_needed_uptime_ + uptime_processing_delay_); 1272 1273 // Verify that unless a non-kiosk-app session is in progress, the device 1274 // eventually reboots. 1275 FastForwardUntilNoTasksRemain(!is_user_logged_in_ || 1276 is_logged_in_as_kiosk_app_); 1277 } 1278 1279 // Chrome is running. The current uptime is 12 hours. 1280 // Verifies that when Chrome is notified twice that an update has been applied, 1281 // the second notification is ignored and the uptime at which it occured does 1282 // not get persisted as the time at which an update became necessary. 1283 TEST_P(AutomaticRebootManagerTest, UpdateAfterUpdate) { 1284 task_runner_->SetUptime(base::TimeDelta::FromHours(12)); 1285 SetRebootAfterUpdate(true, false); 1286 1287 // Verify that the device does not reboot immediately. 1288 CreateAutomaticRebootManager(false); 1289 1290 // Verify that no grace period has started. 1291 VerifyNoGracePeriod(); 1292 1293 // Notify that an update has been applied and a reboot is necessary. Verify 1294 // that the device does not reboot immediately. 1295 NotifyUpdateRebootNeeded(); 1296 1297 // Verify that the current uptime has been persisted as the time at which a 1298 // reboot became necessary. 1299 EXPECT_TRUE(ReadUpdateRebootNeededUptimeFromFile( 1300 &update_reboot_needed_uptime_)); 1301 EXPECT_EQ(task_runner_->Uptime(), update_reboot_needed_uptime_); 1302 1303 // Verify that a grace period has started. 1304 VerifyGracePeriod(update_reboot_needed_uptime_ + uptime_processing_delay_); 1305 1306 // Fast forward the uptime by 20 seconds. Verify that the device does not 1307 // reboot immediately. 1308 FastForwardBy(base::TimeDelta::FromSeconds(20), false); 1309 1310 // Notify that an update has been applied and a reboot is necessary. Verify 1311 // that the device does not reboot immediately. 1312 NotifyUpdateRebootNeeded(); 1313 1314 // Verify that the previously persisted time at which a reboot became 1315 // necessary has not been overwritten. 1316 base::TimeDelta new_update_reboot_needed_uptime; 1317 EXPECT_TRUE(ReadUpdateRebootNeededUptimeFromFile( 1318 &new_update_reboot_needed_uptime)); 1319 EXPECT_EQ(update_reboot_needed_uptime_, new_update_reboot_needed_uptime); 1320 1321 // Verify that unless a non-kiosk-app session is in progress, the device 1322 // eventually reboots. 1323 FastForwardUntilNoTasksRemain(!is_user_logged_in_ || 1324 is_logged_in_as_kiosk_app_); 1325 } 1326 1327 // Chrome is running. The current uptime is 10 minutes. 1328 // Verifies that when the policy to automatically reboot after an update is 1329 // enabled, no reboot occurs a grace period is scheduled to begin after the 1330 // minimum of 1 hour of uptime. Further verifies that when an update is applied, 1331 // the current uptime is persisted as the time at which a reboot became 1332 // necessary. 1333 TEST_P(AutomaticRebootManagerTest, UpdateBeforeMinimumUptime) { 1334 task_runner_->SetUptime(base::TimeDelta::FromMinutes(10)); 1335 SetRebootAfterUpdate(true, false); 1336 1337 // Verify that the device does not reboot immediately. 1338 CreateAutomaticRebootManager(false); 1339 1340 // Verify that no grace period has started. 1341 VerifyNoGracePeriod(); 1342 1343 // Notify that an update has been applied and a reboot is necessary. Verify 1344 // that the device does not reboot immediately. 1345 NotifyUpdateRebootNeeded(); 1346 1347 // Verify that the current uptime has been persisted as the time at which a 1348 // reboot became necessary. 1349 EXPECT_TRUE(ReadUpdateRebootNeededUptimeFromFile( 1350 &update_reboot_needed_uptime_)); 1351 EXPECT_EQ(task_runner_->Uptime(), update_reboot_needed_uptime_); 1352 1353 // Verify that a grace period has been scheduled to begin in the future. 1354 VerifyGracePeriod(base::TimeDelta::FromHours(1)); 1355 1356 // Verify that unless a non-kiosk-app session is in progress, the device 1357 // eventually reboots. 1358 FastForwardUntilNoTasksRemain(!is_user_logged_in_ || 1359 is_logged_in_as_kiosk_app_); 1360 } 1361 1362 // Chrome is running. An update was applied and a reboot became necessary to 1363 // complete the update process after 6 hours of uptime. The current uptime is 1364 // 12 hours. 1365 // Verifies that when the policy to automatically reboot after an update is 1366 // enabled, a reboot is requested and a grace period is started that will end 1367 // after 6 + 24 hours of uptime. 1368 TEST_P(AutomaticRebootManagerTest, PolicyAfterUpdateInGracePeriod) { 1369 task_runner_->SetUptime(base::TimeDelta::FromHours(6)); 1370 1371 // Verify that the device does not reboot immediately. 1372 CreateAutomaticRebootManager(false); 1373 1374 // Notify that an update has been applied and a reboot is necessary. Verify 1375 // that the device does not reboot immediately. 1376 NotifyUpdateRebootNeeded(); 1377 1378 // Fast forward the uptime to 12 hours. Verify that the device does not reboot 1379 // immediately. 1380 FastForwardBy(base::TimeDelta::FromHours(6), false); 1381 1382 // Simulate user activity. 1383 automatic_reboot_manager_->OnUserActivity(NULL); 1384 1385 // Enable automatic reboot after an update has been applied. Verify that the 1386 // device does not reboot immediately. 1387 SetRebootAfterUpdate(true, false); 1388 1389 // Verify that a grace period has started. 1390 VerifyGracePeriod(base::TimeDelta::FromHours(6) + uptime_processing_delay_); 1391 1392 // Verify that unless a non-kiosk-app session is in progress, the device 1393 // eventually reboots. 1394 FastForwardUntilNoTasksRemain(!is_user_logged_in_ || 1395 is_logged_in_as_kiosk_app_); 1396 } 1397 1398 // Chrome is running. An update was applied and a reboot became necessary to 1399 // complete the update process after 6 hours of uptime. The current uptime is 1400 // 10 days. 1401 // Verifies that when the policy to automatically reboot after an update is 1402 // enabled, the device reboots immediately if no non-kiosk-app session is in 1403 // progress because the grace period ended after 6 + 24 hours of uptime. 1404 TEST_P(AutomaticRebootManagerTest, PolicyAfterUpdateAfterGracePeriod) { 1405 task_runner_->SetUptime(base::TimeDelta::FromHours(6)); 1406 1407 // Verify that the device does not reboot immediately. 1408 CreateAutomaticRebootManager(false); 1409 1410 // Notify that an update has been applied and a reboot is necessary. Verify 1411 // that the device does not reboot immediately. 1412 NotifyUpdateRebootNeeded(); 1413 1414 // Fast forward the uptime to 12 hours. Verify that the device does not reboot 1415 // immediately. 1416 FastForwardBy(base::TimeDelta::FromDays(10) - base::TimeDelta::FromHours(6), 1417 false); 1418 1419 // Simulate user activity. 1420 automatic_reboot_manager_->OnUserActivity(NULL); 1421 1422 // Enable automatic rebooting after an update has been applied. Verify that 1423 // unless a non-kiosk-app session is in progress, the the device immediately 1424 // reboots. 1425 SetRebootAfterUpdate(true, !is_user_logged_in_ || is_logged_in_as_kiosk_app_); 1426 1427 // Verify that if a non-kiosk-app session is in progress, the device does not 1428 // reboot eventually. 1429 FastForwardUntilNoTasksRemain(!is_user_logged_in_ || 1430 is_logged_in_as_kiosk_app_); 1431 } 1432 1433 // Chrome is running. An update was applied and a reboot became necessary to 1434 // complete the update process after 6 hours of uptime. The policy to 1435 // automatically reboot after an update is enabled. The current uptime is 1436 // 6 hours 20 seconds. 1437 // Verifies that when the policy to automatically reboot after an update is 1438 // disabled, the reboot request and grace period are removed. 1439 TEST_P(AutomaticRebootManagerTest, PolicyOffAfterUpdate) { 1440 task_runner_->SetUptime(base::TimeDelta::FromHours(6)); 1441 SetRebootAfterUpdate(true, false); 1442 1443 // Verify that the device does not reboot immediately. 1444 CreateAutomaticRebootManager(false); 1445 1446 // Notify that an update has been applied and a reboot is necessary. Verify 1447 // that the device does not reboot immediately. 1448 NotifyUpdateRebootNeeded(); 1449 1450 // Verify that a grace period has started. 1451 VerifyGracePeriod(task_runner_->Uptime() + uptime_processing_delay_); 1452 1453 // Fast forward the uptime by 20 seconds. Verify that the device does not 1454 // reboot immediately. 1455 FastForwardBy(base::TimeDelta::FromSeconds(20), false); 1456 1457 // Disable automatic rebooting after an update has been applied. Verify that 1458 // the device does not reboot immediately. 1459 SetRebootAfterUpdate(false, false); 1460 1461 // Verify that the grace period has been removed. 1462 VerifyNoGracePeriod(); 1463 1464 // Verify that the device does not reboot eventually. 1465 FastForwardUntilNoTasksRemain(false); 1466 } 1467 1468 // Chrome is running. The current uptime is not available. 1469 // Verifies that even if an uptime limit is set, the policy to automatically 1470 // reboot after an update is enabled and an update has been applied, no reboot 1471 // occurs and no grace period is scheduled. Further verifies that no time is 1472 // persisted as the time at which a reboot became necessary. 1473 TEST_P(AutomaticRebootManagerTest, NoUptime) { 1474 // Verify that the device does not reboot immediately. 1475 CreateAutomaticRebootManager(false); 1476 1477 // Set the uptime limit. Verify that the device does not reboot immediately. 1478 SetUptimeLimit(base::TimeDelta::FromHours(6), false); 1479 1480 // Verify that no grace period has started. 1481 VerifyNoGracePeriod(); 1482 1483 // Enable automatic rebooting after an update has been applied. Verify that 1484 // the device does not reboot immediately. 1485 SetRebootAfterUpdate(true, false); 1486 1487 // Verify that no grace period has started. 1488 VerifyNoGracePeriod(); 1489 1490 // Notify that an update has been applied and a reboot is necessary. Verify 1491 // that the device does not reboot immediately. 1492 NotifyUpdateRebootNeeded(); 1493 1494 // Verify that no time is persisted as the time at which a reboot became 1495 // necessary. 1496 EXPECT_FALSE(ReadUpdateRebootNeededUptimeFromFile( 1497 &update_reboot_needed_uptime_)); 1498 1499 // Verify that no grace period has started. 1500 VerifyNoGracePeriod(); 1501 1502 // Verify that the device does not reboot eventually. 1503 FastForwardUntilNoTasksRemain(false); 1504 } 1505 1506 // Chrome is running. The policy to automatically reboot after an update is 1507 // enabled. The current uptime is 12 hours. 1508 // Verifies that when an uptime limit of 6 hours is set, the availability of an 1509 // update does not cause the grace period to be rescheduled. Further verifies 1510 // that the current uptime is persisted as the time at which a reboot became 1511 // necessary. 1512 TEST_P(AutomaticRebootManagerTest, UptimeLimitBeforeUpdate) { 1513 task_runner_->SetUptime(base::TimeDelta::FromHours(12)); 1514 SetRebootAfterUpdate(true, false); 1515 1516 // Verify that the device does not reboot immediately. 1517 CreateAutomaticRebootManager(false); 1518 1519 // Set the uptime limit. Verify that the device does not reboot immediately. 1520 SetUptimeLimit(base::TimeDelta::FromHours(6), false); 1521 1522 // Verify that a grace period has been scheduled to start in the future. 1523 VerifyGracePeriod(uptime_limit_); 1524 1525 // Fast forward the uptime by 20 seconds. Verify that the device does not 1526 // reboot immediately. 1527 FastForwardBy(base::TimeDelta::FromSeconds(20), false); 1528 1529 // Notify that an update has been applied and a reboot is necessary. Verify 1530 // that the device does not reboot immediately. 1531 NotifyUpdateRebootNeeded(); 1532 1533 // Verify that the current uptime has been persisted as the time at which a 1534 // reboot became necessary. 1535 EXPECT_TRUE(ReadUpdateRebootNeededUptimeFromFile( 1536 &update_reboot_needed_uptime_)); 1537 EXPECT_EQ(task_runner_->Uptime(), update_reboot_needed_uptime_); 1538 1539 // Verify that the grace period has not been rescheduled. 1540 VerifyGracePeriod(uptime_limit_); 1541 1542 // Verify that unless a non-kiosk-app session is in progress, the device 1543 // eventually reboots. 1544 FastForwardUntilNoTasksRemain(!is_user_logged_in_ || 1545 is_logged_in_as_kiosk_app_); 1546 } 1547 1548 // Chrome is running. The policy to automatically reboot after an update is 1549 // enabled. The current uptime is 12 hours. 1550 // Verifies that when an uptime limit of 24 hours is set, the availability of an 1551 // update causes the grace period to be rescheduled so that it ends 24 hours 1552 // from now. Further verifies that the current uptime is persisted as the time 1553 // at which a reboot became necessary. 1554 TEST_P(AutomaticRebootManagerTest, UpdateBeforeUptimeLimit) { 1555 task_runner_->SetUptime(base::TimeDelta::FromHours(12)); 1556 SetRebootAfterUpdate(true, false); 1557 1558 // Verify that the device does not reboot immediately. 1559 CreateAutomaticRebootManager(false); 1560 1561 // Set the uptime limit. Verify that the device does not reboot immediately. 1562 SetUptimeLimit(base::TimeDelta::FromHours(24), false); 1563 1564 // Verify that a grace period has been scheduled to start in the future. 1565 VerifyGracePeriod(uptime_limit_); 1566 1567 // Fast forward the uptime by 20 seconds. Verify that the device does not 1568 // reboot immediately. 1569 FastForwardBy(base::TimeDelta::FromSeconds(20), false); 1570 1571 // Notify that an update has been applied and a reboot is necessary. Verify 1572 // that the device does not reboot immediately. 1573 NotifyUpdateRebootNeeded(); 1574 1575 // Verify that the current uptime has been persisted as the time at which a 1576 // reboot became necessary. 1577 EXPECT_TRUE(ReadUpdateRebootNeededUptimeFromFile( 1578 &update_reboot_needed_uptime_)); 1579 EXPECT_EQ(task_runner_->Uptime(), update_reboot_needed_uptime_); 1580 1581 // Verify that the grace period has been rescheduled to start at the time that 1582 // the update became available. 1583 VerifyGracePeriod(update_reboot_needed_uptime_ + uptime_processing_delay_); 1584 1585 // Verify that unless a non-kiosk-app session is in progress, the device 1586 // eventually reboots. 1587 FastForwardUntilNoTasksRemain(!is_user_logged_in_ || 1588 is_logged_in_as_kiosk_app_); 1589 } 1590 1591 // Chrome is running. The uptime limit is set to 24 hours. An update was applied 1592 // and a reboot became necessary to complete the update process after 12 hours. 1593 // The policy to automatically reboot after an update is enabled. The current 1594 // uptime is 12 hours 20 seconds. 1595 // Verifies that when the policy to reboot after an update is disabled, the 1596 // grace period is rescheduled to start after 24 hours of uptime. Further 1597 // verifies that when the uptime limit is removed, the grace period is removed. 1598 TEST_P(AutomaticRebootManagerTest, PolicyOffThenUptimeLimitOff) { 1599 task_runner_->SetUptime(base::TimeDelta::FromHours(12)); 1600 SetRebootAfterUpdate(true, false); 1601 1602 // Verify that the device does not reboot immediately. 1603 CreateAutomaticRebootManager(false); 1604 1605 // Set the uptime limit. Verify that the device does not reboot immediately. 1606 SetUptimeLimit(base::TimeDelta::FromHours(24), false); 1607 1608 // Verify that the grace period has started. 1609 VerifyGracePeriod(uptime_limit_); 1610 1611 // Notify that an update has been applied and a reboot is necessary. Verify 1612 // that the device does not reboot immediately. 1613 NotifyUpdateRebootNeeded(); 1614 1615 // Verify that the current uptime has been persisted as the time at which a 1616 // reboot became necessary. 1617 EXPECT_TRUE(ReadUpdateRebootNeededUptimeFromFile( 1618 &update_reboot_needed_uptime_)); 1619 EXPECT_EQ(task_runner_->Uptime(), update_reboot_needed_uptime_); 1620 1621 // Verify that a grace period has been rescheduled to end 24 hours from now. 1622 VerifyGracePeriod(update_reboot_needed_uptime_ + uptime_processing_delay_); 1623 1624 // Fast forward the uptime by 20 seconds. Verify that the device does not 1625 // reboot immediately. 1626 FastForwardBy(base::TimeDelta::FromSeconds(20), false); 1627 1628 // Disable automatic reboot after an update has been applied. Verify that the 1629 // device does not reboot immediately. 1630 SetRebootAfterUpdate(false, false); 1631 1632 // Verify that the grace period has been rescheduled to start after 24 hours 1633 // of uptime. 1634 VerifyGracePeriod(uptime_limit_); 1635 1636 // Remove the uptime limit. Verify that the device does not reboot 1637 // immediately. 1638 SetUptimeLimit(base::TimeDelta(), false); 1639 1640 // Verify that the grace period has been removed. 1641 VerifyNoGracePeriod(); 1642 1643 // Verify that the device does not reboot eventually. 1644 FastForwardUntilNoTasksRemain(false); 1645 } 1646 1647 // Chrome is running. The uptime limit is set to 6 hours. An update was applied 1648 // and a reboot became necessary to complete the update process after 12 hours. 1649 // The policy to automatically reboot after an update is enabled. The current 1650 // uptime is 12 hours 20 seconds. 1651 // Verifies that when the uptime limit is removed, the grace period is 1652 // rescheduled to have started after 12 hours of uptime. Further verifies that 1653 // when the policy to reboot after an update is disabled, the reboot request and 1654 // grace period are removed. 1655 TEST_P(AutomaticRebootManagerTest, UptimeLimitOffThenPolicyOff) { 1656 task_runner_->SetUptime(base::TimeDelta::FromHours(12)); 1657 SetRebootAfterUpdate(true, false); 1658 1659 // Verify that the device does not reboot immediately. 1660 CreateAutomaticRebootManager(false); 1661 1662 // Notify that an update has been applied and a reboot is necessary. Verify 1663 // that the device does not reboot immediately. 1664 NotifyUpdateRebootNeeded(); 1665 1666 // Verify that the current uptime has been persisted as the time at which a 1667 // reboot became necessary. 1668 EXPECT_TRUE(ReadUpdateRebootNeededUptimeFromFile( 1669 &update_reboot_needed_uptime_)); 1670 EXPECT_EQ(task_runner_->Uptime(), update_reboot_needed_uptime_); 1671 1672 // Verify that the grace period has started. 1673 VerifyGracePeriod(update_reboot_needed_uptime_ + uptime_processing_delay_); 1674 1675 // Set the uptime limit. Verify that the device does not reboot immediately. 1676 SetUptimeLimit(base::TimeDelta::FromHours(6), false); 1677 1678 // Verify that the grace period has been rescheduled to have started after 1679 // 6 hours of uptime. 1680 VerifyGracePeriod(uptime_limit_); 1681 1682 // Fast forward the uptime by 20 seconds. Verify that the device does not 1683 // reboot immediately. 1684 FastForwardBy(base::TimeDelta::FromSeconds(20), false); 1685 1686 // Remove the uptime limit. Verify that the device does not reboot 1687 // immediately. 1688 SetUptimeLimit(base::TimeDelta(), false); 1689 1690 // Verify that a grace period has been rescheduled to have started after 12 1691 // hours of uptime. 1692 VerifyGracePeriod(update_reboot_needed_uptime_ + uptime_processing_delay_); 1693 1694 // Disable automatic reboot after an update has been applied. Verify that the 1695 // device does not reboot immediately. 1696 SetRebootAfterUpdate(false, false); 1697 1698 // Verify that the grace period has been removed. 1699 VerifyNoGracePeriod(); 1700 1701 // Verify that the device does not reboot eventually. 1702 FastForwardUntilNoTasksRemain(false); 1703 } 1704 1705 // Chrome is running. The uptime limit is 6 hours. The current uptime is 1706 // 29 hours 59 minutes 59 seconds. 1707 // Verifies that if no non-kiosk-app session is in progress, the device reboots 1708 // immediately when the grace period ends after 6 + 24 hours of uptime. 1709 TEST_P(AutomaticRebootManagerTest, GracePeriodEnd) { 1710 task_runner_->SetUptime(base::TimeDelta::FromHours(29) + 1711 base::TimeDelta::FromMinutes(59) + 1712 base::TimeDelta::FromSeconds(59)); 1713 1714 // Verify that the device does not reboot immediately. 1715 CreateAutomaticRebootManager(false); 1716 1717 // Set the uptime limit. Verify that the device does not reboot immediately. 1718 SetUptimeLimit(base::TimeDelta::FromHours(6), false); 1719 1720 // Verify that a grace period has started. 1721 VerifyGracePeriod(uptime_limit_); 1722 1723 // Fast forward the uptime by 1 second. Verify that unless a non-kiosk-app 1724 // session is in progress, the the device immediately reboots. 1725 FastForwardBy(base::TimeDelta::FromSeconds(1), !is_user_logged_in_ || 1726 is_logged_in_as_kiosk_app_); 1727 1728 // Verify that if a non-kiosk-app session is in progress, the device does not 1729 // reboot eventually. 1730 FastForwardUntilNoTasksRemain(!is_user_logged_in_ || 1731 is_logged_in_as_kiosk_app_); 1732 } 1733 1734 // Chrome is starting. The current uptime is 10 days. 1735 // Verifies that when no automatic reboot policy is enabled, no reboot occurs 1736 // and no grace period is scheduled. 1737 TEST_P(AutomaticRebootManagerTest, StartNoPolicy) { 1738 task_runner_->SetUptime(base::TimeDelta::FromDays(10)); 1739 1740 // Verify that the device does not reboot immediately. 1741 CreateAutomaticRebootManager(false); 1742 1743 // Verify that no grace period has started. 1744 VerifyNoGracePeriod(); 1745 1746 // Verify that the device does not reboot eventually. 1747 FastForwardUntilNoTasksRemain(false); 1748 } 1749 1750 // Chrome is starting. The uptime limit is set to 24 hours. The current uptime 1751 // is 12 hours. 1752 // Verifies that no reboot occurs and a grace period is scheduled to begin after 1753 // 24 hours of uptime. 1754 TEST_P(AutomaticRebootManagerTest, StartBeforeUptimeLimitGracePeriod) { 1755 SetUptimeLimit(base::TimeDelta::FromHours(24), false); 1756 task_runner_->SetUptime(base::TimeDelta::FromHours(12)); 1757 1758 // Verify that the device does not reboot immediately. 1759 CreateAutomaticRebootManager(false); 1760 1761 // Verify that a grace period has been scheduled to start in the future. 1762 VerifyGracePeriod(uptime_limit_); 1763 1764 // Verify that unless a non-kiosk-app session is in progress, the device 1765 // eventually reboots. 1766 FastForwardUntilNoTasksRemain(!is_user_logged_in_ || 1767 is_logged_in_as_kiosk_app_); 1768 } 1769 1770 // Chrome is starting. The uptime limit is set to 6 hours. The current uptime is 1771 // 10 days. 1772 // Verifies that if no non-kiosk-app session is in progress, the device reboots 1773 // immediately because the grace period ended after 6 + 24 hours of uptime. 1774 TEST_P(AutomaticRebootManagerTest, StartAfterUptimeLimitGracePeriod) { 1775 SetUptimeLimit(base::TimeDelta::FromHours(6), false); 1776 task_runner_->SetUptime(base::TimeDelta::FromDays(10)); 1777 1778 // Verify that unless a non-kiosk-app session is in progress, the the device 1779 // immediately reboots. 1780 CreateAutomaticRebootManager(!is_user_logged_in_ || 1781 is_logged_in_as_kiosk_app_); 1782 1783 // Verify that if a non-kiosk-app session is in progress, the device does not 1784 // reboot eventually. 1785 FastForwardUntilNoTasksRemain(!is_user_logged_in_ || 1786 is_logged_in_as_kiosk_app_); 1787 } 1788 1789 // Chrome is starting. The uptime limit is set to 6 hours. The current uptime is 1790 // 12 hours. 1791 // Verifies that a reboot is requested and a grace period is started that will 1792 // end after 6 + 24 hours of uptime. 1793 TEST_P(AutomaticRebootManagerTest, StartInUptimeLimitGracePeriod) { 1794 SetUptimeLimit(base::TimeDelta::FromHours(6), false); 1795 task_runner_->SetUptime(base::TimeDelta::FromHours(12)); 1796 1797 // Verify that the device does not reboot immediately. 1798 CreateAutomaticRebootManager(false); 1799 1800 // Verify that a grace period has started. 1801 VerifyGracePeriod(uptime_limit_); 1802 1803 // Verify that unless a non-kiosk-app session is in progress, the device 1804 // eventually reboots. 1805 FastForwardUntilNoTasksRemain(!is_user_logged_in_ || 1806 is_logged_in_as_kiosk_app_); 1807 } 1808 1809 // Chrome is starting. An update was applied and a reboot became necessary to 1810 // complete the update process after 6 hours of uptime. The current uptime is 1811 // 10 days. 1812 // Verifies that when the policy to automatically reboot after an update is 1813 // enabled, the device reboots immediately if no non-kiosk-app session is in 1814 // progress because the grace period ended after 6 + 24 hours of uptime. 1815 TEST_P(AutomaticRebootManagerTest, StartAfterUpdateGracePeriod) { 1816 SetUpdateStatusNeedReboot(); 1817 SetUpdateRebootNeededUptime(base::TimeDelta::FromHours(6)); 1818 task_runner_->SetUptime(base::TimeDelta::FromDays(10)); 1819 SetRebootAfterUpdate(true, false); 1820 1821 // Verify that unless a non-kiosk-app session is in progress, the device 1822 // reboots immediately. 1823 CreateAutomaticRebootManager(!is_user_logged_in_ || 1824 is_logged_in_as_kiosk_app_); 1825 1826 // Verify that if a non-kiosk-app session is in progress, the device does not 1827 // reboot eventually. 1828 FastForwardUntilNoTasksRemain(!is_user_logged_in_ || 1829 is_logged_in_as_kiosk_app_); 1830 } 1831 1832 // Chrome is starting. An update was applied and a reboot became necessary to 1833 // complete the update process after 6 hours of uptime. The current uptime is 1834 // 12 hours. 1835 // Verifies that when the policy to automatically reboot after an update is 1836 // enabled, a reboot is requested and a grace period is started that will end 1837 // after 6 + 24 hours of uptime. 1838 TEST_P(AutomaticRebootManagerTest, StartInUpdateGracePeriod) { 1839 SetUpdateStatusNeedReboot(); 1840 SetUpdateRebootNeededUptime(base::TimeDelta::FromHours(6)); 1841 task_runner_->SetUptime(base::TimeDelta::FromHours(12)); 1842 SetRebootAfterUpdate(true, false); 1843 1844 // Verify that the device does not reboot immediately. 1845 CreateAutomaticRebootManager(false); 1846 1847 // Verify that a grace period has started. 1848 VerifyGracePeriod(update_reboot_needed_uptime_); 1849 1850 // Verify that unless a non-kiosk-app session is in progress, the device 1851 // eventually reboots. 1852 FastForwardUntilNoTasksRemain(!is_user_logged_in_ || 1853 is_logged_in_as_kiosk_app_); 1854 } 1855 1856 // Chrome is starting. An update was applied and a reboot became necessary to 1857 // complete the update process after 10 minutes of uptime. The current uptime is 1858 // 20 minutes. 1859 // Verifies that when the policy to automatically reboot after an update is 1860 // enabled, no reboot occurs and a grace period is scheduled to begin after the 1861 // minimum of 1 hour of uptime. 1862 TEST_P(AutomaticRebootManagerTest, StartBeforeUpdateGracePeriod) { 1863 SetUpdateStatusNeedReboot(); 1864 SetUpdateRebootNeededUptime(base::TimeDelta::FromMinutes(10)); 1865 task_runner_->SetUptime(base::TimeDelta::FromMinutes(20)); 1866 SetRebootAfterUpdate(true, false); 1867 1868 // Verify that the device does not reboot immediately. 1869 CreateAutomaticRebootManager(false); 1870 1871 // Verify that a grace period has been scheduled to start in the future. 1872 VerifyGracePeriod(base::TimeDelta::FromHours(1)); 1873 1874 // Verify that unless a non-kiosk-app session is in progress, the device 1875 // eventually reboots. 1876 FastForwardUntilNoTasksRemain(!is_user_logged_in_ || 1877 is_logged_in_as_kiosk_app_); 1878 } 1879 1880 // Chrome is starting. An update was applied and a reboot became necessary to 1881 // complete the update process after 6 hours of uptime. The current uptime is 1882 // 10 days. 1883 // Verifies that when the policy to automatically reboot after an update is not 1884 // enabled, no reboot occurs and no grace period is scheduled. 1885 TEST_P(AutomaticRebootManagerTest, StartUpdateNoPolicy) { 1886 SetUpdateStatusNeedReboot(); 1887 SetUpdateRebootNeededUptime(base::TimeDelta::FromHours(6)); 1888 task_runner_->SetUptime(base::TimeDelta::FromDays(10)); 1889 1890 // Verify that the device does not reboot immediately. 1891 CreateAutomaticRebootManager(false); 1892 1893 // Verify that no grace period has started. 1894 VerifyNoGracePeriod(); 1895 1896 // Verify that the device does not reboot eventually. 1897 FastForwardUntilNoTasksRemain(false); 1898 } 1899 1900 // Chrome is starting. An update was applied and a reboot became necessary to 1901 // complete the update process but the time at which this happened was lost. The 1902 // current uptime is 10 days. 1903 // Verifies that the current uptime is persisted as the time at which a reboot 1904 // became necessary. Further verifies that when the policy to automatically 1905 // reboot after an update is enabled, a reboot is requested and a grace period 1906 // is started that will end 24 hours from now. 1907 TEST_P(AutomaticRebootManagerTest, StartUpdateTimeLost) { 1908 SetUpdateStatusNeedReboot(); 1909 task_runner_->SetUptime(base::TimeDelta::FromDays(10)); 1910 SetRebootAfterUpdate(true, false); 1911 1912 // Verify that the device does not reboot immediately. 1913 CreateAutomaticRebootManager(false); 1914 1915 // Verify that the current uptime has been persisted as the time at which a 1916 // reboot became necessary. 1917 EXPECT_TRUE(ReadUpdateRebootNeededUptimeFromFile( 1918 &update_reboot_needed_uptime_)); 1919 EXPECT_EQ(task_runner_->Uptime(), update_reboot_needed_uptime_); 1920 1921 // Verify that a grace period has started. 1922 VerifyGracePeriod(update_reboot_needed_uptime_ + uptime_processing_delay_); 1923 1924 // Verify that unless a non-kiosk-app session is in progress, the device 1925 // eventually reboots. 1926 FastForwardUntilNoTasksRemain(!is_user_logged_in_ || 1927 is_logged_in_as_kiosk_app_); 1928 } 1929 1930 // Chrome is starting. An update was applied and a reboot became necessary to 1931 // complete the update process but the time at which this happened was lost. The 1932 // current uptime is 10 days. 1933 // Verifies that the current uptime is persisted as the time at which a reboot 1934 // became necessary. Further verifies that when the policy to automatically 1935 // reboot after an update is not enabled, no reboot occurs and no grace period 1936 // is scheduled. 1937 TEST_P(AutomaticRebootManagerTest, StartUpdateNoPolicyTimeLost) { 1938 SetUpdateStatusNeedReboot(); 1939 task_runner_->SetUptime(base::TimeDelta::FromDays(10)); 1940 1941 // Verify that the device does not reboot immediately. 1942 CreateAutomaticRebootManager(false); 1943 1944 // Verify that the current uptime has been persisted as the time at which a 1945 // reboot became necessary. 1946 EXPECT_TRUE(ReadUpdateRebootNeededUptimeFromFile( 1947 &update_reboot_needed_uptime_)); 1948 EXPECT_EQ(task_runner_->Uptime(), update_reboot_needed_uptime_); 1949 1950 // Verify that no grace period has started. 1951 VerifyNoGracePeriod(); 1952 1953 // Verify that the device does not reboot eventually. 1954 FastForwardUntilNoTasksRemain(false); 1955 } 1956 1957 // Chrome is starting. No update has been applied. The current uptime is 1958 // 12 hours. 1959 // Verifies that no time is persisted as the time at which a reboot became 1960 // necessary. Further verifies that no reboot occurs and no grace period is 1961 // scheduled. 1962 TEST_P(AutomaticRebootManagerTest, StartNoUpdate) { 1963 task_runner_->SetUptime(base::TimeDelta::FromHours(12)); 1964 SetRebootAfterUpdate(true, false); 1965 1966 // Verify that the device does not reboot immediately. 1967 CreateAutomaticRebootManager(false); 1968 1969 // Verify that no time is persisted as the time at which a reboot became 1970 // necessary. 1971 EXPECT_FALSE(ReadUpdateRebootNeededUptimeFromFile( 1972 &update_reboot_needed_uptime_)); 1973 1974 // Verify that no grace period has started. 1975 VerifyNoGracePeriod(); 1976 1977 // Verify that the device does not reboot eventually. 1978 FastForwardUntilNoTasksRemain(false); 1979 } 1980 1981 // Chrome is starting. The uptime limit is set to 6 hours. Also, an update was 1982 // applied and a reboot became necessary to complete the update process after 1983 // 8 hours of uptime. The current uptime is 12 hours. 1984 // Verifies that when the policy to automatically reboot after an update is 1985 // enabled, a reboot is requested and a grace period is started that will end 1986 // after 6 + 24 hours of uptime. 1987 TEST_P(AutomaticRebootManagerTest, StartUptimeLimitBeforeUpdate) { 1988 SetUptimeLimit(base::TimeDelta::FromHours(6), false); 1989 SetUpdateStatusNeedReboot(); 1990 SetUpdateRebootNeededUptime(base::TimeDelta::FromHours(8)); 1991 task_runner_->SetUptime(base::TimeDelta::FromHours(12)); 1992 SetRebootAfterUpdate(true, false); 1993 1994 // Verify that the device does not reboot immediately. 1995 CreateAutomaticRebootManager(false); 1996 1997 // Verify that a grace period has started. 1998 VerifyGracePeriod(uptime_limit_); 1999 2000 // Verify that unless a non-kiosk-app session is in progress, the device 2001 // eventually reboots. 2002 FastForwardUntilNoTasksRemain(!is_user_logged_in_ || 2003 is_logged_in_as_kiosk_app_); 2004 } 2005 2006 // Chrome is starting. The uptime limit is set to 8 hours. Also, an update was 2007 // applied and a reboot became necessary to complete the update process after 2008 // 6 hours of uptime. The current uptime is 12 hours. 2009 // Verifies that when the policy to automatically reboot after an update is 2010 // enabled, a reboot is requested and a grace period is started that will end 2011 // after 6 + 24 hours of uptime. 2012 TEST_P(AutomaticRebootManagerTest, StartUpdateBeforeUptimeLimit) { 2013 SetUptimeLimit(base::TimeDelta::FromHours(8), false); 2014 SetUpdateStatusNeedReboot(); 2015 SetUpdateRebootNeededUptime(base::TimeDelta::FromHours(6)); 2016 task_runner_->SetUptime(base::TimeDelta::FromHours(12)); 2017 SetRebootAfterUpdate(true, false); 2018 2019 // Verify that the device does not reboot immediately. 2020 CreateAutomaticRebootManager(false); 2021 2022 // Verify that a grace period has started. 2023 VerifyGracePeriod(update_reboot_needed_uptime_); 2024 2025 // Verify that unless a non-kiosk-app session is in progress, the device 2026 // eventually reboots. 2027 FastForwardUntilNoTasksRemain(!is_user_logged_in_ || 2028 is_logged_in_as_kiosk_app_); 2029 } 2030 2031 // Chrome is starting. The uptime limit is set to 6 hours. Also, an update was 2032 // applied and a reboot became necessary to complete the update process after 2033 // 6 hours of uptime. The current uptime is not available. 2034 // Verifies that even if the policy to automatically reboot after an update is 2035 // enabled, no reboot occurs and no grace period is scheduled. 2036 TEST_P(AutomaticRebootManagerTest, StartNoUptime) { 2037 SetUptimeLimit(base::TimeDelta::FromHours(6), false); 2038 SetUpdateStatusNeedReboot(); 2039 SetUpdateRebootNeededUptime(base::TimeDelta::FromHours(6)); 2040 SetRebootAfterUpdate(true, false); 2041 2042 // Verify that the device does not reboot immediately. 2043 CreateAutomaticRebootManager(false); 2044 2045 // Verify that no grace period has started. 2046 VerifyNoGracePeriod(); 2047 2048 // Verify that the device does not reboot eventually. 2049 FastForwardUntilNoTasksRemain(false); 2050 } 2051 2052 INSTANTIATE_TEST_CASE_P( 2053 AutomaticRebootManagerTestInstance, 2054 AutomaticRebootManagerTest, 2055 ::testing::Values( 2056 AUTOMATIC_REBOOT_MANAGER_TEST_SCENARIO_LOGIN_SCREEN, 2057 AUTOMATIC_REBOOT_MANAGER_TEST_SCENARIO_KIOSK_APP_SESSION, 2058 AUTOMATIC_REBOOT_MANAGER_TEST_SCENARIO_NON_KIOSK_APP_SESSION)); 2059 2060 } // namespace system 2061 } // namespace chromeos 2062