[Installer] Cleaning up dead code for App Launcher / App Host installs.

chrome/installer/setup/uninstall.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.
 //
 // This file defines the methods useful for uninstalling Chrome.
 
 #include "chrome/installer/setup/uninstall.h"
 
 #include <windows.h>
 
 #include <vector>
 
 #include "base/base_paths.h"
 #include "base/files/file_enumerator.h"
 #include "base/files/file_util.h"
 #include "base/path_service.h"
 #include "base/process/kill.h"
 #include "base/strings/string16.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/win/registry.h"
 #include "base/win/scoped_handle.h"
 #include "base/win/shortcut.h"
 #include "base/win/windows_version.h"
 #include "chrome/common/chrome_constants.h"
 #include "chrome/common/chrome_paths.h"
 #include "chrome/common/chrome_result_codes.h"
+#include "chrome/installer/setup/app_launcher_installer.h"
 #include "chrome/installer/setup/install.h"
 #include "chrome/installer/setup/install_worker.h"
 #include "chrome/installer/setup/setup_constants.h"
 #include "chrome/installer/setup/setup_util.h"
 #include "chrome/installer/util/auto_launch_util.h"
 #include "chrome/installer/util/browser_distribution.h"
 #include "chrome/installer/util/channel_info.h"
 #include "chrome/installer/util/delete_after_reboot_helper.h"
 #include "chrome/installer/util/firewall_manager_win.h"
 #include "chrome/installer/util/google_update_constants.h"
@@ skipping 139 matching lines @@
 
   // If chrome has been reactivated, clear all events for this brand as well.
   base::string16 reactivation_brand_wide;
   if (GoogleUpdateSettings::GetReactivationBrand(&reactivation_brand_wide)) {
     std::string reactivation_brand(base::UTF16ToASCII(reactivation_brand_wide));
     rlz_lib::SupplementaryBranding branding(reactivation_brand.c_str());
     rlz_lib::ClearProductState(rlz_lib::CHROME, points);
   }
 }
 
