Show a modified outdated upgrade Bubble for non-enterprise users without auto-update

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"
 #include "base/command_line.h"
 #include "base/files/file_path.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/memory/singleton.h"
 #include "base/path_service.h"
+#include "base/prefs/pref_service.h"
 #include "base/process/launch.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/time/time.h"
 #include "base/version.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/google/google_util.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/chrome_version_info.h"
+#include "chrome/common/pref_names.h"
 #include "content/public/browser/browser_thread.h"
 #include "ui/base/resource/resource_bundle.h"
 
 #if defined(OS_WIN)
+#include "base/win/win_util.h"
 #include "chrome/installer/util/browser_distribution.h"
 #include "chrome/installer/util/google_update_settings.h"
 #include "chrome/installer/util/helper.h"
 #include "chrome/installer/util/install_util.h"
 #elif defined(OS_MACOSX)
 #include "chrome/browser/mac/keystone_glue.h"
 #endif
 
 using content::BrowserThread;
 
 namespace {
 
 // How long (in milliseconds) to wait (each cycle) before checking whether
 // Chrome's been upgraded behind our back.
 const int kCheckForUpgradeMs = 2 * 60 * 60 * 1000;  // 2 hours.
 
 // How long to wait (each cycle) before checking which severity level we should
 // be at. Once we reach the highest severity, the timer will stop.
 const int kNotifyCycleTimeMs = 20 * 60 * 1000;  // 20 minutes.
 
 // Same as kNotifyCycleTimeMs but only used during testing.
 const int kNotifyCycleTimeForTestingMs = 500;  // Half a second.
 
 // The number of days after which we identify a build/install as outdated.
 const uint64 kOutdatedBuildAgeInDays = 12 * 7;
 
+// Return the string that was passed as a value for the
+// kCheckForUpdateIntervalSec switch.
 std::string CmdLineInterval() {
   const CommandLine& cmd_line = *CommandLine::ForCurrentProcess();
   return cmd_line.GetSwitchValueASCII(switches::kCheckForUpdateIntervalSec);
 }
 
+// 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 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) ||
-      cmd_line.HasSwitch(switches::kSimulateOutdated);
+      SimulatingOutdated();
 }
 
 // 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.
 
   return kCheckForUpgradeMs;
 }
 
+// Return true if the current build is one of the unstable channels.
 bool IsUnstableChannel() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
   chrome::VersionInfo::Channel channel = chrome::VersionInfo::GetChannel();
   return channel == chrome::VersionInfo::CHANNEL_DEV ||
          channel == chrome::VersionInfo::CHANNEL_CANARY;
 }
 
 // This task identifies whether we are running an unstable version. And then
 // it unconditionally calls back the provided task.
 void CheckForUnstableChannel(const base::Closure& callback_task,
                              bool* is_unstable_channel) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
   *is_unstable_channel = IsUnstableChannel();
   BrowserThread::PostTask(BrowserThread::UI, FROM_HERE, callback_task);
 }
 
 #if defined(OS_WIN)
+// Return true if the currently running Chrome is a system install.
 bool IsSystemInstall() {
   // Get the version of the currently *installed* instance of Chrome,
   // which might be newer than the *running* instance if we have been
   // upgraded in the background.
   base::FilePath exe_path;
   if (!PathService::Get(base::DIR_EXE, &exe_path)) {
     NOTREACHED() << "Failed to find executable path";
     return false;
   }
 
   return !InstallUtil::IsPerUserInstall(exe_path.value().c_str());
 }
 
-// This task checks the update policy and calls back the task only if automatic
-// updates are allowed. It also identifies whether we are running an unstable
-// channel.
+// This task checks the update policy and calls back the task only if the
+// system is not enrolled in a domain (i.e., not in an enterprise environment).
+// It also identifies if autoupdate is enabled and whether we are running an
+// unstable channel. |is_auto_update_enabled| can be NULL.
 void DetectUpdatability(const base::Closure& callback_task,
-                        bool* is_unstable_channel) {
+                        bool* is_unstable_channel,
+                        bool* is_auto_update_enabled) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
 
   base::string16 app_guid = installer::GetAppGuidForUpdates(IsSystemInstall());
   DCHECK(!app_guid.empty());
-  if (GoogleUpdateSettings::AreAutoupdatesEnabled(app_guid))
+  // Don't try to turn on autoupdate when we failed previously.
+  if (is_auto_update_enabled) {
+    *is_auto_update_enabled =
+        GoogleUpdateSettings::AreAutoupdatesEnabled(app_guid);
+  }
+  // Don't show the update bubbles to entreprise users (i.e., on a domain).
+  if (!base::win::IsEnrolledToDomain())
     CheckForUnstableChannel(callback_task, is_unstable_channel);
 }
 #endif  // defined(OS_WIN)
 
 }  // namespace
 
 UpgradeDetectorImpl::UpgradeDetectorImpl()
     : weak_factory_(this),
       is_unstable_channel_(false),
