Fix detection of restart needed in VersionUpdaterWin.

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/weak_ptr.h"
 #include "base/strings/string16.h"
+#include "base/task_runner_util.h"
 #include "base/win/win_util.h"
 #include "base/win/windows_version.h"
 #include "chrome/browser/browser_process.h"
-#include "chrome/browser/first_run/upgrade_util_win.h"
+#include "chrome/browser/first_run/upgrade_util.h"
 #include "chrome/browser/google/google_update_win.h"
 #include "chrome/browser/lifetime/application_lifetime.h"
 #include "chrome/browser/ui/webui/help/version_updater.h"
 #include "chrome/grit/generated_resources.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/web_contents.h"
 #include "ui/aura/window.h"
 #include "ui/aura/window_tree_host.h"
 #include "ui/base/l10n/l10n_util.h"
 #include "ui/gfx/native_widget_types.h"
@@ skipping 21 matching lines @@
   void OnUpgradeComplete(const base::string16& new_version) override;
   void OnError(GoogleUpdateErrorCode error_code,
                const base::string16& error_message,
                const base::string16& new_version) override;
 
  private:
 #if defined(GOOGLE_CHROME_BUILD)
   void BeginUpdateCheckOnFileThread(bool install_update_if_possible);
 #endif  // GOOGLE_CHROME_BUILD
 
+  // A task run on the UI thread with the result of checking for a pending
+  // restart.
+  void OnPendingRestartCheck(bool is_update_pending_restart);
+
   // The widget owning the UI for the update check.
   gfx::AcceleratedWidget owner_widget_;
 
   // Callback used to communicate update status to the client.
   StatusCallback callback_;
 
   // Used for callbacks.
   base::WeakPtrFactory<VersionUpdaterWin> weak_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(VersionUpdaterWin);
@@ skipping 30 matching lines @@
 }
 
 void VersionUpdaterWin::OnUpdateCheckComplete(
     const base::string16& new_version) {
 #if defined(GOOGLE_CHROME_BUILD)
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
   Status status = CHECKING;
   if (new_version.empty()) {
     // Google Update says that no new version is available. Check to see if a
     // restart is needed for a previously-applied update to take effect.
-    status = upgrade_util::IsRunningOldChrome() ? NEARLY_UPDATED : UPDATED;
+    if (base::PostTaskAndReplyWithResult(

[Peter Kasting, 2015/05/15 18:58:18]

If this conditional fails, we'll run the callback with status CHECKING.  Is that
correct, or should we change to FAILED or NEARLY_UPDATED or something?

[grt (UTC plus 2), 2015/05/15 19:57:16]

This condition will only fail when Chrome is shutting down. I think running the
callback with UPDATED is good since Chrome will complete the update if there is
one, so from the user's point of view it doesn't matter if the true state was
NEARLY_UPDATED.

+            content::BrowserThread::GetBlockingPool(),
+            FROM_HERE,
+            base::Bind(&upgrade_util::IsUpdatePendingRestart),
+            base::Bind(&VersionUpdaterWin::OnPendingRestartCheck,
+                       weak_factory_.GetWeakPtr()))) {
+      // Early exit since callback_ will be Run in OnPendingRestartCheck.
+      return;
+    }
   } else {
     // Notify the caller that the update is now beginning and initiate it.
     status = UPDATING;
     BeginUpdateCheckOnFileThread(true /* install_update_if_possible */);
   }
   callback_.Run(status, 0, base::string16());
 #endif  // GOOGLE_CHROME_BUILD
 }
 
 void VersionUpdaterWin::OnUpgradeProgress(int progress,
@@ skipping 36 matching lines @@
 void VersionUpdaterWin::BeginUpdateCheckOnFileThread(
     bool install_update_if_possible) {
   BeginUpdateCheck(content::BrowserThread::GetMessageLoopProxyForThread(
                        content::BrowserThread::FILE),
                    g_browser_process->GetApplicationLocale(),
                    install_update_if_possible, owner_widget_,
                    weak_factory_.GetWeakPtr());
 }
 #endif  // GOOGLE_CHROME_BUILD
 
+void VersionUpdaterWin::OnPendingRestartCheck(bool is_update_pending_restart) {
+  callback_.Run(is_update_pending_restart ? NEARLY_UPDATED : UPDATED, 0,
+                base::string16());
+}
+
 }  // namespace
 
 VersionUpdater* VersionUpdater::Create(content::WebContents* web_contents) {
   // Retrieve the HWND for the browser window that is hosting the update check.
   // This will be used as the parent for a UAC prompt, if needed. It's possible
   // this this window will no longer have focus by the time UAC is needed. In
   // that case, the UAC prompt will appear in the taskbar and will require a
   // user click. This is the least surprising thing we can do for the user, and
   // is the intended behavior for Windows applications. It's also possible that
   // the browser window hosting the update check will have been closed by the
   // time the UAC prompt is needed. This will behave similarly.
   return new VersionUpdaterWin(web_contents->GetTopLevelNativeWindow()
                                    ->GetHost()
                                    ->GetAcceleratedWidget());
 }