app_mode: Add runtime.onRestartRequired event.

chrome/browser/chromeos/system/automatic_reboot_manager.cc

 // Copyright (c) 2013 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "chrome/browser/chromeos/system/automatic_reboot_manager.h"
 
 #include <fcntl.h>
 #include <sys/stat.h>
 #include <sys/types.h>
 
@@ skipping 15 matching lines @@
 #include "base/prefs/pref_registry_simple.h"
 #include "base/prefs/pref_service.h"
 #include "base/single_thread_task_runner.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/thread_task_runner_handle.h"
 #include "base/threading/sequenced_worker_pool.h"
 #include "base/threading/thread_restrictions.h"
 #include "base/time/tick_clock.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/chromeos/login/user_manager.h"
+#include "chrome/browser/chromeos/system/automatic_reboot_manager_observer.h"
+#include "chrome/browser/profiles/profile_manager.h"
 #include "chrome/common/chrome_notification_types.h"
 #include "chrome/common/pref_names.h"
 #include "chromeos/chromeos_paths.h"
 #include "chromeos/chromeos_switches.h"
 #include "chromeos/dbus/dbus_thread_manager.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/notification_details.h"
 #include "content/public/browser/notification_service.h"
 #include "content/public/browser/notification_source.h"
 
@@ skipping 68 matching lines @@
     return;
   file_util::ScopedFD fd_closer(&fd);
 
   std::string update_reboot_needed_uptime =
       base::DoubleToString(uptime.InSecondsF());
   file_util::WriteFileDescriptor(fd,
                                  update_reboot_needed_uptime.c_str(),
                                  update_reboot_needed_uptime.size());
 }
 
+AutomaticRebootManager* instance = NULL;

[bartfab (slow), 2013/06/17 23:30:59]

Instead of creating more singletons with implicit dependencies, let's pass an
AutomaticRebootManager* to the KioskAppUpdateService constructor.

[xiyuan, 2013/06/20 02:17:12]

Done.

+
 }  // namespace
 
 AutomaticRebootManager::SystemEventTimes::SystemEventTimes()
     : has_boot_time(false),
       has_update_reboot_needed_time(false) {
 }
 
 AutomaticRebootManager::SystemEventTimes::SystemEventTimes(
     const base::TimeDelta& uptime,
     const base::TimeDelta& update_reboot_needed_uptime)
@@ skipping 12 matching lines @@
   has_update_reboot_needed_time = true;
 }
 
 AutomaticRebootManager::AutomaticRebootManager(
     scoped_ptr<base::TickClock> clock)
     : clock_(clock.Pass()),
       have_boot_time_(false),
       have_update_reboot_needed_time_(false),
       reboot_requested_(false),
       weak_ptr_factory_(this) {
+  DCHECK(!instance);

[bartfab (slow), 2013/06/17 23:30:59]

This would require #include <base/logging.h>. However, I do not think we want to
be adding this singleton infrastructure in the first place.

[xiyuan, 2013/06/20 02:17:12]

Code removed.

+  instance = this;
+
   local_state_registrar_.Init(g_browser_process->local_state());
   local_state_registrar_.Add(prefs::kUptimeLimit,
                              base::Bind(&AutomaticRebootManager::Reschedule,
                                         base::Unretained(this)));
   local_state_registrar_.Add(prefs::kRebootAfterUpdate,
                              base::Bind(&AutomaticRebootManager::Reschedule,
                                         base::Unretained(this)));
   notification_registrar_.Add(this, chrome::NOTIFICATION_APP_TERMINATING,
       content::NotificationService::AllSources());
 
@@ skipping 21 matching lines @@
   content::BrowserThread::GetBlockingPool()->PostWorkerTaskWithShutdownBehavior(
       FROM_HERE,
       base::Bind(&GetSystemEventTimes,
                  base::ThreadTaskRunnerHandle::Get(),
                  base::Bind(&AutomaticRebootManager::Init,
                             weak_ptr_factory_.GetWeakPtr())),
       base::SequencedWorkerPool::SKIP_ON_SHUTDOWN);
 }
 
 AutomaticRebootManager::~AutomaticRebootManager() {
+  DCHECK(instance == this);

[bartfab (slow), 2013/06/17 23:30:59]

Nit: DCHECK_EQ()

[xiyuan, 2013/06/20 02:17:12]

Code removed.

+  instance = NULL;
+
   DBusThreadManager* dbus_thread_manager = DBusThreadManager::Get();
   dbus_thread_manager->GetPowerManagerClient()->RemoveObserver(this);
   dbus_thread_manager->GetUpdateEngineClient()->RemoveObserver(this);
   if (ash::Shell::HasInstance())
     ash::Shell::GetInstance()->user_activity_detector()->RemoveObserver(this);
 }
 