+      is_auto_update_enabled_(true),
       build_date_(base::GetBuildTime()) {
   CommandLine command_line(*CommandLine::ForCurrentProcess());
   // The different command line switches that affect testing can't be used
   // simultaneously, if they do, here's the precedence order, based on the order
   // 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.
-  // - kSimulateOutdated can work on its own, or with a specified date.
+  // - 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);
     return;
   }
   if (command_line.HasSwitch(switches::kSimulateCriticalUpdate)) {
     UpgradeDetected(UPGRADE_AVAILABLE_CRITICAL);
     return;
   }
-  if (command_line.HasSwitch(switches::kSimulateOutdated)) {
+  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 build_date = command_line.GetSwitchValueASCII(
-        switches::kSimulateOutdated);
+    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(UPGRADE_NEEDED_OUTDATED_INSTALL);
+      UpgradeDetected(
+          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());
 
 #if defined(OS_WIN)
   // Only enable upgrade notifications for official builds.  Chromium has no
   // upgrade channel.
 #if defined(GOOGLE_CHROME_BUILD)
-  // On Windows, there might be a policy preventing updates, so validate
-  // updatability, and then call StartTimerForUpgradeCheck appropriately.
+  // On Windows, there might be a policy/enterprise environment preventing
+  // updates, so validate updatability, and then call StartTimerForUpgradeCheck
+  // appropriately. And don't check for autoupdate if we already attempted to
+  // enable it in the past.
+  bool attempted_enabling_autoupdate = g_browser_process->local_state() &&
+      g_browser_process->local_state()->GetBoolean(
+          prefs::kAttemptedToEnableAutoupdate);
   BrowserThread::PostTask(BrowserThread::FILE, FROM_HERE,
                           base::Bind(&DetectUpdatability,
                                      start_upgrade_check_timer_task,
-                                     &is_unstable_channel_));
+                                     &is_unstable_channel_,
+                                     attempted_enabling_autoupdate ?
+                                         NULL : &is_auto_update_enabled_));
 #endif
 #else
 #if defined(OS_MACOSX)
   // Only enable upgrade notifications if the updater (Keystone) is present.
-  if (!keystone_glue::KeystoneEnabled())
+  if (!keystone_glue::KeystoneEnabled()) {
+    is_auto_update_enabled_ = false;
     return;
+  }
 #elif defined(OS_POSIX)
   // Always enable upgrade notifications regardless of branding.
 #else
   return;
 #endif
   // Check whether the build is an unstable channel before starting the timer.
   BrowserThread::PostTask(BrowserThread::FILE, FROM_HERE,
                           base::Bind(&CheckForUnstableChannel,
                                      start_upgrade_check_timer_task,
                                      &is_unstable_channel_));
-
+#endif
   // Start tracking network time updates.
   network_time_tracker_.Start();
-#endif
 }
 
 UpgradeDetectorImpl::~UpgradeDetectorImpl() {
 }
 
 // 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
 // be interrupted from the UI thread.
@@ skipping 88 matching lines @@
   // 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::DetectOutdatedInstall() {
-  // Only enable the outdated install check if we are running the trial for it,
-  // unless we are simulating an outdated isntall.
-  static bool simulate_outdated = CommandLine::ForCurrentProcess()->HasSwitch(
-      switches::kSimulateOutdated);
+  // 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) {
-    // Also don't show the bubble if we have a brand code that is NOT organic.
     std::string brand;
     if (google_util::GetBrand(&brand) && !google_util::IsOrganic(brand))
       return false;
   }
 
   base::Time network_time;
   base::TimeDelta uncertainty;
   if (!network_time_tracker_.GetNetworkTime(base::TimeTicks::Now(),
                                             &network_time,
                                             &uncertainty)) {
-    return false;
+    // When network time has not been initialized yet, simply rely on the
+    // 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_ >
       base::TimeDelta::FromDays(kOutdatedBuildAgeInDays)) {
-    UpgradeDetected(UPGRADE_NEEDED_OUTDATED_INSTALL);
+    UpgradeDetected(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) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   upgrade_available_ = upgrade_available;
@@ skipping 70 matching lines @@
 
 // static
 UpgradeDetectorImpl* UpgradeDetectorImpl::GetInstance() {
   return Singleton<UpgradeDetectorImpl>::get();
 }
 
 // static
 UpgradeDetector* UpgradeDetector::GetInstance() {
   return UpgradeDetectorImpl::GetInstance();
 }