Make UpgradeDetector listen to VariationsService changes.

chrome/browser/upgrade_detector.cc

 // Copyright (c) 2012 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/upgrade_detector.h"
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/prefs/pref_registry_simple.h"
 #include "chrome/browser/chrome_notification_types.h"
@@ skipping 41 matching lines @@
       return IDR_UPDATE_MENU_SEVERITY_HIGH;
     case UPGRADE_ANNOYANCE_CRITICAL:
       return IDR_UPDATE_MENU_SEVERITY_HIGH;
   }
   NOTREACHED();
   return 0;
 }
 
 UpgradeDetector::UpgradeDetector()
     : upgrade_available_(UPGRADE_AVAILABLE_NONE),
+      best_effort_experiment_updates_available_(false),
+      critical_experiment_updates_available_(false),
       critical_update_acknowledged_(false),
       upgrade_notification_stage_(UPGRADE_ANNOYANCE_NONE),
       notify_upgrade_(false) {
 }
 
 UpgradeDetector::~UpgradeDetector() {
 }
 
-void UpgradeDetector::NotifyUpgradeDetected() {
-  upgrade_detected_time_ = base::Time::Now();
-  critical_update_acknowledged_ = false;
-}
-
 void UpgradeDetector::NotifyUpgradeRecommended() {
   notify_upgrade_ = true;
 
-  content::NotificationService::current()->Notify(
-      chrome::NOTIFICATION_UPGRADE_RECOMMENDED,
-      content::Source<UpgradeDetector>(this),
-      content::NotificationService::NoDetails());
+  TriggerNotification(chrome::NOTIFICATION_UPGRADE_RECOMMENDED);
+  if (upgrade_available_ == UPGRADE_NEEDED_OUTDATED_INSTALL) {
+    TriggerNotification(chrome::NOTIFICATION_OUTDATED_INSTALL);
+  } else if (upgrade_available_ == UPGRADE_NEEDED_OUTDATED_INSTALL_NO_AU) {
+    TriggerNotification(chrome::NOTIFICATION_OUTDATED_INSTALL_NO_AU);
+  } else if (upgrade_available_ == UPGRADE_AVAILABLE_CRITICAL ||
+      critical_experiment_updates_available_) {

[sky, 2014/08/04 18:24:07]

nit: align with ( on previous line.

[Alexei Svitkine (slow), 2014/08/04 19:43:10]

Done.

+    TriggerCriticalUpdate();
+  }
+}
 
-  switch (upgrade_available_) {
-    case UPGRADE_NEEDED_OUTDATED_INSTALL: {
-      content::NotificationService::current()->Notify(
-          chrome::NOTIFICATION_OUTDATED_INSTALL,
-          content::Source<UpgradeDetector>(this),
-          content::NotificationService::NoDetails());
-      break;
-    }
-    case UPGRADE_NEEDED_OUTDATED_INSTALL_NO_AU: {
-      content::NotificationService::current()->Notify(
-          chrome::NOTIFICATION_OUTDATED_INSTALL_NO_AU,
-          content::Source<UpgradeDetector>(this),
-          content::NotificationService::NoDetails());
-      break;
-    }
-    case UPGRADE_AVAILABLE_CRITICAL: {
-      int idle_timer = UseTestingIntervals() ?
-          kIdleRepeatingTimerWait :
-          kIdleRepeatingTimerWait * 60;  // To minutes.
-      idle_check_timer_.Start(FROM_HERE,
-          base::TimeDelta::FromSeconds(idle_timer),
-          this, &UpgradeDetector::CheckIdle);
-      break;
-    }
-    default:
-      break;
-  }
+void UpgradeDetector::TriggerCriticalUpdate() {
+  const base::TimeDelta idle_timer = UseTestingIntervals() ?
+      base::TimeDelta::FromSeconds(kIdleRepeatingTimerWait) :
+      base::TimeDelta::FromMinutes(kIdleRepeatingTimerWait);
+  idle_check_timer_.Start(FROM_HERE, idle_timer, this,
+                          &UpgradeDetector::CheckIdle);
 }
 
 void UpgradeDetector::CheckIdle() {
   // CalculateIdleState expects an interval in seconds.
   int idle_time_allowed = UseTestingIntervals() ? kIdleAmount :
                                                   kIdleAmount * 60 * 60;
 
   CalculateIdleState(
       idle_time_allowed, base::Bind(&UpgradeDetector::IdleCallback,
                                     base::Unretained(this)));
 }
 
+void UpgradeDetector::TriggerNotification(chrome::NotificationType type) {
+  content::NotificationService::current()->Notify(
+      type,
+      content::Source<UpgradeDetector>(this),
+      content::NotificationService::NoDetails());
+}
+
 void UpgradeDetector::IdleCallback(IdleState state) {
   // Don't proceed while an incognito window is open. The timer will still
   // keep firing, so this function will get a chance to re-evaluate this.
   if (chrome::IsOffTheRecordSessionActive())
     return;
 
   switch (state) {
     case IDLE_STATE_LOCKED:
       // Computer is locked, auto-restart.
       idle_check_timer_.Stop();
       chrome::AttemptRestart();
       break;
     case IDLE_STATE_IDLE:
       // Computer has been idle for long enough, show warning.
       idle_check_timer_.Stop();
-      content::NotificationService::current()->Notify(
-          chrome::NOTIFICATION_CRITICAL_UPGRADE_INSTALLED,
-          content::Source<UpgradeDetector>(this),
-          content::NotificationService::NoDetails());
+      TriggerNotification(chrome::NOTIFICATION_CRITICAL_UPGRADE_INSTALLED);
       break;
     case IDLE_STATE_ACTIVE:
     case IDLE_STATE_UNKNOWN:
       break;
     default:
       NOTREACHED();  // Need to add any new value above (either providing
                      // automatic restart or show notification to user).
       break;
   }
 }