Add an outdated upgrade bubble view.

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/command_line.h"
 #include "base/file_path.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/memory/singleton.h"
 #include "base/path_service.h"
 #include "base/string_number_conversions.h"
 #include "base/string_util.h"
 #include "base/time.h"
 #include "base/utf_string_conversions.h"
+#include "chrome/common/chrome_notification_types.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/chrome_version_info.h"
 #include "chrome/installer/util/browser_distribution.h"
 #include "content/public/browser/browser_thread.h"
+#include "content/public/browser/notification_service.h"
+#include "content/public/browser/user_metrics.h"
 #include "ui/base/resource/resource_bundle.h"
 
 #if defined(OS_WIN)
+#include "chrome/browser/google/google_update_win.h"
+#include "chrome/installer/util/google_update_settings.h"
 #include "chrome/installer/util/install_util.h"
 #elif defined(OS_MACOSX)
 #include "chrome/browser/mac/keystone_glue.h"
 #elif defined(OS_POSIX)
 #include "base/process_util.h"
 #include "base/version.h"
 #endif
 
 using content::BrowserThread;
 
@@ skipping 25 matching lines @@
 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;
 }
 
-// This task checks the currently running version of Chrome against the
-// installed version. If the installed version is newer, it runs the passed
-// callback task. Otherwise it just deletes the task.
-void DetectUpgradeTask(const base::Closure& upgrade_detected_task,
-                       bool* is_unstable_channel,
-                       bool* is_critical_upgrade) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
-
-  Version installed_version;
-  Version critical_update;
-
 #if defined(OS_WIN)
+// This code can be used by both regular and outdated upgrades.

[Finnur, 2012/12/06 19:53:16]

nit: suggest: by both regular upgrades and for checking for severely outdated
version.

[MAD, 2013/01/22 15:18:29]

This is gone... Reworking the whole thing...

+// |critical_update| can be NULL if not needed.
+void GetInstalledAndCriticalVersion(Version* installed_version,
+                                    Version* critical_update) {
   // 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.
   FilePath exe_path;
   if (!PathService::Get(base::DIR_EXE, &exe_path)) {
     NOTREACHED() << "Failed to find executable path";
     return;
   }
 
   bool system_install =
       !InstallUtil::IsPerUserInstall(exe_path.value().c_str());
 
   // TODO(tommi): Check if using the default distribution is always the right
   // thing to do.
   BrowserDistribution* dist = BrowserDistribution::GetDistribution();
-  InstallUtil::GetChromeVersion(dist, system_install, &installed_version);
+  DCHECK(installed_version);
+  InstallUtil::GetChromeVersion(dist, system_install, installed_version);
 
-  if (installed_version.IsValid()) {
+  if (critical_update && installed_version->IsValid()) {
     InstallUtil::GetCriticalUpdateVersion(dist, system_install,
-                                          &critical_update);
+                                          critical_update);
   }
+}
+#endif  // defined(OS_WIN)
+
+// This task checks the currently running version of Chrome against the
+// installed version. If the installed version is newer, it runs the passed
+// callback task. Otherwise it just deletes the task.
+void DetectUpgradeTask(const base::Closure& upgrade_detected_task,
+                       bool* is_unstable_channel,
+                       bool* is_critical_upgrade) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
+
+  Version installed_version;
+  Version critical_update;
+
+#if defined(OS_WIN)
+  GetInstalledAndCriticalVersion(&installed_version, &critical_update);
 #elif defined(OS_MACOSX)
   installed_version =
       Version(UTF16ToASCII(keystone_glue::CurrentlyInstalledVersion()));
 #elif defined(OS_POSIX)
   // POSIX but not Mac OS X: Linux, etc.
   CommandLine command_line(*CommandLine::ForCurrentProcess());
   command_line.AppendSwitch(switches::kProductVersion);
   std::string reply;
   if (!base::GetAppOutput(command_line, &reply)) {
     DLOG(ERROR) << "Failed to get current file version";
@@ skipping 29 matching lines @@
     *is_critical_upgrade =
         critical_update.IsValid() &&
         (critical_update.CompareTo(running_version) > 0);
 
     // Fire off the upgrade detected task.
     BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
                             upgrade_detected_task);
   }
 }
 
+#if defined(OS_WIN)

[Finnur, 2012/12/06 19:53:16]

I would probably have moved this to a _win.cc file, rather than have it in a
cross-platform file, but would probably also suggest that for another CL to keep
this review simpler.

