Elevated install of recovery component (UI part).

chrome/browser/upgrade_detector_impl.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_impl.h"
 
 #include <string>
 
 #include "base/bind.h"
 #include "base/build_time.h"
@@ skipping 54 matching lines @@
 }
 
 // Check if one of the outdated simulation switches was present on the command
 // line.
 bool SimulatingOutdated() {
   const CommandLine& cmd_line = *CommandLine::ForCurrentProcess();
   return cmd_line.HasSwitch(switches::kSimulateOutdated) ||
       cmd_line.HasSwitch(switches::kSimulateOutdatedNoAU);
 }
 
+// Check if elevated recovery simulation switch was present on the command line.
+bool SimulatingElevatedRecovery() {
+  const CommandLine& cmd_line = *CommandLine::ForCurrentProcess();
+  return cmd_line.HasSwitch(switches::kSimulateElevatedRecovery);
+}
+
 // Check if any of the testing switches was present on the command line.
 bool IsTesting() {
   const CommandLine& cmd_line = *CommandLine::ForCurrentProcess();
   return cmd_line.HasSwitch(switches::kSimulateUpgrade) ||
       cmd_line.HasSwitch(switches::kCheckForUpdateIntervalSec) ||
       cmd_line.HasSwitch(switches::kSimulateCriticalUpdate) ||
-      SimulatingOutdated();
+      SimulatingOutdated() ||
+      SimulatingElevatedRecovery();
 }
 
 // How often to check for an upgrade.
 int GetCheckForUpgradeEveryMs() {
   // Check for a value passed via the command line.
   int interval_ms;
   std::string interval = CmdLineInterval();
   if (!interval.empty() && base::StringToInt(interval, &interval_ms))
     return interval_ms * 1000;  // Command line value is in seconds.
 
@@ skipping 107 matching lines @@
   // of the if statements below:
   // - kDisableBackgroundNetworking prevents any of the other command line
   //   switch from being taken into account.
   // - kSimulateUpgrade supersedes critical or outdated upgrade switches.
   // - kSimulateCriticalUpdate has precedence over kSimulateOutdated.
   // - kSimulateOutdatedNoAU has precedence over kSimulateOutdated.
   // - kSimulateOutdated[NoAu] can work on its own, or with a specified date.
   if (command_line.HasSwitch(switches::kDisableBackgroundNetworking))
     return;
   if (command_line.HasSwitch(switches::kSimulateUpgrade)) {
-    UpgradeDetected(UPGRADE_AVAILABLE_REGULAR);
+    UpgradeStatusChanged(UPGRADE_AVAILABLE_REGULAR);
     return;
   }
   if (command_line.HasSwitch(switches::kSimulateCriticalUpdate)) {
-    UpgradeDetected(UPGRADE_AVAILABLE_CRITICAL);
+    UpgradeStatusChanged(UPGRADE_AVAILABLE_CRITICAL);
+    return;
+  }
+  if (SimulatingElevatedRecovery()) {
+    UpgradeStatusChanged(UPGRADE_NEEDS_ELEVATION);
     return;
   }
   if (SimulatingOutdated()) {
     // The outdated simulation can work without a value, which means outdated
     // now, or with a value that must be a well formed date/time string that
     // overrides the build date.
     // Also note that to test with a given time/date, until the network time
     // tracking moves off of the VariationsService, the "variations-server-url"
     // command line switch must also be specified for the service to be
     // available on non GOOGLE_CHROME_BUILD.
     std::string switch_name;
     if (command_line.HasSwitch(switches::kSimulateOutdatedNoAU)) {
       is_auto_update_enabled_ = false;
       switch_name = switches::kSimulateOutdatedNoAU;
     } else {
       switch_name = switches::kSimulateOutdated;
     }
     std::string build_date = command_line.GetSwitchValueASCII(switch_name);
     base::Time maybe_build_time;
     bool result = base::Time::FromString(build_date.c_str(), &maybe_build_time);
     if (result && !maybe_build_time.is_null()) {
       // We got a valid build date simulation so use it and check for upgrades.
       build_date_ = maybe_build_time;
       StartTimerForUpgradeCheck();
     } else {
       // Without a valid date, we simulate that we are already outdated...
-      UpgradeDetected(
+      UpgradeStatusChanged(
           is_auto_update_enabled_ ? UPGRADE_NEEDED_OUTDATED_INSTALL
                                   : UPGRADE_NEEDED_OUTDATED_INSTALL_NO_AU);
     }
     return;
   }
 
   base::Closure start_upgrade_check_timer_task =
       base::Bind(&UpgradeDetectorImpl::StartTimerForUpgradeCheck,
                  weak_factory_.GetWeakPtr());
 
@@ skipping 39 matching lines @@
 }
 
 // static
 base::Version UpgradeDetectorImpl::GetCurrentlyInstalledVersion() {
   return GetCurrentlyInstalledVersionImpl(NULL);
 }
 
 // static
 // This task checks the currently running version of Chrome against the
 // installed version. If the installed version is newer, it calls back
-// UpgradeDetectorImpl::UpgradeDetected using a weak pointer so that it can
+// UpgradeDetectorImpl::UpgradeStatusChanged using a weak pointer so that it can
 // be interrupted from the UI thread.
 void UpgradeDetectorImpl::DetectUpgradeTask(
     base::WeakPtr<UpgradeDetectorImpl> upgrade_detector) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
 
   Version critical_update;
   Version installed_version =
       GetCurrentlyInstalledVersionImpl(&critical_update);
 
   // Get the version of the currently *running* instance of Chrome.
   chrome::VersionInfo version_info;
   if (!version_info.is_valid()) {
     NOTREACHED() << "Failed to get current file version";
+    NotifyNoUpgrade(upgrade_detector);
     return;
   }
   Version running_version(version_info.Version());
   if (!running_version.IsValid()) {
     NOTREACHED();
+    NotifyNoUpgrade(upgrade_detector);
     return;
   }
 
   // |installed_version| may be NULL when the user downgrades on Linux (by
   // switching from dev to beta channel, for example). The user needs a
   // restart in this case as well. See http://crbug.com/46547
   if (!installed_version.IsValid() ||
       (installed_version.CompareTo(running_version) > 0)) {
     // If a more recent version is available, it might be that we are lacking
     // a critical update, such as a zero-day fix.
     UpgradeAvailable upgrade_available = UPGRADE_AVAILABLE_REGULAR;
     if (critical_update.IsValid() &&
         critical_update.CompareTo(running_version) > 0) {
       upgrade_available = UPGRADE_AVAILABLE_CRITICAL;
     }
-
     // Fire off the upgrade detected task.
     BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
-                            base::Bind(&UpgradeDetectorImpl::UpgradeDetected,
-                                       upgrade_detector,
-                                       upgrade_available));
+        base::Bind(&UpgradeDetectorImpl::UpgradeStatusChanged,
+                   upgrade_detector,
+                   upgrade_available));
+  } else {
+    NotifyNoUpgrade(upgrade_detector);
   }
 }
 
 void UpgradeDetectorImpl::StartTimerForUpgradeCheck() {
   detect_upgrade_timer_.Start(FROM_HERE,
       base::TimeDelta::FromMilliseconds(GetCheckForUpgradeEveryMs()),
       this, &UpgradeDetectorImpl::CheckForUpgrade);
 }
 
 void UpgradeDetectorImpl::CheckForUpgrade() {
   // Interrupt any (unlikely) unfinished execution of DetectUpgradeTask, or at
   // least prevent the callback from being executed, because we will potentially
   // call it from within DetectOutdatedInstall() or will post
   // DetectUpgradeTask again below anyway.
   weak_factory_.InvalidateWeakPtrs();
 
+  // No need to check further if elevation is needed to recover Omaha.
+  if (DetectElevationNeeded())
+    return;
+
   // No need to look for upgrades if the install is outdated.
   if (DetectOutdatedInstall())
     return;
 
   // We use FILE as the thread to run the upgrade detection code on all
   // platforms. For Linux, this is because we don't want to block the UI thread
   // while launching a background process and reading its output; on the Mac and
   // on Windows checking for an upgrade requires reading a file.
   BrowserThread::PostTask(BrowserThread::FILE, FROM_HERE,
                           base::Bind(&UpgradeDetectorImpl::DetectUpgradeTask,
                                      weak_factory_.GetWeakPtr()));
 }
 
