Help: Implement version updating on Win.

chrome/browser/ui/webui/help/version_updater_win.cc

+// Use of this source code is governed by a BSD-style license that can be
+// Copyright (c) 2012 The Chromium Authors. All rights reserved.
+// found in the LICENSE file.
+
+#include "chrome/browser/ui/webui/help/version_updater_win.h"
+
+#include "base/i18n/rtl.h"
+#include "base/logging.h"
+#include "base/memory/scoped_ptr.h"
+#include "base/string16.h"
+#include "base/threading/thread_restrictions.h"
+#include "base/version.h"
+#include "base/win/windows_version.h"
+#include "base/win/win_util.h"
+#include "chrome/browser/ui/browser_list.h"
+#include "chrome/common/chrome_version_info.h"
+#include "chrome/installer/util/browser_distribution.h"
+#include "chrome/installer/util/install_util.h"
+#include "content/public/browser/user_metrics.h"
+#include "grit/chromium_strings.h"
+#include "grit/generated_resources.h"
+#include "ui/base/l10n/l10n_util.h"
+
+using content::UserMetricsAction;
+
+VersionUpdater* VersionUpdater::Create() {
+  return new VersionUpdaterWin;
+}
+
+VersionUpdaterWin::VersionUpdaterWin()
+    : google_updater_(new GoogleUpdate()) {
+  google_updater_->set_status_listener(this);
+}
+
+VersionUpdaterWin::~VersionUpdaterWin() {
+  // The Google Updater will hold a pointer to us until it reports status, so we
+  // need to let it know that we will no longer be listening.
+  if (google_updater_)
+    google_updater_->set_status_listener(NULL);
+}
+
+void VersionUpdaterWin::CheckForUpdate(const StatusCallback& callback) {
+  callback_ = callback;
+
+  // On-demand updates for Chrome don't work in Vista RTM when UAC is turned
+  // off. So, in this case we just want the About box to not mention
+  // on-demand updates. Silent updates (in the background) should still
+  // work as before - enabling UAC or installing the latest service pack
+  // for Vista is another option.
+  if (!(base::win::GetVersion() == base::win::VERSION_VISTA &&
+        (base::win::OSInfo::GetInstance()->service_pack().major == 0) &&
+        !base::win::UserAccountControlIsEnabled())) {
+    UpdateStatus(UPGRADE_CHECK_STARTED, GOOGLE_UPDATE_NO_ERROR, string16());
+    google_updater_->CheckForUpdate(false,  // Don't upgrade yet.
+                                    NULL);  // No window widget.

[Finnur, 2012/03/16 12:03:22]

How does setting a NULL window widget work when update needs to show the UAC
prompts with Vista/Windows?

[James Hawkins, 2012/03/26 23:18:14]

I didn't quite understand the requirement of the widget.  If this object is
eventually the only code that calls the updater, it seems like we can remove
this parameter from the API and have CheckForUpdate() handle the code for
acquiring the top-level browser widget.

[Finnur, 2012/03/27 10:44:25]

InitiateGoogleUpdateCheck needs the widget for elevation. It seems simpler to me
to just call GetWidget() here (like the old code does), as opposed to having
CheckForUpdate figure out which widget to use. #shrug#

[James Hawkins, 2012/03/28 20:52:32]

We don't have a GetWidget() for WebUI.  So you're saying we definitely need to
have access to the widget of the browser window containing the WebUI page?

[Finnur, 2012/03/28 22:09:12]

Oh, I see. In that case it doesn't matter, I guess, at what point we obtain the
widget -- whether we do it here or inside CheckForUpdate, as you suggested
(which makes sense now).

I'm not sure it matters which Chrome window we obtain to get the widget as long
as we get a valid HWND from it, but Ananta would know (I think he added this
code).

I do believe, though, that elevation on Vista won't work without *a* widget.

On 2012/03/28 20:52:32, James Hawkins wrote:

[ananta, 2012/03/30 20:52:54]

I don't remember adding this code :(. However Finnur's comment about using any
available HWND does make sense. It would be great if we could test this to be
sure.

+  }
+}
+
+void VersionUpdaterWin::RelaunchBrowser() const {
+  BrowserList::AttemptRestart();
+}
+
+void VersionUpdaterWin::OnReportResults(
+    GoogleUpdateUpgradeResult result, GoogleUpdateErrorCode error_code,
+    const string16& error_message, const string16& version) {
+  // Drop the last reference to the object so that it gets cleaned up here.
+  google_updater_ = NULL;
+  UpdateStatus(result, error_code, error_message);
+}
+
+void VersionUpdaterWin::UpdateStatus(GoogleUpdateUpgradeResult result,
+                                     GoogleUpdateErrorCode error_code,
+                                     const string16& error_message) {

[Finnur, 2012/03/16 12:03:22]

Where's the check to make sure we don't try to upgrade chromium builds?

[James Hawkins, 2012/03/26 23:18:14]

Done.

+  Status status = UPDATED;
+  string16 message;
+
+  switch (result) {
+    case UPGRADE_CHECK_STARTED: {
+      content::RecordAction(UserMetricsAction("UpgradeCheck_Started"));
+      status = CHECKING;
+      break;
+    }
+    case UPGRADE_STARTED: {
+      content::RecordAction(UserMetricsAction("Upgrade_Started"));
+      status = UPDATING;
+      break;
+    }
+    case UPGRADE_IS_AVAILABLE: {
+      content::RecordAction(
+          UserMetricsAction("UpgradeCheck_UpgradeIsAvailable"));
+      DCHECK(!google_updater_);  // Should have been nulled out already.
+      google_updater_ = new GoogleUpdate();
+      google_updater_->set_status_listener(this);
+      UpdateStatus(UPGRADE_STARTED, GOOGLE_UPDATE_NO_ERROR, string16());
+      google_updater_->CheckForUpdate(true,   // Upgrade now.
+                                      NULL);  // No window widget.

[Finnur, 2012/03/16 12:03:22]

Is the page that shows this a singleton or can the user get frustrated with how
long it takes to upgrade and open a new page and start the upgrade process
again?

(Also: window widget == NULL)

[James Hawkins, 2012/03/26 23:18:14]

chrome:chrome (and thus the help page) is a singleton.

+      return;
+    }
+    case UPGRADE_ALREADY_UP_TO_DATE: {
+      // The extra version check is necessary on Windows because the application
+      // may be already up to date on disk though the running app is still
+      // out of date. Chrome OS doesn't quite have this issue since the
+      // OS/App are updated together. If a newer version of the OS has been
+      // staged then UPGRADE_SUCESSFUL will be returned.

[Finnur, 2012/03/16 12:03:22]

nit: Separate these two clauses with linebreak and move lines 100-104 below 107.

[James Hawkins, 2012/03/26 23:18:14]

Done.

+      // Google Update reported that Chrome is up-to-date. Now make sure that we
+      // are running the latest version and if not, notify the user by falling
+      // into the next case of UPGRADE_SUCCESSFUL.
+      BrowserDistribution* dist = BrowserDistribution::GetDistribution();
+      base::ThreadRestrictions::ScopedAllowIO allow_io;
+      chrome::VersionInfo version_info;
+      scoped_ptr<Version> installed_version(
+          InstallUtil::GetChromeVersion(dist, false));
+      if (!installed_version.get()) {
+        // User-level Chrome is not installed, check system-level.
+        installed_version.reset(InstallUtil::GetChromeVersion(dist, true));
+      }
+      scoped_ptr<Version> running_version(
+          Version::GetVersionFromString(version_info.Version()));
+      if (!installed_version.get() ||
+          (installed_version->CompareTo(*running_version) <= 0)) {
+        content::RecordAction(
+            UserMetricsAction("UpgradeCheck_AlreadyUpToDate"));
+        status = UPDATED;
+        break;
+      }
+      // No break here as we want to notify user about upgrade if there is one.
+    }
+    case UPGRADE_SUCCESSFUL: {
+      if (result == UPGRADE_ALREADY_UP_TO_DATE)
+        content::RecordAction(
+            UserMetricsAction("UpgradeCheck_AlreadyUpgraded"));
+      else
+        content::RecordAction(UserMetricsAction("UpgradeCheck_Upgraded"));

[Finnur, 2012/03/16 12:03:22]

You need braces (multiline).

Alternatively (since this is so much simplified), you can just do:

content::RecordAction(UserMetricsAction("UpgradeCheck_AlreadyUpgraded"));
status = NEARLY_UPDATED;
break;

... on line 126 and leave just the else clause plus what is below this line.

(Unless you think the UPGRADE_SUCCESSFUL logic will grow in the future?)

[James Hawkins, 2012/03/26 23:18:14]

Done.

+      status = NEARLY_UPDATED;
+      break;
+    }
+    case UPGRADE_ERROR: {
+      content::RecordAction(UserMetricsAction("UpgradeCheck_Error"));
+      status = FAILED;
+      if (!error_message.empty()) {
+        message =
+            l10n_util::GetStringFUTF16(IDS_ABOUT_BOX_ERROR_DURING_UPDATE_CHECK,
+                                       error_message);
+      }
+      if (error_code != GOOGLE_UPDATE_DISABLED_BY_POLICY) {
+        message =
+            l10n_util::GetStringFUTF16Int(IDS_UPGRADE_ERROR, error_code);
+      } else {
+        message =
+            l10n_util::GetStringUTF16(IDS_UPGRADE_DISABLED_BY_POLICY);
+      }
+      break;
+    }
+  }
+
+  callback_.Run(status, 0, message);
+}