Switch about box to web ui on Windows.

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 "base/memory/ref_counted.h"
+#include "base/memory/scoped_ptr.h"
+#include "base/memory/weak_ptr.h"
+#include "base/string16.h"
+#include "base/version.h"
+#include "base/win/windows_version.h"
+#include "base/win/win_util.h"
+#include "chrome/browser/google/google_update.h"
+#include "chrome/browser/ui/browser.h"
+#include "chrome/browser/ui/browser_list.h"
+#include "chrome/browser/ui/browser_window.h"
+#include "chrome/browser/ui/webui/help/version_updater.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/browser_thread.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"
+#include "ui/views/widget/widget.h"
+
+using content::BrowserThread;
+using content::UserMetricsAction;
+
+namespace {
+
+views::Widget* GetWidget() {

[James Hawkins, 2012/07/06 21:03:44]

Optional nit: Technically you can forward declare Widget instead of
including widget.h.

[James Hawkins, 2012/07/06 21:03:44]

nit: Document the function, specifically *which* widget is being returned.

[MAD, 2012/07/09 15:07:12]

Done.

[MAD, 2012/07/09 15:07:12]

I can't, I use views::Widget::GetWidgetForNativeWindow().

+  // Find an active browser so we can return it's native window as a widget.
+  Browser* browser = NULL;
+  for (BrowserList::const_iterator browser_iterator = BrowserList::begin();
+       browser_iterator != BrowserList::end(); browser_iterator++) {
+    if ((*browser_iterator)->window()) {
+      browser = *browser_iterator;
+      break;
+    }
+  }
+  if (!browser)
+    return NULL;
+  return views::Widget::GetWidgetForNativeWindow(
+      browser->window()->GetNativeWindow());
+}
+
+class VersionUpdaterWin : public VersionUpdater,

[James Hawkins, 2012/07/06 21:03:44]

nit: Document the class.

[MAD, 2012/07/09 15:07:12]

Done.

+                          public GoogleUpdateStatusListener {
+ private:
+  friend class VersionReader;
+  friend class VersionUpdater;
+
+  // Clients must use VersionUpdater::Create().
+  VersionUpdaterWin();
+  virtual ~VersionUpdaterWin();
+
+  // VersionUpdater implementation.
+  virtual void CheckForUpdate(const StatusCallback& callback) OVERRIDE;
+  virtual void RelaunchBrowser() const OVERRIDE;
+
+  // GoogleUpdateStatusListener implementation.
+  virtual void OnReportResults(GoogleUpdateUpgradeResult result,
+                               GoogleUpdateErrorCode error_code,
+                               const string16& error_message,
+                               const string16& version) OVERRIDE;
+
+  // Update the UI to show the status of the upgrade.
+  void UpdateStatus(GoogleUpdateUpgradeResult result,
+                    GoogleUpdateErrorCode error_code,
+                    const string16& error_message);
+
+  // Got the intalled version so we can complete the handling of the

[James Hawkins, 2012/07/06 21:03:44]

nit: Don't use pronouns in comments (we).  Pronouns are ambiguous.

[MAD, 2012/07/09 15:07:12]

Done.

+  // UPGRADE_ALREADY_UP_TO_DATE result case on th UI thread.
+  void GotInstalledVersion(const Version* version);
+
+  // Little helper function to reset google_updater_.
+  void SetGoogleUpdater();
+
+  // 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_;
+
+  // Used for callbacks.
+  base::WeakPtrFactory<VersionUpdaterWin> weak_factory_;
+
+  // Callback used to communicate update status to the client.
+  StatusCallback callback_;
+
+  DISALLOW_COPY_AND_ASSIGN(VersionUpdaterWin);
+};
+
+// We use this class to read the version on the FILE thread and then call back
+// the version updater in the UI thread. We use a class so that we can control
+// the lifespan of the Version independently of the lifespan of the version
+// updater, which may die while asynchonicity is happening, thus the usage of
+// the WeakPtr, which can only be used from the thread that created it.
+class VersionReader
+    : public base::RefCountedThreadSafe<VersionReader> {
+ public:
+  explicit VersionReader(
+      const base::WeakPtr<VersionUpdaterWin>& version_updater)
+      : version_updater_(version_updater) {
+  }
+
+  void GetVersionFromFileThread() {
+    BrowserDistribution* dist = BrowserDistribution::GetDistribution();

[James Hawkins, 2012/07/06 21:03:44]

Optional nit: Technically you can forward declare BrowserDistribution instead of
including browser_distribution.h.

[MAD, 2012/07/09 15:07:12]

But then I won't be able to call  BrowserDistribution::GetDistribution()

+    installed_version_.reset(InstallUtil::GetChromeVersion(dist, false));
+    if (!installed_version_.get()) {
+      // User-level Chrome is not installed, check system-level.
+      installed_version_.reset(InstallUtil::GetChromeVersion(dist, true));
+    }
+    BrowserThread::PostTask(BrowserThread::UI, FROM_HERE, base::Bind(
+          &VersionReader::SetVersionInUIThread, this));
+  }
+
+  void SetVersionInUIThread() {
+    if (version_updater_.get() != NULL)
+      version_updater_->GotInstalledVersion(installed_version_.get());
+  }
+
+ private:
+  friend class base::RefCountedThreadSafe<VersionReader>;
+
+  base::WeakPtr<VersionUpdaterWin> version_updater_;
+  scoped_ptr<Version> installed_version_;
+};
+
+VersionUpdaterWin::VersionUpdaterWin()
+    : ALLOW_THIS_IN_INITIALIZER_LIST(weak_factory_(this)) {
+  SetGoogleUpdater();
+}
+
+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())) {
+    // This could happen if we already got results, but the page got refreshed.
+    if (!google_updater_)
+      SetGoogleUpdater();
+    UpdateStatus(UPGRADE_CHECK_STARTED, GOOGLE_UPDATE_NO_ERROR, string16());
+    google_updater_->CheckForUpdate(false /* Don't upgrade yet */, GetWidget());
+  }
+}
+
+void VersionUpdaterWin::RelaunchBrowser() const {
+  browser::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) {
+  // For Chromium builds it would show an error message.
+  // But it looks weird because in fact there is no error,
+  // just the update server is not available for non-official builds.
+#if defined(GOOGLE_CHROME_BUILD)
+  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.
+      SetGoogleUpdater();
+      UpdateStatus(UPGRADE_STARTED, GOOGLE_UPDATE_NO_ERROR, string16());
+      google_updater_->CheckForUpdate(true /* Upgrade now */, GetWidget());
+      return;
+    }
+    case UPGRADE_ALREADY_UP_TO_DATE: {
+      // Google Update reported that Chrome is up-to-date.
+      // We need to confirm we are running the updated version.
+      // But we must defer version reading to the file thread...
+      // We'll handle the rest of this case within GotInstalledVersion below.
+      BrowserThread::PostTask(BrowserThread::FILE, FROM_HERE, base::Bind(
+            &VersionReader::GetVersionFromFileThread,
+            new VersionReader(weak_factory_.GetWeakPtr())));
+      return;
+    }
+    case UPGRADE_SUCCESSFUL: {
+      content::RecordAction(UserMetricsAction("UpgradeCheck_Upgraded"));
+      status = NEARLY_UPDATED;
+      break;
+    }
+    case UPGRADE_ERROR: {
+      content::RecordAction(UserMetricsAction("UpgradeCheck_Error"));
+      status = FAILED;
+      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);
+      }
+      if (!error_message.empty()) {
+        message +=
+            l10n_util::GetStringFUTF16(IDS_ABOUT_BOX_ERROR_DURING_UPDATE_CHECK,
+                                       error_message);
+      }
+      break;
+    }
+  }
+
+  // TODO(mad): Get proper progress value instead of passing 0.
+  // http://crbug.com/136117
+  callback_.Run(status, 0, message);
+#endif

