chrome/browser/chromeos/upgrade_detector_chromeos.cc

   1 // Copyright (c) 2012 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/upgrade_detector_chromeos.h"
   6
   7 #include "base/memory/singleton.h"
   8 #include "chromeos/dbus/dbus_thread_manager.h"
   9 #include "chromeos/dbus/update_engine_client.h"
  10
  11 using chromeos::DBusThreadManager;
  12 using chromeos::UpdateEngineClient;
  13
  14 namespace {
  15
  16 // How long to wait (each cycle) before checking which severity level we should
  17 // be at. Once we reach the highest severity, the timer will stop.
  18 const int kNotifyCycleTimeMs = 20 * 60 * 1000;  // 20 minutes.
  19
  20 }  // namespace
  21
  22 class UpgradeDetectorChromeos::ChannelsRequester {
  23  public:
  24   typedef base::Callback<void(const std::string&, const std::string&)>
  25       OnChannelsReceivedCallback;
  26
  27   ChannelsRequester() : weak_factory_(this) {}
  28
  29   void RequestChannels(const OnChannelsReceivedCallback& callback) {
  30     UpdateEngineClient* client =
  31         DBusThreadManager::Get()->GetUpdateEngineClient();
  32     callback_ = callback;
  33     client->GetChannel(true /* get_current_channel */,
  34                        base::Bind(&ChannelsRequester::SetCurrentChannel,
  35                                   weak_factory_.GetWeakPtr()));
  36     client->GetChannel(false /* get_current_channel */,
  37                        base::Bind(&ChannelsRequester::SetTargetChannel,
  38                                   weak_factory_.GetWeakPtr()));
  39   }
  40
  41  private:
  42   void SetCurrentChannel(const std::string& current_channel) {
  43     DCHECK(!current_channel.empty());
  44     current_channel_ = current_channel;
  45     TriggerCallbackIfReady();
  46   }
  47
  48   void SetTargetChannel(const std::string& target_channel) {
  49     DCHECK(!target_channel.empty());
  50     target_channel_ = target_channel;
  51     TriggerCallbackIfReady();
  52   }
  53
  54   void TriggerCallbackIfReady() {
  55     if (current_channel_.empty() || target_channel_.empty())
  56       return;
  57     if (!callback_.is_null())
  58       callback_.Run(current_channel_, target_channel_);
  59   }
  60
  61   std::string current_channel_;
  62   std::string target_channel_;
  63
  64   OnChannelsReceivedCallback callback_;
  65
  66   base::WeakPtrFactory<ChannelsRequester> weak_factory_;
  67
  68   DISALLOW_COPY_AND_ASSIGN(ChannelsRequester);
  69 };
  70
  71 UpgradeDetectorChromeos::UpgradeDetectorChromeos()
  72     : initialized_(false), weak_factory_(this) {
  73 }
  74
  75 UpgradeDetectorChromeos::~UpgradeDetectorChromeos() {
  76 }
  77
  78 void UpgradeDetectorChromeos::Init() {
  79   DBusThreadManager::Get()->GetUpdateEngineClient()->AddObserver(this);
  80   initialized_ = true;
  81 }
  82
  83 void UpgradeDetectorChromeos::Shutdown() {
  84   // Init() may not be called from tests.
  85   if (!initialized_)
  86     return;
  87   DBusThreadManager::Get()->GetUpdateEngineClient()->RemoveObserver(this);
  88 }
  89
  90 void UpgradeDetectorChromeos::UpdateStatusChanged(
  91     const UpdateEngineClient::Status& status) {
  92   if (status.status != UpdateEngineClient::UPDATE_STATUS_UPDATED_NEED_REBOOT)
  93     return;
  94
  95   upgrade_detected_time_ = base::Time::Now();
  96
  97   channels_requester_.reset(new UpgradeDetectorChromeos::ChannelsRequester());
  98   channels_requester_->RequestChannels(
  99       base::Bind(&UpgradeDetectorChromeos::OnChannelsReceived,
 100                  weak_factory_.GetWeakPtr()));
 101 }
 102
 103 void UpgradeDetectorChromeos::NotifyOnUpgrade() {
 104   base::TimeDelta delta = base::Time::Now() - upgrade_detected_time_;
 105   int64 time_passed = delta.InDays();
 106
 107   const int kSevereThreshold = 7;
 108   const int kHighThreshold = 4;
 109   const int kElevatedThreshold = 2;
 110   const int kLowThreshold = 0;
 111
 112   // These if statements must be sorted (highest interval first).
 113   if (time_passed >= kSevereThreshold) {
 114     set_upgrade_notification_stage(UPGRADE_ANNOYANCE_SEVERE);
 115
 116     // We can't get any higher, baby.
 117     upgrade_notification_timer_.Stop();
 118   } else if (time_passed >= kHighThreshold) {
 119     set_upgrade_notification_stage(UPGRADE_ANNOYANCE_HIGH);
 120   } else if (time_passed >= kElevatedThreshold) {
 121     set_upgrade_notification_stage(UPGRADE_ANNOYANCE_ELEVATED);
 122   } else if (time_passed >= kLowThreshold) {
 123     set_upgrade_notification_stage(UPGRADE_ANNOYANCE_LOW);
 124   } else {
 125     return;  // Not ready to recommend upgrade.
 126   }
 127
 128   NotifyUpgradeRecommended();
 129 }
 130
 131 void UpgradeDetectorChromeos::OnChannelsReceived(
 132     const std::string& current_channel,
 133     const std::string& target_channel) {
 134   // As current update engine status is UPDATE_STATUS_UPDATED_NEED_REBOOT
 135   // and target channel is more stable than current channel, powerwash
 136   // will be performed after reboot.
 137   set_is_factory_reset_required(UpdateEngineClient::IsTargetChannelMoreStable(
 138       current_channel, target_channel));
 139
 140   // ChromeOS shows upgrade arrow once the upgrade becomes available.
 141   NotifyOnUpgrade();
 142
 143   // Setup timer to to move along the upgrade advisory system.
 144   upgrade_notification_timer_.Start(
 145       FROM_HERE,
 146       base::TimeDelta::FromMilliseconds(kNotifyCycleTimeMs),
 147       this,
 148       &UpgradeDetectorChromeos::NotifyOnUpgrade);
 149 }
 150
 151 // static
 152 UpgradeDetectorChromeos* UpgradeDetectorChromeos::GetInstance() {
 153   return Singleton<UpgradeDetectorChromeos>::get();
 154 }
 155
 156 // static
 157 UpgradeDetector* UpgradeDetector::GetInstance() {
 158   return UpgradeDetectorChromeos::GetInstance();
 159 }