-// Decides whether setup.exe and the installer archive should be removed based
-// on the original and installer states:
-// * non-multi product being uninstalled: remove both
-// * any multi product left besides App Host: keep both
-// * only App Host left: keep setup.exe
-void CheckShouldRemoveSetupAndArchive(const InstallationState& original_state,
-                                      const InstallerState& installer_state,
-                                      bool* remove_setup,
-                                      bool* remove_archive) {
-  *remove_setup = true;
-  *remove_archive = true;
-
-  // If any multi-install product is left (other than App Host) we must leave
-  // the installer and archive. For the App Host, we only leave the installer.
+// Returns whether setup.exe should be removed based on the original and
+// installer states:
+// * non-multi product being uninstalled: remove setup.exe
+// * any multi product left: keep setup.exe
+bool CheckShouldRemoveSetup(const InstallationState& original_state,
+                            const InstallerState& installer_state) {
+  // If any multi-install product is left we must leave the installer and
+  // archive.
   if (!installer_state.is_multi_install()) {
     VLOG(1) << "Removing all installer files for a non-multi installation.";
   } else {
     // Loop through all known products...
     for (size_t i = 0; i < BrowserDistribution::NUM_TYPES; ++i) {
       BrowserDistribution::Type dist_type =
           static_cast<BrowserDistribution::Type>(i);
       const ProductState* product_state = original_state.GetProductState(
           installer_state.system_install(), dist_type);
       // If the product is installed, in multi mode, and is not part of the
       // active uninstallation...
       if (product_state && product_state->is_multi_install() &&
           !installer_state.FindProduct(dist_type)) {
         // setup.exe will not be removed as there is a remaining multi-install
         // product.
-        *remove_setup = false;
-        // As a special case, we can still remove the actual archive if the
-        // only remaining product is the App Host.
-        if (dist_type != BrowserDistribution::CHROME_APP_HOST) {
-          VLOG(1) << "Keeping all installer files due to a remaining "
-                  << "multi-install product.";
-          *remove_archive = false;
-          return;
-        }
-        VLOG(1) << "Keeping setup.exe due to a remaining "
-                << "app-host installation.";
+        VLOG(1) << "Keeping all installer files due to a remaining "
+                << "multi-install product.";
+        return false;
       }
     }
-    VLOG(1) << "Removing the installer archive.";
-    if (remove_setup)
-      VLOG(1) << "Removing setup.exe.";
+    VLOG(1) << "Removing all installer files.";
   }
+  return true;
 }
 
 // Removes all files from the installer directory, leaving setup.exe iff
 // |remove_setup| is false.
 // Returns false in case of an error.
 bool RemoveInstallerFiles(const base::FilePath& installer_directory,
                           bool remove_setup) {
   base::FileEnumerator file_enumerator(
       installer_directory,
       false,
@@ skipping 262 matching lines @@
     // We cannot delete the file right away, but try to delete it some other
     // way. Either with the help of a different process or the system.
     if (!base::DeleteFileAfterReboot(temp_file)) {
       const uint32 kDeleteAfterMs = 10 * 1000;
       installer::DeleteFileFromTempProcess(temp_file, kDeleteAfterMs);
     }
   }
   return true;
 }
 
-DeleteResult DeleteAppHostFilesAndFolders(const InstallerState& installer_state,
-                                          const Version& installed_version) {
-  const base::FilePath& target_path = installer_state.target_path();
-  if (target_path.empty()) {
-    LOG(ERROR) << "DeleteAppHostFilesAndFolders: no installation destination "
-               << "path.";
-    return DELETE_FAILED;  // Nothing else we can do to uninstall, so we return.
-  }
-
-  DeleteInstallTempDir(target_path);
-
-  DeleteResult result = DELETE_SUCCEEDED;
-
-  base::FilePath app_host_exe(target_path.Append(installer::kChromeAppHostExe));
-  if (!base::DeleteFile(app_host_exe, false)) {
-    result = DELETE_FAILED;
-    LOG(ERROR) << "Failed to delete path: " << app_host_exe.value();
-  }
-
-  return result;
-}
-
 DeleteResult DeleteChromeFilesAndFolders(const InstallerState& installer_state,
                                          const base::FilePath& setup_exe) {
   const base::FilePath& target_path = installer_state.target_path();
   if (target_path.empty()) {
     LOG(ERROR) << "DeleteChromeFilesAndFolders: no installation destination "
                << "path.";
     return DELETE_FAILED;  // Nothing else we can do to uninstall, so we return.
   }
 
   DeleteInstallTempDir(target_path);
 
   DeleteResult result = DELETE_SUCCEEDED;
 
   base::FilePath installer_directory;
   if (target_path.IsParent(setup_exe))
     installer_directory = setup_exe.DirName();
 
   // Enumerate all the files in target_path recursively (breadth-first).
   // We delete a file or folder unless it is a parent/child of the installer
   // directory. For parents of the installer directory, we will later recurse
   // and delete all the children (that are not also parents/children of the
   // installer directory).
   base::FileEnumerator file_enumerator(target_path, true,
       base::FileEnumerator::FILES | base::FileEnumerator::DIRECTORIES);
   for (base::FilePath to_delete = file_enumerator.Next(); !to_delete.empty();
        to_delete = file_enumerator.Next()) {
-    if (to_delete.BaseName().value() == installer::kChromeAppHostExe)
-      continue;
     if (!installer_directory.empty() &&
         (to_delete == installer_directory ||
          installer_directory.IsParent(to_delete) ||
          to_delete.IsParent(installer_directory))) {
       continue;
     }
 
     VLOG(1) << "Deleting install path " << to_delete.value();
     if (!base::DeleteFile(to_delete, true)) {
       LOG(ERROR) << "Failed to delete path (1st try): " << to_delete.value();
@@ skipping 565 matching lines @@
       new_cmd.AppendSwitch(installer::switches::kRemoveChromeRegistration);
       if (!suffix.empty()) {
         new_cmd.AppendSwitchNative(
             installer::switches::kRegisterChromeBrowserSuffix, suffix);
       }
       DWORD exit_code = installer::UNKNOWN_STATUS;
       InstallUtil::ExecuteExeAsAdmin(new_cmd, &exit_code);
     }
   }
 
+  HKEY reg_root = installer_state.root_key();
+
   if (is_chrome) {
     // Chrome is not in use so lets uninstall Chrome by deleting various files
     // and registry entries. Here we will just make best effort and keep going
     // in case of errors.
     ClearRlzProductState();
     // Delete the key that delegate_execute might make.
     if (base::win::GetVersion() >= base::win::VERSION_WIN8) {
       InstallUtil::DeleteRegistryKey(HKEY_CURRENT_USER,
                                      chrome::kMetroRegistryPath,
                                      WorkItem::kWow64Default);
@@ skipping 12 matching lines @@
               Append(installer::kChromeExe));
       VLOG(1) << "Retargeting user-generated Chrome shortcuts.";
       if (base::PathExists(system_chrome_path)) {
         RetargetUserShortcutsWithArgs(installer_state, product, chrome_exe,
                                       system_chrome_path);
       } else {
         LOG(ERROR) << "Retarget failed: system-level Chrome not found.";
       }
     }
 
+#if defined(GOOGLE_CHROME_BUILD)
+    if (!InstallUtil::IsChromeSxSProcess()) {

[grt (UTC plus 2), 2015/01/09 18:57:04]

nit: no braces

[huangs, 2015/01/18 01:18:24]

Done.

+      app_launcher_installer::RemoveShadowKey(reg_root);

[grt (UTC plus 2), 2015/01/09 18:57:04]

i think this belongs in the is_chrome block below since the AppLauncher dr
tracking is specific to the browser.

[huangs, 2015/01/18 01:18:24]

Moved, but I don't understand the reason you stated: This is also an |is_chrome|
block?  Meanwhile, also moved the "reg_root" assignment line.

[grt (UTC plus 2), 2015/01/20 21:30:22]

Doh! So it is! In any case, I think the block below is a better place for new
additions. I have to say I don't see why there are two is_chrome blocks like
that. Probably just the way things were split up way back when multi was
introduced.

[huangs, 2015/01/20 23:26:00]

Okay. No additional change here.

+    }
+#endif
+
     DeleteShortcuts(installer_state, product, chrome_exe);
   }
 
   // Delete the registry keys (Uninstall key and Version key).
-  HKEY reg_root = installer_state.root_key();
-
   // Note that we must retrieve the distribution-specific data before deleting
   // product.GetVersionKey().
   base::string16 distribution_data(browser_dist->GetDistributionData(reg_root));
 
   // Remove Control Panel uninstall link.
   if (product.ShouldCreateUninstallEntry()) {
     InstallUtil::DeleteRegistryKey(
         reg_root, browser_dist->GetUninstallRegPath(), KEY_WOW64_32KEY);
   }
 
@@ skipping 70 matching lines @@
 
     UninstallActiveSetupEntries(installer_state, product);
 
     UninstallFirewallRules(browser_dist, chrome_exe);
 
     RemoveBlacklistState();
 
     // Notify the shell that associations have changed since Chrome was likely
     // unregistered.
     SHChangeNotify(SHCNE_ASSOCCHANGED, SHCNF_IDLIST, NULL, NULL);
-
-    // TODO(huangs): Implement actual migration code and remove the hack below.
-    // Remove the "shadow" App Launcher registry keys.
-    // TODO(hunags): Management of this key should not be conditional on
-    // multi-install since the app list feature is available regardless of how
-    // chrome is installed.
-    if (installer_state.is_multi_install()) {
-      // Delete the "shadow" keys.
-      BrowserDistribution* shadow_app_launcher_dist =
-          BrowserDistribution::GetSpecificDistribution(
-              BrowserDistribution::CHROME_APP_HOST);
-      InstallUtil::DeleteRegistryKey(
-          reg_root,
-          shadow_app_launcher_dist->GetVersionKey(),
-          KEY_WOW64_32KEY);
-    }
   }
 
   if (installer_state.is_multi_install())
     ProcessGoogleUpdateItems(original_state, installer_state, product);
 
   // Get the state of the installed product (if any)
   const ProductState* product_state =
       original_state.GetProductState(installer_state.system_install(),
                                      browser_dist->GetType());
 