[James Hawkins, 2012/07/06 21:03:44]

nit: #endif  // defined(GOOGLE_CHROME_BUILD)

[MAD, 2012/07/09 15:07:12]

Done.

+}
+
+void VersionUpdaterWin::GotInstalledVersion(const Version* version) {
+  // This must be called on the UI thread so that we can call callback_.
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+
+  // Make sure that we are running the latest version and if not,
+  // notify the user by setting the status to NEARLY_UPDATED.
+  //
+  // 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::VersionInfo version_info;
+  scoped_ptr<Version> running_version(
+      Version::GetVersionFromString(version_info.Version()));
+  if (!version || (version->CompareTo(*running_version) <= 0)) {
+    content::RecordAction(
+        UserMetricsAction("UpgradeCheck_AlreadyUpToDate"));
+    callback_.Run(UPDATED, 0, string16());
+  } else {
+    content::RecordAction(UserMetricsAction("UpgradeCheck_AlreadyUpgraded"));
+    callback_.Run(NEARLY_UPDATED, 0, string16());
+  }
+}
+
+void VersionUpdaterWin::SetGoogleUpdater() {
+  google_updater_ = new GoogleUpdate();
+  google_updater_->set_status_listener(this);
+}
+
+}  // namespace
+
+VersionUpdater* VersionUpdater::Create() {
+  return new VersionUpdaterWin;
+}