Modernize on-demand update checks on Windows.

chrome/browser/ui/webui/help/version_updater_win.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 "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/memory/weak_ptr.h"
 #include "base/strings/string16.h"
 #include "base/version.h"
 #include "base/win/win_util.h"
@@ skipping 10 matching lines @@
 #include "content/public/browser/browser_thread.h"
 #include "ui/base/l10n/l10n_util.h"
 #include "ui/views/widget/widget.h"
 
 using content::BrowserThread;
 
 namespace {
 
 // Windows implementation of version update functionality, used by the WebUI
 // About/Help page.
-class VersionUpdaterWin : public VersionUpdater,
-                          public GoogleUpdateStatusListener {
+class VersionUpdaterWin : public VersionUpdater {
  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 base::string16& error_message,
-                               const base::string16& version) override;
+  // chrome::UpdateCheckCallback.
+  void OnUpdateCheckResults(GoogleUpdateUpgradeResult result,
+                            GoogleUpdateErrorCode error_code,
+                            const base::string16& error_message,
+                            const base::string16& version);
 
   // Update the UI to show the status of the upgrade.
   void UpdateStatus(GoogleUpdateUpgradeResult result,
                     GoogleUpdateErrorCode error_code,
                     const base::string16& error_message);
 
   // Got the intalled version so the handling of the UPGRADE_ALREADY_UP_TO_DATE
   // result case can now be completeb on the UI thread.
   void GotInstalledVersion(const Version& version);
 
-  // Little helper function to create google_updater_.
-  void CreateGoogleUpdater();
-
-  // Helper function to clear google_updater_.
-  void ClearGoogleUpdater();
-
   // Returns a window that can be used for elevation.
   HWND GetElevationParent();
 
-  // 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);
 };
 
 // This class is used to read the version on the FILE thread and then call back
@@ skipping 32 matching lines @@
   // We use a weak pointer in case the updater gets destroyed while waiting.
   base::WeakPtr<VersionUpdaterWin> version_updater_;
 
   // This is the version that gets read in the FILE thread and set on the
   // the updater in the UI thread.
   Version installed_version_;
 };
 
 VersionUpdaterWin::VersionUpdaterWin()
     : weak_factory_(this) {
-  CreateGoogleUpdater();
 }
 
 VersionUpdaterWin::~VersionUpdaterWin() {
-  // The Google Updater will hold a pointer to the listener until it reports
-  // status, so that pointer must be cleared when the listener is destoyed.
-  ClearGoogleUpdater();
 }
 
 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, the version updater must 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 the page got refreshed after results were returned.
-    if (!google_updater_.get())
-      CreateGoogleUpdater();
     UpdateStatus(UPGRADE_CHECK_STARTED, GOOGLE_UPDATE_NO_ERROR,
                  base::string16());
     // Specify false to not upgrade yet.
-    google_updater_->CheckForUpdate(false, GetElevationParent());
+    ::CheckForUpdate(false, GetElevationParent(),

[Peter Kasting, 2014/11/26 22:13:05]

Nit: "::" shouldn't be necessary here, I wouldn't think, since
argument-dependent lookup should find the right method?  If it's not, I'd avoid
it; we generally try to either avoid "::" entirely or else use it only for
system APIs (e.g. win32), though usage is admittedly inconsistent.

[grt (UTC plus 2), 2014/11/27 04:44:57]

ADL wasn't enough to find it. I've renamed the function in google_update_win to
avoid the collision.

+                     base::Bind(&VersionUpdaterWin::OnUpdateCheckResults,
+                                weak_factory_.GetWeakPtr()));
   }
 }
 
 void VersionUpdaterWin::RelaunchBrowser() const {
   chrome::AttemptRestart();
 }
 
-void VersionUpdaterWin::OnReportResults(
-    GoogleUpdateUpgradeResult result, GoogleUpdateErrorCode error_code,
-    const base::string16& error_message, const base::string16& version) {
-  // Drop the last reference to the object so that it gets cleaned up here.
-  ClearGoogleUpdater();
+void VersionUpdaterWin::OnUpdateCheckResults(
+    GoogleUpdateUpgradeResult result,
+    GoogleUpdateErrorCode error_code,
+    const base::string16& error_message,
+    const base::string16& version) {
   UpdateStatus(result, error_code, error_message);
 }
 
 void VersionUpdaterWin::UpdateStatus(GoogleUpdateUpgradeResult result,
                                      GoogleUpdateErrorCode error_code,
                                      const base::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;
   base::string16 message;
 
   switch (result) {
     case UPGRADE_CHECK_STARTED: {
       status = CHECKING;
       break;
     }
     case UPGRADE_STARTED: {
       status = UPDATING;
       break;
     }
     case UPGRADE_IS_AVAILABLE: {
-      DCHECK(!google_updater_.get());  // Should have been nulled out already.
-      CreateGoogleUpdater();
       UpdateStatus(UPGRADE_STARTED, GOOGLE_UPDATE_NO_ERROR, base::string16());
       // Specify true to upgrade now.
-      google_updater_->CheckForUpdate(true, GetElevationParent());
+      ::CheckForUpdate(true, GetElevationParent(),
+                       base::Bind(&VersionUpdaterWin::OnUpdateCheckResults,
+                                  weak_factory_.GetWeakPtr()));
       return;
     }
     case UPGRADE_ALREADY_UP_TO_DATE: {
       // Google Update reported that Chrome is up-to-date.
       // To confirm the updated version is running, the reading
       // must be done on the file thread. The rest of this case
       // will be handled within GotInstalledVersion.
       BrowserThread::PostTask(BrowserThread::FILE, FROM_HERE, base::Bind(
             &VersionReader::GetVersionFromFileThread,
             new VersionReader(weak_factory_.GetWeakPtr())));
@@ skipping 43 matching lines @@
   // out of date.
   chrome::VersionInfo version_info;
   Version running_version(version_info.Version());
   callback_.Run((version.IsValid() && version.CompareTo(running_version) > 0)
                     ? NEARLY_UPDATED
                     : UPDATED,
                 0,
                 base::string16());
 }
 
-void VersionUpdaterWin::CreateGoogleUpdater() {
-  ClearGoogleUpdater();
-  google_updater_ = new GoogleUpdate();
-  google_updater_->set_status_listener(this);
-}
-
-void VersionUpdaterWin::ClearGoogleUpdater() {
-  if (google_updater_.get()) {
-    google_updater_->set_status_listener(NULL);
-    google_updater_ = NULL;
-  }
-}
-
 BOOL CALLBACK WindowEnumeration(HWND window, LPARAM param) {
   if (IsWindowVisible(window)) {
     HWND* returned_window = reinterpret_cast<HWND*>(param);
     *returned_window = window;
     return FALSE;
   }
   return TRUE;
 }
 
 HWND VersionUpdaterWin::GetElevationParent() {
@@ skipping 10 matching lines @@
                          << GetCurrentThreadId();
 #endif
   return window;
 }
 
 }  // namespace
 
 VersionUpdater* VersionUpdater::Create(content::BrowserContext* /* context */) {
   return new VersionUpdaterWin;
 }