Implement installation of the Chrome App Host.

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 <vector>
 
@@ skipping 31 matching lines @@
 
 // Build-time generated include file.
 #include "registered_dlls.h"  // NOLINT
 
 using base::win::RegKey;
 using installer::InstallStatus;
 using installer::MasterPreferences;
 
 namespace {
 
+// Avoid leaving behind a Temp dir.  If one exists, ask SelfCleaningTempDir to
+// clean it up for us.  This may involve scheduling it for deletion after
+// reboot.  Don't report that a reboot is required in this case, however.
+// TODO(erikwright): Shouldn't this still lead to
+// ScheduleParentAndGrandparentForDeletion?

[grt (UTC plus 2), 2012/07/23 11:31:12]

i don't understand the question; could you elaborate?

+void DeleteInstallTempDir(const FilePath& target_path) {
+  FilePath temp_path(target_path.DirName().Append(installer::kInstallTempDir));
+  if (file_util::DirectoryExists(temp_path)) {
+    installer::SelfCleaningTempDir temp_dir;
+    if (!temp_dir.Initialize(target_path.DirName(),
+                             installer::kInstallTempDir) ||
+        !temp_dir.Delete()) {
+      LOG(ERROR) << "Failed to delete temp dir " << temp_path.value();
+    }
+  }
+}
+
 // Makes appropriate changes to the Google Update "ap" value in the registry.
 // Specifically, removes the flags associated with this product ("-chrome" or
 // "-chromeframe[-readymode]") from the "ap" values for all other
 // installed products and for the multi-installer package.
 void ProcessGoogleUpdateItems(
     const installer::InstallationState& original_state,
     const installer::InstallerState& installer_state,
     const installer::Product& product) {
   DCHECK(installer_state.is_multi_install());
   const bool system_level = installer_state.system_install();
   BrowserDistribution* distribution = product.distribution();
   const HKEY reg_root = installer_state.root_key();
   const installer::ProductState* product_state =
       original_state.GetProductState(system_level, distribution->GetType());
   DCHECK(product_state != NULL);
   installer::ChannelInfo channel_info;
 
   // Remove product's flags from the channel value.
   channel_info.set_value(product_state->channel().value());
   const bool modified = product.SetChannelFlags(false, &channel_info);
 
   // Apply the new channel value to all other products and to the multi package.
   if (modified) {
-    BrowserDistribution::Type other_dist_types[] = {
-        (distribution->GetType() == BrowserDistribution::CHROME_BROWSER) ?
-            BrowserDistribution::CHROME_FRAME :
-            BrowserDistribution::CHROME_BROWSER,
-        BrowserDistribution::CHROME_BINARIES
-    };
     scoped_ptr<WorkItemList>
         update_list(WorkItem::CreateNoRollbackWorkItemList());
 
-    for (int i = 0; i < arraysize(other_dist_types); ++i) {
-      BrowserDistribution::Type other_dist_type = other_dist_types[i];
+    for (size_t i = 0; i < BrowserDistribution::NUM_TYPES; ++i) {
+      BrowserDistribution::Type other_dist_type =
+          static_cast<BrowserDistribution::Type>(i);
+      if (distribution->GetType() == other_dist_type)
+        continue;
+
       product_state =
           original_state.GetProductState(system_level, other_dist_type);
       // Only modify other products if they're installed and multi.
       if (product_state != NULL &&
           product_state->is_multi_install() &&
           !product_state->channel().Equals(channel_info)) {
         BrowserDistribution* other_dist =
             BrowserDistribution::GetSpecificDistribution(other_dist_type);
         update_list->AddSetRegValueWorkItem(reg_root, other_dist->GetStateKey(),
             google_update::kRegApField, channel_info.value(), true);
@@ skipping 14 matching lines @@
 }
 
 // Adds or removes the quick-enable-cf command to the binaries' version key in
 // the registry as needed.
 void ProcessQuickEnableWorkItems(
     const installer::InstallerState& installer_state,
     const installer::InstallationState& machine_state) {
   scoped_ptr<WorkItemList> work_item_list(
       WorkItem::CreateNoRollbackWorkItemList());
 
-  AddQuickEnableWorkItems(installer_state, machine_state, NULL, NULL,
-                          work_item_list.get());
+  AddQuickEnableChromeFrameWorkItems(installer_state, machine_state, NULL, NULL,
+                                     work_item_list.get());
+
+  AddQuickEnableApplicationHostWorkItems(installer_state, machine_state, NULL,
+                                         NULL, work_item_list.get());
   if (!work_item_list->Do())
     LOG(ERROR) << "Failed to update quick-enable-cf command.";
 }
 
 void ProcessIELowRightsPolicyWorkItems(
     const installer::InstallerState& installer_state) {
   scoped_ptr<WorkItemList> work_items(WorkItem::CreateNoRollbackWorkItemList());
   AddDeleteOldIELowRightsPolicyWorkItems(installer_state, work_items.get());
   work_items->Do();
   installer::RefreshElevationPolicy();
@@ skipping 257 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 (ret && !file_util::DeleteAfterReboot(temp_file)) {
       static const uint32 kDeleteAfterMs = 10 * 1000;
       installer::DeleteFileFromTempProcess(temp_file, kDeleteAfterMs);
     }
   }
   return ret;
 }
 
-DeleteResult DeleteFilesAndFolders(const InstallerState& installer_state,
-                                   const Version& installed_version) {
+DeleteResult DeleteAppHostFilesAndFolders(const InstallerState& installer_state,
+                                          const Version& installed_version) {
   const FilePath& target_path = installer_state.target_path();
   if (target_path.empty()) {
-    LOG(ERROR) << "DeleteFilesAndFolders: no installation destination path.";
+    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;
 
-  // Avoid leaving behind a Temp dir.  If one exists, ask SelfCleaningTempDir to
-  // clean it up for us.  This may involve scheduling it for deletion after
-  // reboot.  Don't report that a reboot is required in this case, however.
-  FilePath temp_path(target_path.DirName().Append(kInstallTempDir));
-  if (file_util::DirectoryExists(temp_path)) {
-    installer::SelfCleaningTempDir temp_dir;
-    if (!temp_dir.Initialize(target_path.DirName(), kInstallTempDir) ||
-        !temp_dir.Delete()) {
-      LOG(ERROR) << "Failed to delete temp dir " << temp_path.value();
-    }
+  FilePath app_host_exe(target_path.Append(installer::kChromeAppHostExe));
+  if (!file_util::Delete(app_host_exe, false)) {
+    result = DELETE_FAILED;
+    LOG(ERROR) << "Failed to delete path: " << app_host_exe.value();
+  } else {
+    DeleteEmptyParentDir(target_path);
   }
 
-  VLOG(1) << "Deleting install path " << target_path.value();
-  if (!file_util::Delete(target_path, true)) {
-    LOG(ERROR) << "Failed to delete folder (1st try): " << target_path.value();
-    if (installer_state.FindProduct(BrowserDistribution::CHROME_FRAME)) {
-      // We don't try killing Chrome processes for Chrome Frame builds since
-      // that is unlikely to help. Instead, schedule files for deletion and
-      // return a value that will trigger a reboot prompt.
-      ScheduleDirectoryForDeletion(target_path.value().c_str());
-      result = DELETE_REQUIRES_REBOOT;
-    } else {
-      // Try closing any running chrome processes and deleting files once again.
-      CloseAllChromeProcesses();
-      if (!file_util::Delete(target_path, true)) {
-        LOG(ERROR) << "Failed to delete folder (2nd try): "
-                   << target_path.value();
-        result = DELETE_FAILED;
+  return result;
+}
+
+DeleteResult DeleteChromeFilesAndFolders(const InstallerState& installer_state,
+                                         const Version& installed_version) {
+  const 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;
+
+  using file_util::FileEnumerator;
+  FileEnumerator file_enumerator(
+      target_path,
+      false,
+      static_cast<FileEnumerator::FileType>(FileEnumerator::FILES |
+                                            FileEnumerator::DIRECTORIES));
+  while (true) {
+    FilePath to_delete(file_enumerator.Next());
+    if (to_delete.empty())
+      break;
+    if (to_delete.BaseName().value() == installer::kChromeAppHostExe)
+      continue;
+
+    VLOG(1) << "Deleting install path " << target_path.value();
+    if (!file_util::Delete(to_delete, true)) {
+      LOG(ERROR) << "Failed to delete path (1st try): " << to_delete.value();
+      if (installer_state.FindProduct(BrowserDistribution::CHROME_FRAME)) {
+        // We don't try killing Chrome processes for Chrome Frame builds since
+        // that is unlikely to help. Instead, schedule files for deletion and
+        // return a value that will trigger a reboot prompt.
+        FileEnumerator::FindInfo find_info;
+        file_enumerator.GetFindInfo(&find_info);
+        if (FileEnumerator::IsDirectory(find_info))
+          ScheduleDirectoryForDeletion(to_delete.value().c_str());
+        else
+          ScheduleFileSystemEntityForDeletion(to_delete.value().c_str());
+        result = DELETE_REQUIRES_REBOOT;
+      } else {
+        // Try closing any running Chrome processes and deleting files once
+        // again.
+        CloseAllChromeProcesses();
+        if (!file_util::Delete(to_delete, true)) {
+          LOG(ERROR) << "Failed to delete path (2nd try): "
+                     << to_delete.value();
+          result = DELETE_FAILED;
+          break;
+        }
       }
     }
   }
 
   if (result == DELETE_REQUIRES_REBOOT) {
     // 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 {
@@ skipping 43 matching lines @@
 
 bool ShouldDeleteProfile(const InstallerState& installer_state,
                          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.is_chrome() && !installer_state.is_msi()) {
+  if (product.is_chrome_frame() && !installer_state.is_msi()) {
     should_delete = true;
   } else {
     should_delete =
         status == installer::UNINSTALL_DELETE_PROFILE ||
         cmd_line.HasSwitch(installer::switches::kDeleteProfile);
   }
 
   return should_delete;
 }
 
@@ skipping 246 matching lines @@
   }
 
   // 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.
   if (is_chrome) {
     ClearRlzProductState();
 
     auto_launch_util::DisableAllAutoStartFeatures(
         ASCIIToUTF16(chrome::kInitialProfile));
+
+    // First delete shortcuts from Start->Programs, Desktop & Quick Launch.
+    DeleteChromeShortcuts(installer_state, product);
   }
 
-  // First delete shortcuts from Start->Programs, Desktop & Quick Launch.
-  DeleteChromeShortcuts(installer_state, product);
-
   // 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().
   string16 distribution_data(browser_dist->GetDistributionData(reg_root));
 
-  // Remove Control Panel uninstall link and Omaha product key.
-  InstallUtil::DeleteRegistryKey(reg_root, browser_dist->GetUninstallRegPath());
+  // Remove Control Panel uninstall link.
+  if (product.ShouldCreateUninstallEntry()) {
+    InstallUtil::DeleteRegistryKey(reg_root,
+                                   browser_dist->GetUninstallRegPath());
+  }
+
+  // Remove Omaha product key.
   InstallUtil::DeleteRegistryKey(reg_root, 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(installer_state.system_install(), false);
 
-  // Remove all Chrome registration keys.
-  // Registration data is put in HKCU for both system level and user level
-  // installs.
   InstallStatus ret = installer::UNKNOWN_STATUS;
-  DeleteChromeRegistrationKeys(browser_dist, HKEY_CURRENT_USER, suffix,
-                               installer_state.target_path(), &ret);
 
-  // If the user's Chrome is registered with a suffix: it is possible that old
-  // unsuffixed registrations were left in HKCU (e.g. if this install was
-  // previously installed with no suffix in HKCU (old suffix rules if the user
-  // is not an admin (or declined UAC at first run)) and later had to be
-  // suffixed when fully registered in HKLM (e.g. when later making Chrome
-  // default through the UI)).
-  // Remove remaining HKCU entries with no suffix if any.
-  if (!suffix.empty()) {
-    DeleteChromeRegistrationKeys(browser_dist, HKEY_CURRENT_USER, string16(),
+  if (is_chrome) {
+    // Remove all Chrome registration keys.
+    // Registration data is put in HKCU for both system level and user level
+    // installs.
+    DeleteChromeRegistrationKeys(browser_dist, HKEY_CURRENT_USER, suffix,
                                  installer_state.target_path(), &ret);
 
-    // For similar reasons it is possible in very few installs (from 21.0.1180.0
-    // and fixed shortly after) to be installed with the new-style suffix, but
-    // have some old-style suffix registrations left behind.
-    string16 old_style_suffix;
-    if (ShellUtil::GetOldUserSpecificRegistrySuffix(&old_style_suffix) &&
-        suffix != old_style_suffix) {
-      DeleteChromeRegistrationKeys(browser_dist, HKEY_CURRENT_USER,
-                                   old_style_suffix,
+    // If the user's Chrome is registered with a suffix: it is possible that old
+    // unsuffixed registrations were left in HKCU (e.g. if this install was
+    // previously installed with no suffix in HKCU (old suffix rules if the user
+    // is not an admin (or declined UAC at first run)) and later had to be
+    // suffixed when fully registered in HKLM (e.g. when later making Chrome
+    // default through the UI)).
+    // Remove remaining HKCU entries with no suffix if any.
+    if (!suffix.empty()) {
+      DeleteChromeRegistrationKeys(browser_dist, HKEY_CURRENT_USER, string16(),
+                                   installer_state.target_path(), &ret);
+
+      // For similar reasons it is possible in very few installs (from
+      // 21.0.1180.0 and fixed shortly after) to be installed with the new-style
+      // suffix, but have some old-style suffix registrations left behind.
+      string16 old_style_suffix;
+      if (ShellUtil::GetOldUserSpecificRegistrySuffix(&old_style_suffix) &&
+          suffix != old_style_suffix) {
+        DeleteChromeRegistrationKeys(browser_dist, HKEY_CURRENT_USER,
+                                     old_style_suffix,
+                                     installer_state.target_path(), &ret);
+      }
+    }
+
+    // Chrome is registered in HKLM for all system-level installs and for
+    // user-level installs for which Chrome has been made the default browser.
+    // Always remove the HKLM registration for system-level installs.  For
+    // user-level installs, only remove it if both: 1) this uninstall isn't a
+    // self destruct following the installation of a system-level Chrome
+    // (because the system-level Chrome owns the HKLM registration now), and 2)
+    // this user has made Chrome their default browser (i.e. has shell
+    // integration entries registered with |suffix| (note: |suffix| will be the
+    // empty string if required as it is obtained by
+    // GetCurrentInstallationSuffix() above)).
+    // TODO(gab): This can still leave parts of a suffixed install behind. To be
+    // able to remove them we would need to be able to remove only suffixed
+    // entries (as it is now some of the shell integration entries are
+    // unsuffixed; thus removing suffixed installs is prohibited in HKLM if
+    // !|remove_all| for now).
+    if (installer_state.system_install() ||
+        (remove_all &&
+         ShellUtil::QuickIsChromeRegisteredInHKLM(
+             browser_dist, chrome_exe, suffix))) {
+      DeleteChromeRegistrationKeys(browser_dist, HKEY_LOCAL_MACHINE, suffix,
                                    installer_state.target_path(), &ret);
     }
+
+    ProcessDelegateExecuteWorkItems(installer_state, product);
   }
 
-  // Chrome is registered in HKLM for all system-level installs and for
-  // user-level installs for which Chrome has been made the default browser.
-  // Always remove the HKLM registration for system-level installs.  For
-  // user-level installs, only remove it if both: 1) this uninstall isn't a self
-  // destruct following the installation of a system-level Chrome (because the
-  // system-level Chrome owns the HKLM registration now), and 2) this user has
-  // made Chrome their default browser (i.e. has shell integration entries
-  // registered with |suffix| (note: |suffix| will be the empty string if
-  // required as it is obtained by GetCurrentInstallationSuffix() above)).
-  // TODO(gab): This can still leave parts of a suffixed install behind. To be
-  // able to remove them we would need to be able to remove only suffixed
-  // entries (as it is now some of the shell integration entries are unsuffixed;
-  // thus removing suffixed installs is prohibited in HKLM if !|remove_all| for
-  // now).
-  if (installer_state.system_install() ||
-      (remove_all &&
-       ShellUtil::QuickIsChromeRegisteredInHKLM(
-           browser_dist, chrome_exe, suffix))) {
-    DeleteChromeRegistrationKeys(browser_dist, HKEY_LOCAL_MACHINE, suffix,
-                                 installer_state.target_path(), &ret);
-  }
-
-  ProcessDelegateExecuteWorkItems(installer_state, product);
-
-  if (!is_chrome) {
+  if (product.is_chrome_frame()) {
     ProcessChromeFrameWorkItems(original_state, installer_state, setup_path,
                                 product);
   }
 
   if (installer_state.is_multi_install())
     ProcessGoogleUpdateItems(original_state, installer_state, product);
 
   ProcessQuickEnableWorkItems(installer_state, original_state);
 
   // Get the state of the installed product (if any)
@@ skipping 27 matching lines @@
 
       AddRegisterComDllWorkItems(dll_folder,
                                  com_dll_list,
                                  installer_state.system_install(),
                                  false,  // Unregister
                                  true,   // May fail
                                  unreg_work_item_list.get());
       unreg_work_item_list->Do();
     }
 
-    if (!is_chrome)
+    if (product.is_chrome_frame())
       ProcessIELowRightsPolicyWorkItems(installer_state);
   }
 
   // Close any Chrome Frame helper processes that may be running.
   if (product.is_chrome_frame()) {
     VLOG(1) << "Closing the Chrome Frame helper process";
     CloseChromeFrameHelperProcess();
   }
 
   if (product_state == NULL)
     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(installer_state, cmd_line, status,
                                             product);
   ret = installer::UNINSTALL_SUCCESSFUL;
 
   // When deleting files, we must make sure that we're either a "single"
-  // (aka non-multi) installation or, in the case of multi, that no other
-  // "multi" products share the binaries we are about to delete.
+  // (aka non-multi) installation or we are the Chrome Binaries.
 
-  bool can_delete_files = true;
-  if (installer_state.is_multi_install()) {
-    ProductState prod_state;
-    for (size_t i = 0; i < BrowserDistribution::kNumProductTypes; ++i) {
-      if (prod_state.Initialize(installer_state.system_install(),
-                                BrowserDistribution::kProductTypes[i]) &&
-          prod_state.is_multi_install()) {
-        can_delete_files = false;
-        break;
-      }
-    }
-    LOG(INFO) << (can_delete_files ? "Shared binaries will be deleted." :
-                                     "Shared binaries still in use.");
-    if (can_delete_files) {
-      BrowserDistribution* multi_dist =
-          installer_state.multi_package_binaries_distribution();
-      InstallUtil::DeleteRegistryKey(reg_root, multi_dist->GetVersionKey());
-    }
-  }
-
-  FilePath backup_state_file(BackupLocalStateFile(
-      GetLocalStateFolder(product)));
+  FilePath backup_state_file(
+      BackupLocalStateFile(GetLocalStateFolder(product)));
 
   DeleteResult delete_result = DELETE_SUCCEEDED;
-  if (can_delete_files) {
+
+  if (product.is_chrome_app_host()) {
+    DeleteAppHostFilesAndFolders(installer_state, product_state->version());
+  } else if (!installer_state.is_multi_install() ||
+             product.is_chrome_binaries()) {
+
     // 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_path,
                                 product_state->version());
-    delete_result = DeleteFilesAndFolders(installer_state,
-                                          product_state->version());
+    delete_result = DeleteChromeFilesAndFolders(installer_state,
+                                                product_state->version());
   }
 
   if (delete_profile)
     DeleteLocalState(product);
 
   if (delete_result == DELETE_FAILED) {
     ret = installer::UNINSTALL_FAILED;
   } else if (delete_result == DELETE_REQUIRES_REBOOT) {
     ret = installer::UNINSTALL_REQUIRES_REBOOT;
   }
 
   if (!force_uninstall) {
-    VLOG(1) << "Uninstallation complete. Launching Uninstall survey.";
+    VLOG(1) << "Uninstallation complete. Launching post-uninstall operations.";
     browser_dist->DoPostUninstallOperations(product_state->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