Revert of Fire notifications when reboot is requested, not scheduled

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 14 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/chrome_notification_types.h"
+#include "chrome/browser/chromeos/system/automatic_reboot_manager_observer.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 "components/user_manager/user_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"
 #include "ui/wm/core/user_activity_detector.h"
@@ skipping 98 matching lines @@
   // necessary in base::TimeTicks::Now() ticks.
   update_reboot_needed_time = boot_time + update_reboot_needed_uptime;
   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_reason_(AutomaticRebootManagerObserver::REBOOT_REASON_UNKNOWN),
       reboot_requested_(false),
       weak_ptr_factory_(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,
@@ skipping 55 matching lines @@
     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.
   if (status.status != UpdateEngineClient::UPDATE_STATUS_UPDATED_NEED_REBOOT ||
-      have_update_reboot_needed_time_) {
+      !have_boot_time_ || have_update_reboot_needed_time_) {
     return;
   }
 
   content::BrowserThread::PostBlockingPoolTask(
       FROM_HERE, base::Bind(&SaveUpdateRebootNeededUptime));
 
   update_reboot_needed_time_ = clock_->NowTicks();
   have_update_reboot_needed_time_ = true;
 
   Reschedule();
@@ skipping 70 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;
+    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;
+    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 15 matching lines @@
       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;
-  DCHECK_NE(AutomaticRebootManagerObserver::REBOOT_REASON_UNKNOWN,
-            reboot_reason_);
-  FOR_EACH_OBSERVER(AutomaticRebootManagerObserver,
-                    observers_,
-                    OnRebootRequested(reboot_reason_));
   MaybeReboot(false);
 }
 
 void AutomaticRebootManager::MaybeReboot(bool ignore_session) {
   // Do not reboot if any of the following applies:
   // * No reboot has been requested.
   // * A user is interacting with the login screen.
   // * A session is in progress and |ignore_session| is not set.
   if (!reboot_requested_ ||
       (login_screen_idle_timer_ && login_screen_idle_timer_->IsRunning()) ||
@@ skipping 12 matching lines @@
   }
 
   login_screen_idle_timer_.reset();
   grace_start_timer_.reset();
   grace_end_timer_.reset();
   DBusThreadManager::Get()->GetPowerManagerClient()->RequestRestart();
 }
 
 }  // namespace system
 }  // namespace chromeos