src/chrome/browser/ui/webui/help/version_updater_win.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 "base/memory/ref_counted.h"
   6 #include "base/memory/scoped_ptr.h"
   7 #include "base/memory/weak_ptr.h"
   8 #include "base/strings/string16.h"
   9 #include "base/version.h"
  10 #include "base/win/win_util.h"
  11 #include "base/win/windows_version.h"
  12 #include "chrome/browser/google/google_update_win.h"
  13 #include "chrome/browser/lifetime/application_lifetime.h"
  14 #include "chrome/browser/ui/browser.h"
  15 #include "chrome/browser/ui/webui/help/version_updater.h"
  16 #include "chrome/common/chrome_version_info.h"
  17 #include "chrome/grit/chromium_strings.h"
  18 #include "chrome/grit/generated_resources.h"
  19 #include "chrome/installer/util/browser_distribution.h"
  20 #include "chrome/installer/util/install_util.h"
  21 #include "content/public/browser/browser_thread.h"
  22 #include "content/public/browser/user_metrics.h"
  23 #include "ui/base/l10n/l10n_util.h"
  24 #include "ui/views/widget/widget.h"
  25
  26 using base::UserMetricsAction;
  27 using content::BrowserThread;
  28
  29 namespace {
  30
  31 // Windows implementation of version update functionality, used by the WebUI
  32 // About/Help page.
  33 class VersionUpdaterWin : public VersionUpdater,
  34                           public GoogleUpdateStatusListener {
  35  private:
  36   friend class VersionReader;
  37   friend class VersionUpdater;
  38
  39   // Clients must use VersionUpdater::Create().
  40   VersionUpdaterWin();
  41   virtual ~VersionUpdaterWin();
  42
  43   // VersionUpdater implementation.
  44   virtual void CheckForUpdate(const StatusCallback& callback) OVERRIDE;
  45   virtual void RelaunchBrowser() const OVERRIDE;
  46
  47   // GoogleUpdateStatusListener implementation.
  48   virtual void OnReportResults(GoogleUpdateUpgradeResult result,
  49                                GoogleUpdateErrorCode error_code,
  50                                const base::string16& error_message,
  51                                const base::string16& version) OVERRIDE;
  52
  53   // Update the UI to show the status of the upgrade.
  54   void UpdateStatus(GoogleUpdateUpgradeResult result,
  55                     GoogleUpdateErrorCode error_code,
  56                     const base::string16& error_message);
  57
  58   // Got the intalled version so the handling of the UPGRADE_ALREADY_UP_TO_DATE
  59   // result case can now be completeb on the UI thread.
  60   void GotInstalledVersion(const Version& version);
  61
  62   // Little helper function to create google_updater_.
  63   void CreateGoogleUpdater();
  64
  65   // Helper function to clear google_updater_.
  66   void ClearGoogleUpdater();
  67
  68   // Returns a window that can be used for elevation.
  69   HWND GetElevationParent();
  70
  71   // The class that communicates with Google Update to find out if an update is
  72   // available and asks it to start an upgrade.
  73   scoped_refptr<GoogleUpdate> google_updater_;
  74
  75   // Used for callbacks.
  76   base::WeakPtrFactory<VersionUpdaterWin> weak_factory_;
  77
  78   // Callback used to communicate update status to the client.
  79   StatusCallback callback_;
  80
  81   DISALLOW_COPY_AND_ASSIGN(VersionUpdaterWin);
  82 };
  83
  84 // This class is used to read the version on the FILE thread and then call back
  85 // the version updater in the UI thread. Using a class helps better control
  86 // the lifespan of the Version independently of the lifespan of the version
  87 // updater, which may die while asynchonicity is happening, thus the usage of
  88 // the WeakPtr, which can only be used from the thread that created it.
  89 class VersionReader
  90     : public base::RefCountedThreadSafe<VersionReader> {
  91  public:
  92   explicit VersionReader(
  93       const base::WeakPtr<VersionUpdaterWin>& version_updater)
  94       : version_updater_(version_updater) {
  95   }
  96
  97   void GetVersionFromFileThread() {
  98     BrowserDistribution* dist = BrowserDistribution::GetDistribution();
  99     InstallUtil::GetChromeVersion(dist, false, &installed_version_);
 100     if (!installed_version_.IsValid()) {
 101       // User-level Chrome is not installed, check system-level.
 102       InstallUtil::GetChromeVersion(dist, true, &installed_version_);
 103     }
 104     BrowserThread::PostTask(BrowserThread::UI, FROM_HERE, base::Bind(
 105           &VersionReader::SetVersionInUIThread, this));
 106   }
 107
 108   void SetVersionInUIThread() {
 109     if (version_updater_.get() != NULL)
 110       version_updater_->GotInstalledVersion(installed_version_);
 111   }
 112
 113  private:
 114   friend class base::RefCountedThreadSafe<VersionReader>;
 115
 116   // The version updater that must be called back when we are done.
 117   // We use a weak pointer in case the updater gets destroyed while waiting.
 118   base::WeakPtr<VersionUpdaterWin> version_updater_;
 119
 120   // This is the version that gets read in the FILE thread and set on the
 121   // the updater in the UI thread.
 122   Version installed_version_;
 123 };
 124
 125 VersionUpdaterWin::VersionUpdaterWin()
 126     : weak_factory_(this) {
 127   CreateGoogleUpdater();
 128 }
 129
 130 VersionUpdaterWin::~VersionUpdaterWin() {
 131   // The Google Updater will hold a pointer to the listener until it reports
 132   // status, so that pointer must be cleared when the listener is destoyed.
 133   ClearGoogleUpdater();
 134 }
 135
 136 void VersionUpdaterWin::CheckForUpdate(const StatusCallback& callback) {
 137   callback_ = callback;
 138
 139   // On-demand updates for Chrome don't work in Vista RTM when UAC is turned
 140   // off. So, in this case, the version updater must not mention
 141   // on-demand updates. Silent updates (in the background) should still
 142   // work as before - enabling UAC or installing the latest service pack
 143   // for Vista is another option.
 144   if (!(base::win::GetVersion() == base::win::VERSION_VISTA &&
 145         (base::win::OSInfo::GetInstance()->service_pack().major == 0) &&
 146         !base::win::UserAccountControlIsEnabled())) {
 147     // This could happen if the page got refreshed after results were returned.
 148     if (!google_updater_)
 149       CreateGoogleUpdater();
 150     UpdateStatus(UPGRADE_CHECK_STARTED, GOOGLE_UPDATE_NO_ERROR,
 151                  base::string16());
 152     // Specify false to not upgrade yet.
 153     google_updater_->CheckForUpdate(false, GetElevationParent());
 154   }
 155 }
 156
 157 void VersionUpdaterWin::RelaunchBrowser() const {
 158   chrome::AttemptRestart();
 159 }
 160
 161 void VersionUpdaterWin::OnReportResults(
 162     GoogleUpdateUpgradeResult result, GoogleUpdateErrorCode error_code,
 163     const base::string16& error_message, const base::string16& version) {
 164   // Drop the last reference to the object so that it gets cleaned up here.
 165   ClearGoogleUpdater();
 166   UpdateStatus(result, error_code, error_message);
 167 }
 168
 169 void VersionUpdaterWin::UpdateStatus(GoogleUpdateUpgradeResult result,
 170                                      GoogleUpdateErrorCode error_code,
 171                                      const base::string16& error_message) {
 172   // For Chromium builds it would show an error message.
 173   // But it looks weird because in fact there is no error,
 174   // just the update server is not available for non-official builds.
 175 #if defined(GOOGLE_CHROME_BUILD)
 176   Status status = UPDATED;
 177   base::string16 message;
 178
 179   switch (result) {
 180     case UPGRADE_CHECK_STARTED: {
 181       content::RecordAction(UserMetricsAction("UpgradeCheck_Started"));
 182       status = CHECKING;
 183       break;
 184     }
 185     case UPGRADE_STARTED: {
 186       content::RecordAction(UserMetricsAction("Upgrade_Started"));
 187       status = UPDATING;
 188       break;
 189     }
 190     case UPGRADE_IS_AVAILABLE: {
 191       content::RecordAction(
 192           UserMetricsAction("UpgradeCheck_UpgradeIsAvailable"));
 193       DCHECK(!google_updater_);  // Should have been nulled out already.
 194       CreateGoogleUpdater();
 195       UpdateStatus(UPGRADE_STARTED, GOOGLE_UPDATE_NO_ERROR, base::string16());
 196       // Specify true to upgrade now.
 197       google_updater_->CheckForUpdate(true, GetElevationParent());
 198       return;
 199     }
 200     case UPGRADE_ALREADY_UP_TO_DATE: {
 201       // Google Update reported that Chrome is up-to-date.
 202       // To confirm the updated version is running, the reading
 203       // must be done on the file thread. The rest of this case
 204       // will be handled within GotInstalledVersion.
 205       BrowserThread::PostTask(BrowserThread::FILE, FROM_HERE, base::Bind(
 206             &VersionReader::GetVersionFromFileThread,
 207             new VersionReader(weak_factory_.GetWeakPtr())));
 208       return;
 209     }
 210     case UPGRADE_SUCCESSFUL: {
 211       content::RecordAction(UserMetricsAction("UpgradeCheck_Upgraded"));
 212       status = NEARLY_UPDATED;
 213       break;
 214     }
 215     case UPGRADE_ERROR: {
 216       content::RecordAction(UserMetricsAction("UpgradeCheck_Error"));
 217       status = FAILED;
 218       if (error_code == GOOGLE_UPDATE_DISABLED_BY_POLICY) {
 219         message =
 220             l10n_util::GetStringUTF16(IDS_UPGRADE_DISABLED_BY_POLICY);
 221       } else if (error_code == GOOGLE_UPDATE_DISABLED_BY_POLICY_AUTO_ONLY) {
 222         message =
 223             l10n_util::GetStringUTF16(IDS_UPGRADE_DISABLED_BY_POLICY_MANUAL);
 224       } else {
 225         message =
 226             l10n_util::GetStringFUTF16Int(IDS_UPGRADE_ERROR, error_code);
 227       }
 228
 229       if (!error_message.empty()) {
 230         message +=
 231             l10n_util::GetStringFUTF16(IDS_ABOUT_BOX_ERROR_DURING_UPDATE_CHECK,
 232                                        error_message);
 233       }
 234       break;
 235     }
 236   }
 237
 238   // TODO(mad): Get proper progress value instead of passing 0.
 239   // http://crbug.com/136117
 240   callback_.Run(status, 0, message);
 241 #endif  //  defined(GOOGLE_CHROME_BUILD)
 242 }
 243
 244 void VersionUpdaterWin::GotInstalledVersion(const Version& version) {
 245   // This must be called on the UI thread so that callback_ can be called.
 246   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 247
 248   // Make sure that the latest version is running and if not,
 249   // notify the user by setting the status to NEARLY_UPDATED.
 250   //
 251   // The extra version check is necessary on Windows because the application
 252   // may be already up to date on disk though the running app is still
 253   // out of date.
 254   chrome::VersionInfo version_info;
 255   Version running_version(version_info.Version());
 256   if (!version.IsValid() || version.CompareTo(running_version) <= 0) {
 257     content::RecordAction(
 258         UserMetricsAction("UpgradeCheck_AlreadyUpToDate"));
 259     callback_.Run(UPDATED, 0, base::string16());
 260   } else {
 261     content::RecordAction(UserMetricsAction("UpgradeCheck_AlreadyUpgraded"));
 262     callback_.Run(NEARLY_UPDATED, 0, base::string16());
 263   }
 264 }
 265
 266 void VersionUpdaterWin::CreateGoogleUpdater() {
 267   ClearGoogleUpdater();
 268   google_updater_ = new GoogleUpdate();
 269   google_updater_->set_status_listener(this);
 270 }
 271
 272 void VersionUpdaterWin::ClearGoogleUpdater() {
 273   if (google_updater_) {
 274     google_updater_->set_status_listener(NULL);
 275     google_updater_ = NULL;
 276   }
 277 }
 278
 279 BOOL CALLBACK WindowEnumeration(HWND window, LPARAM param) {
 280   if (IsWindowVisible(window)) {
 281     HWND* returned_window = reinterpret_cast<HWND*>(param);
 282     *returned_window = window;
 283     return FALSE;
 284   }
 285   return TRUE;
 286 }
 287
 288 HWND VersionUpdaterWin::GetElevationParent() {
 289   // Look for a visible window belonging to the UI thread.
 290   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 291   HWND window = NULL;
 292   EnumThreadWindows(GetCurrentThreadId(),
 293                     WindowEnumeration,
 294                     reinterpret_cast<LPARAM>(&window));
 295 #if !defined(USE_AURA)
 296   // If using Aura, we might not have a Visible window in this process. In
 297   // theory Google update can cope with that.
 298   DCHECK(window != NULL) << "Failed to find a valid window handle on thread: "
 299                          << GetCurrentThreadId();
 300 #endif
 301   return window;
 302 }
 303
 304 }  // namespace
 305
 306 VersionUpdater* VersionUpdater::Create() {
 307   return new VersionUpdaterWin;
 308 }