+bool UpgradeDetectorImpl::DetectElevationNeeded() {
+  PrefService* prefs = g_browser_process->local_state();
+  if (prefs->FindPreference(prefs::kRecoveryComponentNeedsElevation) &&
+      prefs->GetBoolean(prefs::kRecoveryComponentNeedsElevation)) {
+    UpgradeStatusChanged(UPGRADE_NEEDS_ELEVATION);
+    return true;
+  }
+
+  return false;
+}
+
 bool UpgradeDetectorImpl::DetectOutdatedInstall() {
   // Don't show the bubble if we have a brand code that is NOT organic, unless
   // an outdated build is being simulated by command line switches.
   static bool simulate_outdated = SimulatingOutdated();
   if (!simulate_outdated) {
     std::string brand;
     if (google_brand::GetBrand(&brand) && !google_brand::IsOrganic(brand))
       return false;
 
 #if defined(OS_WIN)
@@ skipping 16 matching lines @@
     // machine's current time.
     network_time = base::Time::Now();
   }
 
   if (network_time.is_null() || build_date_.is_null() ||
       build_date_ > network_time) {
     NOTREACHED();
     return false;
   }
 
-  if (network_time - build_date_ >
+  if (simulate_outdated ||
+      network_time - build_date_ >
       base::TimeDelta::FromDays(kOutdatedBuildAgeInDays)) {
-    UpgradeDetected(is_auto_update_enabled_ ?
+    UpgradeStatusChanged(is_auto_update_enabled_ ?
         UPGRADE_NEEDED_OUTDATED_INSTALL :
         UPGRADE_NEEDED_OUTDATED_INSTALL_NO_AU);
     return true;
   }
   // If we simlated an outdated install with a date, we don't want to keep
   // checking for version upgrades, which happens on non-official builds.
-  return simulate_outdated;
-}
-
-void UpgradeDetectorImpl::UpgradeDetected(UpgradeAvailable upgrade_available) {
+  return false;
+}
+
+void UpgradeDetectorImpl::UpgradeStatusChanged(
+    UpgradeAvailable upgrade_available) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   upgrade_available_ = upgrade_available;
-
-  // Stop the recurring timer (that is checking for changes).
-  detect_upgrade_timer_.Stop();
+  if (upgrade_available_ == UPGRADE_AVAILABLE_NONE) {
+    NotifyUpgradeStatusChanged();
+    return;
+  }
 
   NotifyUpgradeDetected();
 
   // Start the repeating timer for notifying the user after a certain period.
   // The called function will eventually figure out that enough time has passed
   // and stop the timer.
   int cycle_time = IsTesting() ?
       kNotifyCycleTimeForTestingMs : kNotifyCycleTimeMs;
   upgrade_notification_timer_.Start(FROM_HERE,
       base::TimeDelta::FromMilliseconds(cycle_time),
-      this, &UpgradeDetectorImpl::NotifyOnUpgrade);
-}
-
-void UpgradeDetectorImpl::NotifyOnUpgrade() {
+      this, &UpgradeDetectorImpl::NotifyUpgradeStatusChanged);
+}
+
+void UpgradeDetectorImpl::NotifyNoUpgrade(
+    base::WeakPtr<UpgradeDetectorImpl> upgrade_detector) {
+  BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
+                          base::Bind(&UpgradeDetectorImpl::UpgradeStatusChanged,
+                                     upgrade_detector,
+                                     UPGRADE_AVAILABLE_NONE));
+}
+
+void UpgradeDetectorImpl::NotifyUpgradeStatusChanged() {
   base::TimeDelta delta = base::Time::Now() - upgrade_detected_time();
 
   // We'll make testing more convenient by switching to seconds of waiting
   // instead of days between flipping severity.
   bool is_testing = IsTesting();
   int64 time_passed = is_testing ? delta.InSeconds() : delta.InHours();
 
   bool is_critical_or_outdated = upgrade_available_ > UPGRADE_AVAILABLE_REGULAR;
   if (is_unstable_channel_) {
     // There's only one threat level for unstable channels like dev and
@@ skipping 27 matching lines @@
 
       // We can't get any higher, baby.
       upgrade_notification_timer_.Stop();
     } else if (time_passed >= kHighThreshold) {
       set_upgrade_notification_stage(UPGRADE_ANNOYANCE_HIGH);
     } else if (time_passed >= kElevatedThreshold) {
       set_upgrade_notification_stage(UPGRADE_ANNOYANCE_ELEVATED);
     } else if (time_passed >= kLowThreshold) {
       set_upgrade_notification_stage(UPGRADE_ANNOYANCE_LOW);
     } else {
-      return;  // Not ready to recommend upgrade.
+      set_upgrade_notification_stage(UPGRADE_ANNOYANCE_NONE);
     }
   }
 
   NotifyUpgradeRecommended();
 }
 
 // static
 UpgradeDetectorImpl* UpgradeDetectorImpl::GetInstance() {
   return Singleton<UpgradeDetectorImpl>::get();
 }
 
 // static
 UpgradeDetector* UpgradeDetector::GetInstance() {
   return UpgradeDetectorImpl::GetInstance();
 }