@@ skipping 56 matching lines @@
   base::FilePath user_data_dir(GetUserDataDir(product));
   base::FilePath backup_state_file;
   if (!user_data_dir.empty()) {
     backup_state_file = BackupLocalStateFile(user_data_dir);
   } else {
     LOG(ERROR) << "Could not retrieve the user's profile directory.";
     ret = installer::UNINSTALL_FAILED;
     delete_profile = false;
   }
 
-  if (product.is_chrome_app_host()) {
-    DeleteAppHostFilesAndFolders(installer_state, product_state->version());
-  } else if (!installer_state.is_multi_install() ||
-             product.is_chrome_binaries()) {
+  if (!installer_state.is_multi_install() || product.is_chrome_binaries()) {
     DeleteResult delete_result = DeleteChromeFilesAndFolders(
         installer_state, base::MakeAbsoluteFilePath(setup_exe));
     if (delete_result == DELETE_FAILED) {
       ret = installer::UNINSTALL_FAILED;
     } else if (delete_result == DELETE_REQUIRES_REBOOT) {
       ret = installer::UNINSTALL_REQUIRES_REBOOT;
     }
   }
 
   if (delete_profile)
@@ skipping 27 matching lines @@
     LOG(ERROR) << "No installation destination path.";
     *uninstall_status = UNINSTALL_FAILED;
     return;
   }
   if (!target_path.IsParent(base::MakeAbsoluteFilePath(setup_exe))) {
     VLOG(1) << "setup.exe is not in target path. Skipping installer cleanup.";
     return;
   }
   base::FilePath install_directory(setup_exe.DirName());
 
-  bool remove_setup = true;
-  bool remove_archive = true;
-  CheckShouldRemoveSetupAndArchive(original_state, installer_state,
-                                   &remove_setup, &remove_archive);
-  if (!remove_archive)
-    return;
+  bool remove_setup = CheckShouldRemoveSetup(original_state, installer_state);
 
   if (remove_setup) {
     // 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(installer_state, setup_exe);
   }
 
   // Remove files from "...\<product>\Application\<version>\Installer"
   if (!RemoveInstallerFiles(install_directory, remove_setup)) {
@@ skipping 28 matching lines @@
     // If we need a reboot to continue, schedule the parent directories for
     // deletion unconditionally. If they are not empty, the session manager
     // will not delete them on reboot.
     ScheduleParentAndGrandparentForDeletion(target_path);
   } else if (DeleteChromeDirectoriesIfEmpty(target_path) == DELETE_FAILED) {
     *uninstall_status = UNINSTALL_FAILED;
   }
 }
 
 }  // namespace installer