Revert 69167, itself a revert of 69165 - Merge the installer, installer_util ...

chrome/installer/setup/uninstall.cc

 // Copyright (c) 2010 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.
 //
 // This file defines the methods useful for uninstalling Chrome.
 
 #include "chrome/installer/setup/uninstall.h"
 
 #include "base/file_util.h"
 #include "base/path_service.h"
@@ skipping 14 matching lines @@
 #include "chrome/installer/util/install_util.h"
 #include "chrome/installer/util/logging_installer.h"
 #include "chrome/installer/util/shell_util.h"
 #include "chrome/installer/util/util_constants.h"
 #include "chrome/installer/util/version.h"
 
 // Build-time generated include file.
 #include "registered_dlls.h"  // NOLINT
 
 using base::win::RegKey;
-using installer_util::InstallStatus;
+using installer::InstallStatus;
 
 namespace installer {
 
 // This functions checks for any Chrome instances that are
 // running and first asks them to close politely by sending a Windows message.
 // If there is an error while sending message or if there are still Chrome
 // procesess active after the message has been sent, this function will try
 // to kill them.
 void CloseAllChromeProcesses() {
   for (int j = 0; j < 4; ++j) {
     std::wstring wnd_class(L"Chrome_WidgetWin_");
     wnd_class.append(base::IntToString16(j));
     HWND window = FindWindowEx(NULL, NULL, wnd_class.c_str(), NULL);
     while (window) {
       HWND tmpWnd = window;
       window = FindWindowEx(NULL, window, wnd_class.c_str(), NULL);
       if (!SendMessageTimeout(tmpWnd, WM_CLOSE, 0, 0, SMTO_BLOCK, 3000, NULL) &&
           (GetLastError() == ERROR_TIMEOUT)) {
-        base::CleanupProcesses(installer_util::kChromeExe, 0,
+        base::CleanupProcesses(installer::kChromeExe, 0,
                                ResultCodes::HUNG, NULL);
-        base::CleanupProcesses(installer_util::kNaClExe, 0,
+        base::CleanupProcesses(installer::kNaClExe, 0,
                                ResultCodes::HUNG, NULL);
         return;
       }
     }
   }
 
   // If asking politely didn't work, wait for 15 seconds and then kill all
   // chrome.exe. This check is just in case Chrome is ignoring WM_CLOSE
   // messages.
-  base::CleanupProcesses(installer_util::kChromeExe, 15000,
+  base::CleanupProcesses(installer::kChromeExe, 15000,
                          ResultCodes::HUNG, NULL);
-  base::CleanupProcesses(installer_util::kNaClExe, 15000,
+  base::CleanupProcesses(installer::kNaClExe, 15000,
                          ResultCodes::HUNG, NULL);
 }
 
 // Attempts to close the Chrome Frame helper process by sending WM_CLOSE
 // messages to its window, or just killing it if that doesn't work.
 void CloseChromeFrameHelperProcess() {
-  HWND window = FindWindow(installer_util::kChromeFrameHelperWndClass, NULL);
+  HWND window = FindWindow(installer::kChromeFrameHelperWndClass, NULL);
   if (!::IsWindow(window))
     return;
 
   const DWORD kWaitMs = 3000;
 
   DWORD pid = 0;
   ::GetWindowThreadProcessId(window, &pid);
   DCHECK_NE(pid, 0U);
   ScopedHandle process(::OpenProcess(SYNCHRONIZE, FALSE, pid));
   PLOG_IF(INFO, !process) << "Failed to open process: " << pid;
 
   bool kill = true;
   if (SendMessageTimeout(window, WM_CLOSE, 0, 0, SMTO_BLOCK, kWaitMs, NULL) &&
       process) {
-    VLOG(1) << "Waiting for " << installer_util::kChromeFrameHelperExe;
+    VLOG(1) << "Waiting for " << installer::kChromeFrameHelperExe;
     DWORD wait = ::WaitForSingleObject(process, kWaitMs);
     if (wait != WAIT_OBJECT_0) {
-      LOG(WARNING) << "Wait for " << installer_util::kChromeFrameHelperExe
+      LOG(WARNING) << "Wait for " << installer::kChromeFrameHelperExe
                    << " to exit failed or timed out.";
     } else {
       kill = false;
-      VLOG(1) << installer_util::kChromeFrameHelperExe << " exited normally.";
+      VLOG(1) << installer::kChromeFrameHelperExe << " exited normally.";
     }
   }
 
   if (kill) {
-    VLOG(1) << installer_util::kChromeFrameHelperExe << " hung.  Killing.";
-    base::CleanupProcesses(installer_util::kChromeFrameHelperExe, 0,
+    VLOG(1) << installer::kChromeFrameHelperExe << " hung.  Killing.";
+    base::CleanupProcesses(installer::kChromeFrameHelperExe, 0,
                            ResultCodes::HUNG, NULL);
   }
 }
 
 // This method tries to figure out if current user has registered Chrome.
 // It returns true iff:
 // - Software\Clients\StartMenuInternet\Chromium\"" key has a valid value.
 // - The value is same as chrome.exe path for the current installation.
 bool CurrentUserHasDefaultBrowser(const Product& product) {
   std::wstring reg_key(ShellUtil::kRegStartMenuInternet);
   reg_key.append(L"\\" + product.distribution()->GetApplicationName() +
                  ShellUtil::kRegShellOpen);
   RegKey key(HKEY_LOCAL_MACHINE, reg_key.c_str(), KEY_READ);
   std::wstring reg_exe;
   if (key.ReadValue(L"", &reg_exe) && reg_exe.length() > 2) {
     FilePath chrome_exe(product.package().path()
-        .Append(installer_util::kChromeExe));
+        .Append(installer::kChromeExe));
     // The path in the registry will always have quotes.
     reg_exe = reg_exe.substr(1, reg_exe.length() - 2);
     if (FilePath::CompareEqualIgnoreCase(reg_exe, chrome_exe.value()))
       return true;
   }
 
   return false;
 }
 
 // This method deletes Chrome shortcut folder from Windows Start menu. It
@@ skipping 203 matching lines @@
   }
   return result;
 }
 
 // This method checks if Chrome is currently running or if the user has
 // cancelled the uninstall operation by clicking Cancel on the confirmation
 // box that Chrome pops up.
 InstallStatus IsChromeActiveOrUserCancelled(const Product& product) {
   int32 exit_code = ResultCodes::NORMAL_EXIT;
   CommandLine options(CommandLine::NO_PROGRAM);
-  options.AppendSwitch(installer_util::switches::kUninstall);
+  options.AppendSwitch(installer::switches::kUninstall);
 
   // Here we want to save user from frustration (in case of Chrome crashes)
   // and continue with the uninstallation as long as chrome.exe process exit
   // code is NOT one of the following:
   // - UNINSTALL_CHROME_ALIVE - chrome.exe is currently running
   // - UNINSTALL_USER_CANCEL - User cancelled uninstallation
   // - HUNG - chrome.exe was killed by HuntForZombieProcesses() (until we can
   //          give this method some brains and not kill chrome.exe launched
   //          by us, we will not uninstall if we get this return code).
   VLOG(1) << "Launching Chrome to do uninstall tasks.";
   if (product.LaunchChromeAndWait(options, &exit_code)) {
     VLOG(1) << "chrome.exe launched for uninstall confirmation returned: "
             << exit_code;
     if ((exit_code == ResultCodes::UNINSTALL_CHROME_ALIVE) ||
         (exit_code == ResultCodes::UNINSTALL_USER_CANCEL) ||
         (exit_code == ResultCodes::HUNG))
-      return installer_util::UNINSTALL_CANCELLED;
+      return installer::UNINSTALL_CANCELLED;
 
     if (exit_code == ResultCodes::UNINSTALL_DELETE_PROFILE)
-      return installer_util::UNINSTALL_DELETE_PROFILE;
+      return installer::UNINSTALL_DELETE_PROFILE;
   } else {
     PLOG(ERROR) << "Failed to launch chrome.exe for uninstall confirmation.";
   }
 
-  return installer_util::UNINSTALL_CONFIRMED;
+  return installer::UNINSTALL_CONFIRMED;
 }
 
 bool ShouldDeleteProfile(const CommandLine& cmd_line, InstallStatus status,
                          const Product& product) {
   bool should_delete = false;
 
   // Chrome Frame uninstallations always want to delete the profile (we have no
   // UI to prompt otherwise and the profile stores no useful data anyway)
   // unless they are managed by MSI. MSI uninstalls will explicitly include
   // the --delete-profile flag to distinguish them from MSI upgrades.
   if (product.distribution()->GetType() !=
       BrowserDistribution::CHROME_BROWSER && !product.IsMsi()) {
     should_delete = true;
   } else {
     should_delete =
-        status == installer_util::UNINSTALL_DELETE_PROFILE ||
-        cmd_line.HasSwitch(installer_util::switches::kDeleteProfile);
+        status == installer::UNINSTALL_DELETE_PROFILE ||
+        cmd_line.HasSwitch(installer::switches::kDeleteProfile);
   }
 
   return should_delete;
 }
 
 bool DeleteChromeRegistrationKeys(BrowserDistribution* dist, HKEY root,
                                   const std::wstring& browser_entry_suffix,
                                   InstallStatus& exit_code) {
   if (!dist->CanSetAsDefault()) {
     // We should have never set those keys.
@@ skipping 14 matching lines @@
   // Delete Software\Clients\StartMenuInternet\Chromium
   std::wstring set_access_key(ShellUtil::kRegStartMenuInternet);
   file_util::AppendToPath(&set_access_key, dist->GetApplicationName());
   set_access_key.append(browser_entry_suffix);
   InstallUtil::DeleteRegistryKey(key, set_access_key);
 
   // We have renamed the StartMenuInternet\chrome.exe to
   // StartMenuInternet\Chromium so for old users we still need to delete
   // the old key.
   std::wstring old_set_access_key(ShellUtil::kRegStartMenuInternet);
-  file_util::AppendToPath(&old_set_access_key, installer_util::kChromeExe);
+  file_util::AppendToPath(&old_set_access_key, installer::kChromeExe);
   InstallUtil::DeleteRegistryKey(key, old_set_access_key);
 
   // Delete Software\RegisteredApplications\Chromium
   InstallUtil::DeleteRegistryValue(root, ShellUtil::kRegRegisteredApplications,
       dist->GetApplicationName() + browser_entry_suffix);
 
   // Delete Software\Classes\Applications\chrome.exe
   std::wstring app_key(ShellUtil::kRegClasses);
   file_util::AppendToPath(&app_key, L"Applications");
-  file_util::AppendToPath(&app_key, installer_util::kChromeExe);
+  file_util::AppendToPath(&app_key, installer::kChromeExe);
   InstallUtil::DeleteRegistryKey(key, app_key);
 
   // Delete the App Paths key that lets explorer find Chrome.
   std::wstring app_path_key(ShellUtil::kAppPathsRegistryKey);
-  file_util::AppendToPath(&app_path_key, installer_util::kChromeExe);
+  file_util::AppendToPath(&app_path_key, installer::kChromeExe);
   InstallUtil::DeleteRegistryKey(key, app_path_key);
 
   // Cleanup OpenWithList
   for (int i = 0; ShellUtil::kFileAssociations[i] != NULL; i++) {
     std::wstring open_with_key(ShellUtil::kRegClasses);
     file_util::AppendToPath(&open_with_key, ShellUtil::kFileAssociations[i]);
     file_util::AppendToPath(&open_with_key, L"OpenWithList");
-    file_util::AppendToPath(&open_with_key, installer_util::kChromeExe);
+    file_util::AppendToPath(&open_with_key, installer::kChromeExe);
     InstallUtil::DeleteRegistryKey(key, open_with_key);
   }
 
   key.Close();
-  exit_code = installer_util::UNINSTALL_SUCCESSFUL;
+  exit_code = installer::UNINSTALL_SUCCESSFUL;
   return true;
 }
 
 void RemoveLegacyRegistryKeys(BrowserDistribution* dist) {
   // We used to register Chrome to handle crx files, but this turned out
   // to be not worth the hassle. Remove these old registry entries if
   // they exist. See: http://codereview.chromium.org/210007
 
 #if defined(GOOGLE_CHROME_BUILD)
 const wchar_t kChromeExtProgId[] = L"ChromeExt";
@@ skipping 22 matching lines @@
     ext_association.append(chrome::kExtensionFileExtension);
     InstallUtil::DeleteRegistryKey(key, ext_association);
   }
 }
 
 InstallStatus UninstallChrome(const FilePath& setup_path,
                               const Product& product,
                               bool remove_all,
                               bool force_uninstall,
                               const CommandLine& cmd_line) {
-  InstallStatus status = installer_util::UNINSTALL_CONFIRMED;
+  InstallStatus status = installer::UNINSTALL_CONFIRMED;
   std::wstring suffix;
   if (!ShellUtil::GetUserSpecificDefaultBrowserSuffix(product.distribution(),
                                                       &suffix))
     suffix = L"";
 
   BrowserDistribution* browser_dist = product.distribution();
   bool is_chrome = (browser_dist->GetType() ==
                     BrowserDistribution::CHROME_BROWSER);
 
   VLOG(1) << "UninstallChrome: " << browser_dist->GetApplicationName();
 
   if (force_uninstall) {
     // Since --force-uninstall command line option is used, we are going to
     // do silent uninstall. Try to close all running Chrome instances.
     // NOTE: We don't do this for Chrome Frame or CEEE.
     if (is_chrome)
       CloseAllChromeProcesses();
   } else if (is_chrome) {
     // no --force-uninstall so lets show some UI dialog boxes.
     status = IsChromeActiveOrUserCancelled(product);
-    if (status != installer_util::UNINSTALL_CONFIRMED &&
-        status != installer_util::UNINSTALL_DELETE_PROFILE)
+    if (status != installer::UNINSTALL_CONFIRMED &&
+        status != installer::UNINSTALL_DELETE_PROFILE)
       return status;
 
     // Check if we need admin rights to cleanup HKLM. If we do, try to launch
     // another uninstaller (silent) in elevated mode to do HKLM cleanup.
     // And continue uninstalling in the current process also to do HKCU cleanup.
     if (remove_all &&
         (!suffix.empty() || CurrentUserHasDefaultBrowser(product)) &&
         !::IsUserAnAdmin() &&
         base::win::GetVersion() >= base::win::VERSION_VISTA &&
-        !cmd_line.HasSwitch(installer_util::switches::kRunAsAdmin)) {
+        !cmd_line.HasSwitch(installer::switches::kRunAsAdmin)) {
       CommandLine new_cmd(CommandLine::NO_PROGRAM);
       new_cmd.AppendArguments(cmd_line, true);
       // Append --run-as-admin flag to let the new instance of setup.exe know
       // that we already tried to launch ourselves as admin.
-      new_cmd.AppendSwitch(installer_util::switches::kRunAsAdmin);
+      new_cmd.AppendSwitch(installer::switches::kRunAsAdmin);
       // Append --remove-chrome-registration to remove registry keys only.
-      new_cmd.AppendSwitch(installer_util::switches::kRemoveChromeRegistration);
+      new_cmd.AppendSwitch(installer::switches::kRemoveChromeRegistration);
       if (!suffix.empty()) {
         new_cmd.AppendSwitchNative(
-            installer_util::switches::kRegisterChromeBrowserSuffix, suffix);
+            installer::switches::kRegisterChromeBrowserSuffix, suffix);
       }
-      DWORD exit_code = installer_util::UNKNOWN_STATUS;
+      DWORD exit_code = installer::UNKNOWN_STATUS;
       InstallUtil::ExecuteExeAsAdmin(new_cmd, &exit_code);
     }
   }
 
   // Get the version of installed Chrome (if any)
   scoped_ptr<installer::Version>
       installed_version(InstallUtil::GetChromeVersion(browser_dist,
                                                       product.system_level()));
 
   // Chrome is not in use so lets uninstall Chrome by deleting various files
@@ skipping 16 matching lines @@
   InstallUtil::DeleteRegistryKey(key, browser_dist->GetUninstallRegPath());
   InstallUtil::DeleteRegistryKey(key, browser_dist->GetVersionKey());
 
   // Also try to delete the MSI value in the ClientState key (it might not be
   // there). This is due to a Google Update behaviour where an uninstall and a
   // rapid reinstall might result in stale values from the old ClientState key
   // being picked up on reinstall.
   product.SetMsiMarker(false);
 
   // Remove all Chrome registration keys.
-  InstallStatus ret = installer_util::UNKNOWN_STATUS;
+  InstallStatus ret = installer::UNKNOWN_STATUS;
   DeleteChromeRegistrationKeys(product.distribution(), reg_root, suffix, ret);
 
   // For user level install also we end up creating some keys in HKLM if user
   // sets Chrome as default browser. So delete those as well (needs admin).
   if (remove_all && !product.system_level() &&
       (!suffix.empty() || CurrentUserHasDefaultBrowser(product))) {
     DeleteChromeRegistrationKeys(product.distribution(), HKEY_LOCAL_MACHINE,
                                  suffix, ret);
   }
 
   // Delete shared registry keys as well (these require admin rights) if
   // remove_all option is specified.
   if (remove_all) {
     if (!InstallUtil::IsChromeSxSProcess() && is_chrome) {
       // Delete media player registry key that exists only in HKLM.
       // We don't delete this key in SxS uninstall or Chrome Frame uninstall
       // as we never set the key for those products.
       RegKey hklm_key(HKEY_LOCAL_MACHINE, L"", KEY_ALL_ACCESS);
       std::wstring reg_path(installer::kMediaPlayerRegPath);
-      file_util::AppendToPath(&reg_path, installer_util::kChromeExe);
+      file_util::AppendToPath(&reg_path, installer::kChromeExe);
       InstallUtil::DeleteRegistryKey(hklm_key, reg_path);
       hklm_key.Close();
     }
 
     // Unregister any dll servers that we may have registered for Chrome Frame
     // and CEEE builds only.
     // TODO(tommi): We should only do this when the folder itself is
     // being removed and we know that the DLLs were previously registered.
     // Simplest would be to always register them.
     if (installed_version.get() && !is_chrome) {
       RegisterComDllList(product.package().path().Append(
                              installed_version->GetString()),
                          product.system_level(), false, false);
     }
   }
 
   // Close any Chrome Frame helper processes that may be running.
   if (product.distribution()->GetType() == BrowserDistribution::CHROME_FRAME) {
     VLOG(1) << "Closing the Chrome Frame helper process";
     CloseChromeFrameHelperProcess();
   }
 
   if (!installed_version.get())
-    return installer_util::UNINSTALL_SUCCESSFUL;
+    return installer::UNINSTALL_SUCCESSFUL;
 
   // Finally delete all the files from Chrome folder after moving setup.exe
   // and the user's Local State to a temp location.
   bool delete_profile = ShouldDeleteProfile(cmd_line, status, product);
-  ret = installer_util::UNINSTALL_SUCCESSFUL;
+  ret = installer::UNINSTALL_SUCCESSFUL;
 
   // In order to be able to remove the folder in which we're running, we
   // need to move setup.exe out of the install folder.
   // TODO(tommi): What if the temp folder is on a different volume?
   MoveSetupOutOfInstallFolder(product.package(), setup_path,
                               *installed_version);
 
   FilePath backup_state_file(BackupLocalStateFile(
       GetLocalStateFolder(product)));
 
   // TODO(tommi): We should only do this when the last distribution is being
   // uninstalled.
   DeleteResult delete_result = DeleteFilesAndFolders(product.package(),
                                                      *installed_version);
 
   if (delete_profile)
     DeleteLocalState(product);
 
   if (delete_result == DELETE_FAILED) {
-    ret = installer_util::UNINSTALL_FAILED;
+    ret = installer::UNINSTALL_FAILED;
   } else if (delete_result == DELETE_REQUIRES_REBOOT) {
-    ret = installer_util::UNINSTALL_REQUIRES_REBOOT;
+    ret = installer::UNINSTALL_REQUIRES_REBOOT;
   }
 
   if (!force_uninstall) {
     VLOG(1) << "Uninstallation complete. Launching Uninstall survey.";
     browser_dist->DoPostUninstallOperations(*installed_version,
         backup_state_file, distribution_data);
   }
 
   // Try and delete the preserved local state once the post-install
   // operations are complete.
   if (!backup_state_file.empty())
     file_util::Delete(backup_state_file, false);
 
   return ret;
 }
 
 }  // namespace installer