[MAD, 2013/01/22 15:18:29]

Gone!

+// Implementation of a GoogleUpdateStatusListener (only available on Windows),
+// so we can get the available version and identify if we are outdated.
+class UpgradeStatusListener : public GoogleUpdateStatusListener {
+ public:
+  explicit UpgradeStatusListener(const base::Closure& notify_outdated_callback)
+      : google_updater_(new GoogleUpdate()),
+        got_installed_version_(false),
+        got_available_version_(false),
+        notify_outdated_callback_(notify_outdated_callback) {
+    DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+    google_updater_->set_status_listener(this);
+    // false is for |install_if_newer|, we just want the available version.
+    // And when we use false, we don't need to specify a |window|, so NULL.
+    google_updater_->CheckForUpdate(false, NULL);
+
+    // We use FILE as the thread to get the installed version
+    // since it requires reading a file. And it is safe to use an unretained
+    // this pointer since GetInstalledVersion must be called before destruction.
+    BrowserThread::PostTask(
+        BrowserThread::FILE, FROM_HERE,
+        base::Bind(&UpgradeStatusListener::GetInstalledVersion,
+                   base::Unretained(this)));
+  }
+
+  virtual ~UpgradeStatusListener() {
+    google_updater_->set_status_listener(NULL);
+  }
+
+  // GoogleUpdateStatusListener implementation.
+  virtual void OnReportResults(GoogleUpdateUpgradeResult result,
+                               GoogleUpdateErrorCode error_code,
+                               const string16& error_message,
+                               const string16& version) OVERRIDE {
+    DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+    // The google update class is never supposed to sent these two to listeners.

[Finnur, 2012/12/06 19:53:16]

nit: s/sent/send/

[MAD, 2013/01/22 15:18:29]

Gone!

+    DCHECK(result != UPGRADE_STARTED && result != UPGRADE_CHECK_STARTED);
+
+    // Since false was specified for |install_if_newer|, this shouldn't happen.
+    DCHECK(result != UPGRADE_SUCCESSFUL);
+
+    switch (result) {
+      case UPGRADE_ALREADY_UP_TO_DATE: {
+        // Nothing needs to be done.
+        break;
+      }
+      case UPGRADE_ERROR: {
+        // Record these errors in UMA to see if something should be added here.
+        content::RecordAction(content::UserMetricsAction("UpgradeCheck_Error"));
+        break;
+      }
+      case UPGRADE_IS_AVAILABLE: {
+        available_version_ = Version(UTF16ToASCII(version));
+        break;
+      }
+      default: {
+        NOTREACHED();
+      }
+    }
+    got_available_version_ = true;

[Finnur, 2012/12/06 19:53:16]

This variable is actually misnamed because you don't always get an available
version number, right? Same with got_installed_version.

[MAD, 2013/01/22 15:18:29]

Gone!

+    if (got_installed_version_)
+      CheckForOutdated();
+  }
+
+ private:
+  void GetInstalledVersion() {
+    DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
+    Version installed_version;
+    // We only check for outdated when there are no group policies preventing

[Finnur, 2012/12/06 19:53:16]

s/outdated/outdated version/

[MAD, 2013/01/22 15:18:29]

Gone!

+    // regular upgrades. The test is done here because it needs access to the
+    // registry, which must be done on the FILE thread.
+    BrowserDistribution* distribution = BrowserDistribution::GetDistribution();
+    DCHECK(distribution);
+    if (GoogleUpdateSettings::GetAppUpdatePolicy(distribution->GetAppGuid(),
+                                                 NULL) ==
+        GoogleUpdateSettings::AUTOMATIC_UPDATES) {
+      // An uninitialized install version prevents an outdated notification.

[Finnur, 2012/12/06 19:53:16]

Not sure I understand this comment...

[MAD, 2013/01/22 15:18:29]

Gone!

+      GetInstalledAndCriticalVersion(&installed_version, NULL);
+    }
+    BrowserThread::PostTask(
+        BrowserThread::UI, FROM_HERE,
+        base::Bind(&UpgradeStatusListener::GotInstalledVersion,
+                   base::Unretained(this), installed_version));
+  }
+
+  void GotInstalledVersion(const Version& installed_version) {
+    DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+    installed_version_ = installed_version;
+    got_installed_version_ = true;
+    if (got_available_version_)
+      CheckForOutdated();
+  }
+
+  void CheckForOutdated() {

[Finnur, 2012/12/06 19:53:16]

nit: Suggest: CheckIfOutdatedVersion or NotifyIfOutdatedVersion

[MAD, 2013/01/22 15:18:29]

Gone!

+    DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+    DCHECK(got_available_version_ && got_installed_version_);
+    if (available_version_.IsValid() && installed_version_.IsValid() &&
+        available_version_.components()[0] >
+            installed_version_.components()[0] + 1) {
+      notify_outdated_callback_.Run();
+    }
+    delete this;
+  }
+
+  // The class that communicates with Google Update to find out if an update is
+  // available and asks it to start an upgrade.
+  scoped_refptr<GoogleUpdate> google_updater_;
+
+  // The value returned by GetInstalledAndCriticalVersion might be invalid
+  // so a bool is also needed to identify that we at least tried to read it.
+  Version installed_version_;
+  bool got_installed_version_;
+
+  // The value returned by google_updater_ might also be invalid
+  // so a bool is also needed to identify that we at least tried to read it.
+  Version available_version_;
+  bool got_available_version_;
+
+  // A callback to notify of an outdated install.
+  base::Closure notify_outdated_callback_;
+
+  DISALLOW_COPY_AND_ASSIGN(UpgradeStatusListener);
+};
+
+#endif  // defined(OS_WIN)
+
 }  // namespace
 
 UpgradeDetectorImpl::UpgradeDetectorImpl()
     : ALLOW_THIS_IN_INITIALIZER_LIST(weak_factory_(this)),
       is_unstable_channel_(false) {
   CommandLine command_line(*CommandLine::ForCurrentProcess());
   if (command_line.HasSwitch(switches::kDisableBackgroundNetworking))
     return;
   if (command_line.HasSwitch(switches::kSimulateUpgrade)) {
     UpgradeDetected();
     return;
   }
   // Windows: only enable upgrade notifications for official builds.
   // Mac: only enable them if the updater (Keystone) is present.
   // Linux (and other POSIX): always enable regardless of branding.
 #if (defined(OS_WIN) && defined(GOOGLE_CHROME_BUILD)) || defined(OS_POSIX)
 #if defined(OS_MACOSX)
   if (keystone_glue::KeystoneEnabled())
 #endif
   {
     detect_upgrade_timer_.Start(FROM_HERE,
         base::TimeDelta::FromMilliseconds(GetCheckForUpgradeEveryMs()),
         this, &UpgradeDetectorImpl::CheckForUpgrade);
   }
 #endif
+#if defined(OS_WIN) && defined(GOOGLE_CHROME_BUILD)
+  // On Windows, we also check for an outdated version so we use this listener
+  // of Google update to asynchronously fetch the available version.
+  // This object will self-destruct when done.
+  new UpgradeStatusListener(base::Bind(&UpgradeDetectorImpl::NotifyOutdated,
+                            weak_factory_.GetWeakPtr()));
+#endif  // defined(OS_WIN)
 }
 
 UpgradeDetectorImpl::~UpgradeDetectorImpl() {
 }
 
 void UpgradeDetectorImpl::CheckForUpgrade() {
   weak_factory_.InvalidateWeakPtrs();
   base::Closure callback_task =
       base::Bind(&UpgradeDetectorImpl::UpgradeDetected,
                  weak_factory_.GetWeakPtr());
@@ skipping 73 matching lines @@
     } else if (time_passed >= kLowThreshold) {
       set_upgrade_notification_stage(UPGRADE_ANNOYANCE_LOW);
     } else {
       return;  // Not ready to recommend upgrade.
     }
   }
 
   NotifyUpgradeRecommended();
 }
 
+void UpgradeDetectorImpl::NotifyOutdated() {
+  // Stop the recurring timer (that is checking for changes).
+  detect_upgrade_timer_.Stop();
+  set_upgrade_notification_stage(UPGRADE_ANNOYANCE_CRITICAL);
+
+  content::NotificationService::current()->Notify(
+      chrome::NOTIFICATION_OUTDATED_INSTALL,
+      content::Source<UpgradeDetector>(this),
+      content::NotificationService::NoDetails());
+
+  NotifyUpgradeRecommended();
+}
+
 // static
 UpgradeDetectorImpl* UpgradeDetectorImpl::GetInstance() {
   return Singleton<UpgradeDetectorImpl>::get();
 }
 
 // static
 UpgradeDetector* UpgradeDetector::GetInstance() {
   return UpgradeDetectorImpl::GetInstance();
 }