+AutomaticRebootManager* AutomaticRebootManager::Get() {
+  return instance;
+}
+
+void AutomaticRebootManager::AddObserver(
+    AutomaticRebootManagerObserver* observer) {
+  observers_.AddObserver(observer);
+}
+
+void AutomaticRebootManager::RemoveObserver(
+    AutomaticRebootManagerObserver* observer) {
+  observers_.RemoveObserver(observer);
+}
+
 void AutomaticRebootManager::SystemResumed(
     const base::TimeDelta& sleep_duration) {
   MaybeReboot(true);
 }
 
 void AutomaticRebootManager::UpdateStatusChanged(
     const UpdateEngineClient::Status& status) {
   // Ignore repeated notifications that a reboot is necessary. This is important
   // so that only the time of the first notification is taken into account and
   // repeated notifications do not postpone the reboot request and grace period.
@@ skipping 82 matching lines @@
 void AutomaticRebootManager::Reschedule() {
   // Safeguard against reboot loops under error conditions: If the boot time is
   // unavailable because /proc/uptime could not be read, do nothing.
   if (!have_boot_time_)
     return;
 
   // Assume that no reboot has been requested.
   reboot_requested_ = false;
 
   const base::TimeDelta kZeroTimeDelta;
+  AutomaticRebootManagerObserver::Reason reboot_reason =
+      AutomaticRebootManagerObserver::REBOOT_REASON_UNKNOWN;
 
   // If an uptime limit is set, calculate the time at which it should cause a
   // reboot to be requested.
   const base::TimeDelta uptime_limit = base::TimeDelta::FromSeconds(
       local_state_registrar_.prefs()->GetInteger(prefs::kUptimeLimit));
   base::TimeTicks reboot_request_time = boot_time_ + uptime_limit;
   bool have_reboot_request_time = uptime_limit != kZeroTimeDelta;
+  if (have_reboot_request_time)
+    reboot_reason = AutomaticRebootManagerObserver::REBOOT_REASON_PERIODIC;
 
   // If the policy to automatically reboot after an update is enabled and an
   // update has been applied, set the time at which a reboot should be
   // requested to the minimum of its current value and the time when the reboot
   // became necessary.
   if (have_update_reboot_needed_time_ &&
       local_state_registrar_.prefs()->GetBoolean(prefs::kRebootAfterUpdate) &&
       (!have_reboot_request_time ||
        update_reboot_needed_time_ < reboot_request_time)) {
     reboot_request_time = update_reboot_needed_time_;
     have_reboot_request_time = true;
+    reboot_reason = AutomaticRebootManagerObserver::REBOOT_REASON_OS_UPDATE;
   }
 
   // If no reboot should be requested, remove any grace period.
   if (!have_reboot_request_time) {
     grace_start_timer_.reset();
     grace_end_timer_.reset();
     return;
   }
 
   // Safeguard against reboot loops: Ensure that the uptime after which a reboot
@@ skipping 14 matching lines @@
   const base::TimeTicks grace_end_time = grace_start_time +
       base::TimeDelta::FromMilliseconds(kGracePeriodMs);
   // Set up a timer for the end of the grace period. If the grace period ended
   // in the past, the timer is still used with its delay set to zero.
   if (!grace_end_timer_)
     grace_end_timer_.reset(new base::OneShotTimer<AutomaticRebootManager>);
   grace_end_timer_->Start(FROM_HERE,
                           std::max(grace_end_time - now, kZeroTimeDelta),
                           base::Bind(&AutomaticRebootManager::Reboot,
                                      base::Unretained(this)));
+
+  DCHECK_NE(AutomaticRebootManagerObserver::REBOOT_REASON_UNKNOWN,
+            reboot_reason);
+  FOR_EACH_OBSERVER(AutomaticRebootManagerObserver,
+                    observers_,
+                    OnRebootScheduled(reboot_reason));
 }
 
 void AutomaticRebootManager::RequestReboot() {
   reboot_requested_ = true;
   MaybeReboot(false);
 }
 
 void AutomaticRebootManager::MaybeReboot(bool ignore_session) {
   // Do not reboot if any of the following applies:
   // * No reboot has been requested.
@@ skipping 16 matching lines @@
   }
 
   login_screen_idle_timer_.reset();
   grace_start_timer_.reset();
   grace_end_timer_.reset();
   DBusThreadManager::Get()->GetPowerManagerClient()->RequestRestart();
 }
 
 }  // namespace system
 }  // namespace chromeos