Making google update UAC prompt launch in the foreground

chrome/browser/google_update.cc

 // Copyright (c) 2006-2008 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 "chrome/browser/google_update.h"
 
 #include <atlbase.h>
 #include <atlcom.h>
 
 #include "base/message_loop.h"
 #include "base/path_service.h"
 #include "base/string_util.h"
 #include "base/task.h"
 #include "base/thread.h"
 #include "base/win_util.h"
 #include "chrome/app/client_util.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/installer/util/google_update_constants.h"
 #include "chrome/installer/util/helper.h"
 #include "chrome/installer/util/install_util.h"
+#include "chrome/views/window/window.h"
 #include "google_update_idl_i.c"
 
+using views::Window;
+
 namespace {
 // Check if the currently running instance can be updated by Google Update.
 // Returns true only if the instance running is a Google Chrome
 // distribution installed in a standard location.
 bool CanUpdateCurrentChrome(const std::wstring& chrome_exe_path) {
 #if !defined(GOOGLE_CHROME_BUILD)
   return false;
 #else
   std::wstring user_exe_path = installer::GetChromeInstallPath(false);
   std::wstring machine_exe_path = installer::GetChromeInstallPath(true);
   std::transform(user_exe_path.begin(), user_exe_path.end(),
                  user_exe_path.begin(), tolower);
   std::transform(machine_exe_path.begin(), machine_exe_path.end(),
                  machine_exe_path.begin(), tolower);
   if (chrome_exe_path != user_exe_path &&
       chrome_exe_path != machine_exe_path ) {
     LOG(ERROR) << L"Google Update cannot update Chrome installed in a "
                << L"non-standard location: " << chrome_exe_path.c_str()
                << L". The standard location is: " << user_exe_path.c_str()
                << L" or " << machine_exe_path.c_str() << L".";
     return false;
   }
 
   return true;
 #endif
 }
 
 // Creates an instance of a COM Local Server class using either plain vanilla
 // CoCreateInstance, or using the Elevation moniker if running on Vista.
+// hwnd must refer to a foregound window in order to get the UAC prompt
+// showing up in the foreground if running on Vista. It can also be NULL if
+// background UAC prompts are desired.
 HRESULT CoCreateInstanceAsAdmin(REFCLSID class_id, REFIID interface_id,
-                                void** interface_ptr) {
+                                HWND hwnd, void** interface_ptr) {
   if (!interface_ptr)
     return E_POINTER;
 
   // For Vista we need to instantiate the COM server via the elevation
   // moniker. This ensures that the UAC dialog shows up.
   if (win_util::GetWinVersion() >= win_util::WINVERSION_VISTA) {
     wchar_t class_id_as_string[MAX_PATH] = {0};
     StringFromGUID2(class_id, class_id_as_string,
                     arraysize(class_id_as_string));
 
     std::wstring elevation_moniker_name =
-        StringPrintf(L"Elevation:Administrator!new:%s", class_id_as_string);
+        StringPrintf(L"Elevation:Administrator!new:%ls", class_id_as_string);
 
     BIND_OPTS3 bind_opts;
     memset(&bind_opts, 0, sizeof(bind_opts));
-
     bind_opts.cbStruct = sizeof(bind_opts);
     bind_opts.dwClassContext = CLSCTX_LOCAL_SERVER;
+    bind_opts.hwnd = hwnd;
+
     return CoGetObject(elevation_moniker_name.c_str(), &bind_opts,
                        interface_id, reinterpret_cast<void**>(interface_ptr));
   }
 
   return CoCreateInstance(class_id, NULL, CLSCTX_LOCAL_SERVER,
                           interface_id,
                           reinterpret_cast<void**>(interface_ptr));
 }
 
 
@@ skipping 112 matching lines @@
 GoogleUpdate::GoogleUpdate()
     : listener_(NULL) {
 }
 
 GoogleUpdate::~GoogleUpdate() {
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // GoogleUpdate, views::DialogDelegate implementation:
 
-void GoogleUpdate::CheckForUpdate(bool install_if_newer) {
+void GoogleUpdate::CheckForUpdate(bool install_if_newer, Window* window) {
   // We need to shunt this request over to InitiateGoogleUpdateCheck and have
   // it run in the file thread.
   MessageLoop* file_loop = g_browser_process->file_thread()->message_loop();
   file_loop->PostTask(FROM_HERE, NewRunnableMethod(this,
       &GoogleUpdate::InitiateGoogleUpdateCheck,
-      install_if_newer, MessageLoop::current()));
+      install_if_newer, window, MessageLoop::current()));
 }
 
 // Adds/removes a listener. Only one listener is maintained at the moment.
 void GoogleUpdate::AddStatusChangeListener(
     GoogleUpdateStatusListener* listener) {
   DCHECK(!listener_);
   listener_ = listener;
 }
 
 void GoogleUpdate::RemoveStatusChangeListener() {
   listener_ = NULL;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // GoogleUpdate, private:
 
 bool GoogleUpdate::InitiateGoogleUpdateCheck(bool install_if_newer,
+                                             Window* window,
                                              MessageLoop* main_loop) {
 
   std::wstring chrome_exe_path;
   if (!PathService::Get(base::DIR_EXE, &chrome_exe_path)) {
     NOTREACHED();
     return false;
   }
 
   std::transform(chrome_exe_path.begin(), chrome_exe_path.end(),
                  chrome_exe_path.begin(), tolower);
@@ skipping 19 matching lines @@
 
   if (InstallUtil::IsPerUserInstall(chrome_exe_path.c_str())) {
     hr = on_demand.CoCreateInstance(CLSID_OnDemandUserAppsClass);
   } else {
     // The Update operation needs Admin privileges for writing
     // to %ProgramFiles%. On Vista we need to elevate before instantiating
     // the updater instance.
     if (!install_if_newer) {
       hr = on_demand.CoCreateInstance(CLSID_OnDemandMachineAppsClass);
     } else {
+      HWND foreground_hwnd = NULL;
+      if (window != NULL) {
+        foreground_hwnd = window->GetNativeWindow();
+      }
+
       hr = CoCreateInstanceAsAdmin(CLSID_OnDemandMachineAppsClass,
-                                   IID_IGoogleUpdate,
+                                   IID_IGoogleUpdate, foreground_hwnd,
                                    reinterpret_cast<void**>(&on_demand));
     }
   }
 
   if (hr != S_OK)
     return ReportFailure(hr, GOOGLE_UPDATE_ONDEMAND_CLASS_NOT_FOUND, main_loop);
 
   if (!install_if_newer)
     hr = on_demand->CheckForUpdate(google_update::kChromeGuid, job_observer);
   else
@@ skipping 38 matching lines @@
 }
 
 bool GoogleUpdate::ReportFailure(HRESULT hr, GoogleUpdateErrorCode error_code,
                                  MessageLoop* main_loop) {
   NOTREACHED() << "Communication with Google Update failed: " << hr
                << " error: " << error_code;
   main_loop->PostTask(FROM_HERE, NewRunnableMethod(this,
       &GoogleUpdate::ReportResults, UPGRADE_ERROR, error_code));
   return false;
 }