Remove stale code to delete the metro user data dir. It never shipped.

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>
 
@@ skipping 32 matching lines @@
 #include "chrome/installer/util/installer_state.h"
 #include "chrome/installer/util/logging_installer.h"
 #include "chrome/installer/util/self_cleaning_temp_dir.h"
 #include "chrome/installer/util/shell_util.h"
 #include "chrome/installer/util/util_constants.h"
 #include "content/public/common/result_codes.h"
 #include "extensions/common/constants.h"
 #include "rlz/lib/rlz_lib.h"
 
 using base::win::RegKey;
-using installer::InstallStatus;
-using installer::MasterPreferences;
+
+namespace installer {

[grt (UTC plus 2), 2014/04/02 16:53:10]

In patch set 2, I've moved all private functions into the unnamed namespace.
This required some code motion, which explains the big deleted and added blocks.

[gab, 2014/04/02 17:20:14]

Sounds good, I assume the code didn't change (didn't review closely).

 
 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?
 void DeleteInstallTempDir(const base::FilePath& target_path) {
   base::FilePath temp_path(target_path.DirName().Append(
       installer::kInstallTempDir));
   if (base::DirectoryExists(temp_path)) {
-    installer::SelfCleaningTempDir temp_dir;
+    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();
     }
   }
 }
 
 // Iterates over the list of distribution types in |dist_types|, and
 // adds to |update_list| the work item to update the corresponding "ap"
 // registry value specified in |channel_info|.
 void AddChannelValueUpdateWorkItems(
-    const installer::InstallationState& original_state,
-    const installer::InstallerState& installer_state,
-    const installer::ChannelInfo& channel_info,
+    const InstallationState& original_state,
+    const InstallerState& installer_state,
+    const ChannelInfo& channel_info,
     const std::vector<BrowserDistribution::Type>& dist_types,
     WorkItemList* update_list) {
   const bool system_level = installer_state.system_install();
   const HKEY reg_root = installer_state.root_key();
   for (size_t i = 0; i < dist_types.size(); ++i) {
     BrowserDistribution::Type dist_type = dist_types[i];
-    const installer::ProductState* product_state =
+    const ProductState* product_state =
         original_state.GetProductState(system_level, 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(dist_type);
       update_list->AddSetRegValueWorkItem(reg_root, other_dist->GetStateKey(),
           google_update::kRegApField, channel_info.value(), true);
     } else {
       LOG_IF(ERROR,
              product_state != NULL && product_state->is_multi_install())
           << "Channel value for "
           << BrowserDistribution::GetSpecificDistribution(
                  dist_type)->GetDisplayName()
           << " is somehow already set to the desired new value of "
           << channel_info.value();
     }
   }
 }
 
 // Makes appropriate changes to the Google Update "ap" value in the registry.
 // Specifically, removes the flags associated with this product ("-chrome" or
 // "-chromeframe") 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) {
+void ProcessGoogleUpdateItems(const InstallationState& original_state,
+                              const InstallerState& installer_state,
+                              const Product& product) {
   DCHECK(installer_state.is_multi_install());
   const bool system_level = installer_state.system_install();
   BrowserDistribution* distribution = product.distribution();
-  const installer::ProductState* product_state =
+  const ProductState* product_state =
       original_state.GetProductState(system_level, distribution->GetType());
   DCHECK(product_state != NULL);
-  installer::ChannelInfo channel_info;
+  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) {
     scoped_ptr<WorkItemList>
         update_list(WorkItem::CreateNoRollbackWorkItemList());
     std::vector<BrowserDistribution::Type> dist_types;
     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)
         dist_types.push_back(other_dist_type);
     }
     AddChannelValueUpdateWorkItems(original_state, installer_state,
                                    channel_info, dist_types,
                                    update_list.get());
     bool success = update_list->Do();
     LOG_IF(ERROR, !success) << "Failed updating channel values.";
   }
 }
 
-void ProcessOnOsUpgradeWorkItems(
-    const installer::InstallerState& installer_state,
-    const installer::Product& product) {
+void ProcessOnOsUpgradeWorkItems(const InstallerState& installer_state,
+                                 const Product& product) {
   scoped_ptr<WorkItemList> work_item_list(
       WorkItem::CreateNoRollbackWorkItemList());
   AddOsUpgradeWorkItems(installer_state, base::FilePath(), Version(), product,
                         work_item_list.get());
   if (!work_item_list->Do())
     LOG(ERROR) << "Failed to remove on-os-upgrade command.";
 }
 
-void ProcessIELowRightsPolicyWorkItems(
-    const installer::InstallerState& installer_state) {
+void ProcessIELowRightsPolicyWorkItems(const InstallerState& installer_state) {
   scoped_ptr<WorkItemList> work_items(WorkItem::CreateNoRollbackWorkItemList());
   AddDeleteOldIELowRightsPolicyWorkItems(installer_state, work_items.get());
   work_items->Do();
-  installer::RefreshElevationPolicy();
+  RefreshElevationPolicy();
 }
 
 void ClearRlzProductState() {
   const rlz_lib::AccessPoint points[] = {rlz_lib::CHROME_OMNIBOX,
                                          rlz_lib::CHROME_HOME_PAGE,
                                          rlz_lib::NO_ACCESS_POINT};
 
   rlz_lib::ClearProductState(rlz_lib::CHROME, points);
 
   // 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 installer::InstallationState& original_state,
-    const installer::InstallerState& installer_state,
-    bool* remove_setup,
-    bool* remove_archive) {
+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.
   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 installer::ProductState* product_state =
-          original_state.GetProductState(
-              installer_state.system_install(), dist_type);
+      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) {
@@ skipping 33 matching lines @@
     VLOG(1) << "Deleting installer path " << to_delete.value();
     if (!base::DeleteFile(to_delete, true)) {
       LOG(ERROR) << "Failed to delete path: " << to_delete.value();
       success = false;
     }
   }
 
   return success;
 }
 
-}  // namespace
-
-namespace installer {
-
 // Kills all Chrome processes, immediately.
 void CloseAllChromeProcesses() {
   base::CleanupProcesses(installer::kChromeExe, base::TimeDelta(),
                          content::RESULT_CODE_HUNG, NULL);
   base::CleanupProcesses(installer::kNaClExe, base::TimeDelta(),
                          content::RESULT_CODE_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.
@@ skipping 111 matching lines @@
   if (!base::IsDirectoryEmpty(path))
     return DELETE_NOT_EMPTY;
 
   if (base::DeleteFile(path, true))
     return DELETE_SUCCEEDED;
 
   LOG(ERROR) << "Failed to delete folder: " << path.value();
   return DELETE_FAILED;
 }
 
-void GetLocalStateFolders(const Product& product,
-                          std::vector<base::FilePath>* paths) {
+base::FilePath GetUserDataDir(const Product& product) {
   // Obtain the location of the user profile data.
-  product.GetUserDataPaths(paths);
-  LOG_IF(ERROR, paths->empty())
+  base::FilePath user_data_dir = product.GetUserDataPath();
+  LOG_IF(ERROR, user_data_dir.empty())
       << "Could not retrieve user's profile directory.";
+
+  return user_data_dir;
 }
 
 // Creates a copy of the local state file and returns a path to the copy.
-base::FilePath BackupLocalStateFile(
-    const std::vector<base::FilePath>& local_state_folders) {
+base::FilePath BackupLocalStateFile(const base::FilePath& user_data_dir) {
   base::FilePath backup;
-
-  // Copy the first local state file that is found.
-  for (size_t i = 0; i < local_state_folders.size(); ++i) {
-    const base::FilePath& local_state_folder = local_state_folders[i];
-    base::FilePath state_file(
-        local_state_folder.Append(chrome::kLocalStateFilename));
-    if (!base::PathExists(state_file))
-      continue;
-    if (!base::CreateTemporaryFile(&backup))
-      LOG(ERROR) << "Failed to create temporary file for Local State.";
-    else
-      base::CopyFile(state_file, backup);
-    break;
-  }
+  base::FilePath state_file(
+      user_data_dir.Append(chrome::kLocalStateFilename));
+  if (!base::CreateTemporaryFile(&backup))
+    LOG(ERROR) << "Failed to create temporary file for Local State.";
+  else
+    base::CopyFile(state_file, backup);
   return backup;
 }
 
-// Deletes all user data directories for a product.
-DeleteResult DeleteLocalState(
-    const std::vector<base::FilePath>& local_state_folders,
-    bool schedule_on_failure) {
-  if (local_state_folders.empty())
+// Deletes a product's user data directory.

[gab, 2014/04/02 17:20:14]

I think this method used to take a |product| argument, but it no longer does and
this comment should no longer refer to "product" IMO.

[grt (UTC plus 2), 2014/04/02 18:04:12]

Done.

+DeleteResult DeleteUserDataDir(const base::FilePath& user_data_dir,
+                               bool schedule_on_failure) {
+  if (user_data_dir.empty())
     return DELETE_SUCCEEDED;
 
   DeleteResult result = DELETE_SUCCEEDED;
-  for (size_t i = 0; i < local_state_folders.size(); ++i) {
-    const base::FilePath& user_local_state = local_state_folders[i];
-    VLOG(1) << "Deleting user profile " << user_local_state.value();
-    if (!base::DeleteFile(user_local_state, true)) {
-      LOG(ERROR) << "Failed to delete user profile dir: "
-                 << user_local_state.value();
-      if (schedule_on_failure) {
-        ScheduleDirectoryForDeletion(user_local_state);
-        result = DELETE_REQUIRES_REBOOT;
-      } else {
-        result = DELETE_FAILED;
-      }
+  VLOG(1) << "Deleting user profile " << user_data_dir.value();
+  if (!base::DeleteFile(user_data_dir, true)) {
+    LOG(ERROR) << "Failed to delete user profile dir: "
+               << user_data_dir.value();
+    if (schedule_on_failure) {
+      ScheduleDirectoryForDeletion(user_data_dir);
+      result = DELETE_REQUIRES_REBOOT;
+    } else {
+      result = DELETE_FAILED;
     }
   }
 
   if (result == DELETE_REQUIRES_REBOOT) {
-    ScheduleParentAndGrandparentForDeletion(local_state_folders[0]);
+    ScheduleParentAndGrandparentForDeletion(user_data_dir);
   } else {
-    const base::FilePath user_data_dir(local_state_folders[0].DirName());
+    const base::FilePath user_data_dir(user_data_dir.DirName());
     if (!user_data_dir.empty() &&
         DeleteEmptyDir(user_data_dir) == DELETE_SUCCEEDED) {
       const base::FilePath product_dir(user_data_dir.DirName());
       if (!product_dir.empty())
         DeleteEmptyDir(product_dir);
     }
   }
 
   return result;
 }
@@ skipping 51 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 DeleteChromeDirectoriesIfEmpty(
-    const base::FilePath& application_directory) {
-  DeleteResult result(DeleteEmptyDir(application_directory));
-  if (result == DELETE_SUCCEEDED) {
-    // Now check and delete if the parent directories are empty
-    // For example Google\Chrome or Chromium
-    const base::FilePath product_directory(application_directory.DirName());
-    if (!product_directory.empty()) {
-        result = DeleteEmptyDir(product_directory);
-        if (result == DELETE_SUCCEEDED) {
-          const base::FilePath vendor_directory(product_directory.DirName());
-          if (!vendor_directory.empty())
-            result = DeleteEmptyDir(vendor_directory);
-        }
-    }
-  }
-  if (result == DELETE_NOT_EMPTY)
-    result = DELETE_SUCCEEDED;
-  return result;
-}
-
 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);
@@ skipping 195 matching lines @@
                   key.WriteValue(NULL, replacement_prog_id) != ERROR_SUCCESS)) {
         // The replacement ProgID is registered on the computer but the attempt
         // to set it for the filetype failed.
         LOG(ERROR) << "Failed to restore system-level filetype association "
                    << assoc << " = " << replacement_prog_id;
       }
     }
   }
 }
 
+// Builds and executes a work item list to remove DelegateExecute verb handler
+// work items for |product|.  This will be a noop for products whose
+// corresponding BrowserDistribution implementations do not publish a CLSID via
+// GetCommandExecuteImplClsid.
+bool ProcessDelegateExecuteWorkItems(const InstallerState& installer_state,
+                                     const Product& product) {
+  scoped_ptr<WorkItemList> item_list(WorkItem::CreateNoRollbackWorkItemList());
+  AddDelegateExecuteWorkItems(installer_state, base::FilePath(), Version(),
+                              product, item_list.get());
+  return item_list->Do();
+}
+
+// Removes Active Setup entries from the registry. This cannot be done through
+// a work items list as usual because of different paths based on conditionals,
+// but otherwise respects the no rollback/best effort uninstall mentality.
+// This will only apply for system-level installs of Chrome/Chromium and will be
+// a no-op for all other types of installs.
+void UninstallActiveSetupEntries(const InstallerState& installer_state,
+                                 const Product& product) {
+  VLOG(1) << "Uninstalling registry entries for ActiveSetup.";
+  BrowserDistribution* distribution = product.distribution();
+
+  if (!product.is_chrome() || !installer_state.system_install()) {
+    const char* install_level =
+        installer_state.system_install() ? "system" : "user";
+    VLOG(1) << "No Active Setup processing to do for " << install_level
+            << "-level " << distribution->GetDisplayName();
+    return;
+  }
+
+  const base::string16 active_setup_path(
+      InstallUtil::GetActiveSetupPath(distribution));
+  InstallUtil::DeleteRegistryKey(HKEY_LOCAL_MACHINE, active_setup_path);
+
+  // Windows leaves keys behind in HKCU\\Software\\(Wow6432Node\\)?Microsoft\\
+  //     Active Setup\\Installed Components\\{guid}
+  // for every user that logged in since system-level Chrome was installed.
+  // This is a problem because Windows compares the value of the Version subkey
+  // in there with the value of the Version subkey in the matching HKLM entries
+  // before running Chrome's Active Setup so if Chrome was to be reinstalled
+  // with a lesser version (e.g. switching back to a more stable channel), the
+  // affected users would not have Chrome's Active Setup called until Chrome
+  // eventually updated passed that user's registered Version.
+  //
+  // It is however very hard to delete those values as the registry hives for
+  // other users are not loaded by default under HKEY_USERS (unless a user is
+  // logged on or has a process impersonating him).
+  //
+  // Following our best effort uninstall practices, try to delete the value in
+  // all users hives. If a given user's hive is not loaded, try to load it to
+  // proceed with the deletion (failure to do so is ignored).
+
+  static const wchar_t kProfileList[] =
+      L"Software\\Microsoft\\Windows NT\\CurrentVersion\\ProfileList\\";
+
+  // Windows automatically adds Wow6432Node when creating/deleting the HKLM key,
+  // but doesn't seem to do so when manually deleting the user-level keys it
+  // created.
+  base::string16 alternate_active_setup_path(active_setup_path);
+  alternate_active_setup_path.insert(arraysize("Software\\") - 1,
+                                     L"Wow6432Node\\");
+
+  // These two privileges are required by RegLoadKey() and RegUnloadKey() below.
+  ScopedTokenPrivilege se_restore_name_privilege(SE_RESTORE_NAME);
+  ScopedTokenPrivilege se_backup_name_privilege(SE_BACKUP_NAME);
+  if (!se_restore_name_privilege.is_enabled() ||
+      !se_backup_name_privilege.is_enabled()) {
+    // This is not a critical failure as those privileges aren't required to
+    // clean hives that are already loaded, but attempts to LoadRegKey() below
+    // will fail.
+    LOG(WARNING) << "Failed to enable privileges required to load registry "
+                    "hives.";
+  }
+
+  for (base::win::RegistryKeyIterator it(HKEY_LOCAL_MACHINE, kProfileList);
+       it.Valid(); ++it) {
+    const wchar_t* profile_sid = it.Name();
+
+    // First check if this user's registry hive needs to be loaded in
+    // HKEY_USERS.
+    base::win::RegKey user_reg_root_probe(
+        HKEY_USERS, profile_sid, KEY_READ);
+    bool loaded_hive = false;
+    if (!user_reg_root_probe.Valid()) {
+      VLOG(1) << "Attempting to load registry hive for " << profile_sid;
+
+      base::string16 reg_profile_info_path(kProfileList);
+      reg_profile_info_path.append(profile_sid);
+      base::win::RegKey reg_profile_info_key(
+          HKEY_LOCAL_MACHINE, reg_profile_info_path.c_str(), KEY_READ);
+
+      base::string16 profile_path;
+      LONG result = reg_profile_info_key.ReadValue(L"ProfileImagePath",
+                                                   &profile_path);
+      if (result != ERROR_SUCCESS) {
+        LOG(ERROR) << "Error reading ProfileImagePath: " << result;
+        continue;
+      }
+      base::FilePath registry_hive_file(profile_path);
+      registry_hive_file = registry_hive_file.AppendASCII("NTUSER.DAT");
+
+      result = RegLoadKey(HKEY_USERS, profile_sid,
+                          registry_hive_file.value().c_str());
+      if (result != ERROR_SUCCESS) {
+        LOG(ERROR) << "Error loading registry hive: " << result;
+        continue;
+      }
+
+      VLOG(1) << "Loaded registry hive for " << profile_sid;
+      loaded_hive = true;
+    }
+
+    base::win::RegKey user_reg_root(
+        HKEY_USERS, profile_sid, KEY_ALL_ACCESS);
+
+    LONG result = user_reg_root.DeleteKey(active_setup_path.c_str());
+    if (result != ERROR_SUCCESS) {
+      result = user_reg_root.DeleteKey(alternate_active_setup_path.c_str());
+      if (result != ERROR_SUCCESS && result != ERROR_FILE_NOT_FOUND) {
+        LOG(ERROR) << "Failed to delete key at " << active_setup_path
+                   << " and at " << alternate_active_setup_path
+                   << ", result: " << result;
+      }
+    }
+
+    if (loaded_hive) {
+      user_reg_root.Close();
+      if (RegUnLoadKey(HKEY_USERS, profile_sid) == ERROR_SUCCESS)
+        VLOG(1) << "Unloaded registry hive for " << profile_sid;
+      else
+        LOG(ERROR) << "Error unloading registry hive for " << profile_sid;
+    }
+  }
+}
+
+}  // namespace
+
+DeleteResult DeleteChromeDirectoriesIfEmpty(
+    const base::FilePath& application_directory) {
+  DeleteResult result(DeleteEmptyDir(application_directory));
+  if (result == DELETE_SUCCEEDED) {
+    // Now check and delete if the parent directories are empty
+    // For example Google\Chrome or Chromium
+    const base::FilePath product_directory(application_directory.DirName());
+    if (!product_directory.empty()) {
+        result = DeleteEmptyDir(product_directory);
+        if (result == DELETE_SUCCEEDED) {
+          const base::FilePath vendor_directory(product_directory.DirName());
+          if (!vendor_directory.empty())
+            result = DeleteEmptyDir(vendor_directory);
+        }
+    }
+  }
+  if (result == DELETE_NOT_EMPTY)
+    result = DELETE_SUCCEEDED;
+  return result;
+}
+
 bool DeleteChromeRegistrationKeys(const InstallerState& installer_state,
                                   BrowserDistribution* dist,
                                   HKEY root,
                                   const base::string16& browser_entry_suffix,
                                   InstallStatus* exit_code) {
   DCHECK(exit_code);
   if (dist->GetDefaultBrowserControlPolicy() ==
       BrowserDistribution::DEFAULT_BROWSER_UNSUPPORTED) {
     // We should have never set those keys.
     return true;
@@ skipping 151 matching lines @@
     InstallUtil::DeleteRegistryKey(roots[i], ext_prog_id);
 
     // Delete Software\Classes\.crx,
     base::string16 ext_association(ShellUtil::kRegClasses);
     ext_association.append(L"\\");
     ext_association.append(extensions::kExtensionFileExtension);
     InstallUtil::DeleteRegistryKey(roots[i], ext_association);
   }
 }
 
-// Builds and executes a work item list to remove DelegateExecute verb handler
-// work items for |product|.  This will be a noop for products whose
-// corresponding BrowserDistribution implementations do not publish a CLSID via
-// GetCommandExecuteImplClsid.
-bool ProcessDelegateExecuteWorkItems(const InstallerState& installer_state,
-                                     const Product& product) {
-  scoped_ptr<WorkItemList> item_list(WorkItem::CreateNoRollbackWorkItemList());
-  AddDelegateExecuteWorkItems(installer_state, base::FilePath(), Version(),
-                              product, item_list.get());
-  return item_list->Do();
-}
-
-// Removes Active Setup entries from the registry. This cannot be done through
-// a work items list as usual because of different paths based on conditionals,
-// but otherwise respects the no rollback/best effort uninstall mentality.
-// This will only apply for system-level installs of Chrome/Chromium and will be
-// a no-op for all other types of installs.
-void UninstallActiveSetupEntries(const InstallerState& installer_state,
-                                 const Product& product) {
-  VLOG(1) << "Uninstalling registry entries for ActiveSetup.";
-  BrowserDistribution* distribution = product.distribution();
-
-  if (!product.is_chrome() || !installer_state.system_install()) {
-    const char* install_level =
-        installer_state.system_install() ? "system" : "user";
-    VLOG(1) << "No Active Setup processing to do for " << install_level
-            << "-level " << distribution->GetDisplayName();
-    return;
-  }
-
-  const base::string16 active_setup_path(
-      InstallUtil::GetActiveSetupPath(distribution));
-  InstallUtil::DeleteRegistryKey(HKEY_LOCAL_MACHINE, active_setup_path);
-
-  // Windows leaves keys behind in HKCU\\Software\\(Wow6432Node\\)?Microsoft\\
-  //     Active Setup\\Installed Components\\{guid}
-  // for every user that logged in since system-level Chrome was installed.
-  // This is a problem because Windows compares the value of the Version subkey
-  // in there with the value of the Version subkey in the matching HKLM entries
-  // before running Chrome's Active Setup so if Chrome was to be reinstalled
-  // with a lesser version (e.g. switching back to a more stable channel), the
-  // affected users would not have Chrome's Active Setup called until Chrome
-  // eventually updated passed that user's registered Version.
-  //
-  // It is however very hard to delete those values as the registry hives for
-  // other users are not loaded by default under HKEY_USERS (unless a user is
-  // logged on or has a process impersonating him).
-  //
-  // Following our best effort uninstall practices, try to delete the value in
-  // all users hives. If a given user's hive is not loaded, try to load it to
-  // proceed with the deletion (failure to do so is ignored).
-
-  static const wchar_t kProfileList[] =
-      L"Software\\Microsoft\\Windows NT\\CurrentVersion\\ProfileList\\";
-
-  // Windows automatically adds Wow6432Node when creating/deleting the HKLM key,
-  // but doesn't seem to do so when manually deleting the user-level keys it
-  // created.
-  base::string16 alternate_active_setup_path(active_setup_path);
-  alternate_active_setup_path.insert(arraysize("Software\\") - 1,
-                                     L"Wow6432Node\\");
-
-  // These two privileges are required by RegLoadKey() and RegUnloadKey() below.
-  ScopedTokenPrivilege se_restore_name_privilege(SE_RESTORE_NAME);
-  ScopedTokenPrivilege se_backup_name_privilege(SE_BACKUP_NAME);
-  if (!se_restore_name_privilege.is_enabled() ||
-      !se_backup_name_privilege.is_enabled()) {
-    // This is not a critical failure as those privileges aren't required to
-    // clean hives that are already loaded, but attempts to LoadRegKey() below
-    // will fail.
-    LOG(WARNING) << "Failed to enable privileges required to load registry "
-                    "hives.";
-  }
-
-  for (base::win::RegistryKeyIterator it(HKEY_LOCAL_MACHINE, kProfileList);
-       it.Valid(); ++it) {
-    const wchar_t* profile_sid = it.Name();
-
-    // First check if this user's registry hive needs to be loaded in
-    // HKEY_USERS.
-    base::win::RegKey user_reg_root_probe(
-        HKEY_USERS, profile_sid, KEY_READ);
-    bool loaded_hive = false;
-    if (!user_reg_root_probe.Valid()) {
-      VLOG(1) << "Attempting to load registry hive for " << profile_sid;
-
-      base::string16 reg_profile_info_path(kProfileList);
-      reg_profile_info_path.append(profile_sid);
-      base::win::RegKey reg_profile_info_key(
-          HKEY_LOCAL_MACHINE, reg_profile_info_path.c_str(), KEY_READ);
-
-      base::string16 profile_path;
-      LONG result = reg_profile_info_key.ReadValue(L"ProfileImagePath",
-                                                   &profile_path);
-      if (result != ERROR_SUCCESS) {
-        LOG(ERROR) << "Error reading ProfileImagePath: " << result;
-        continue;
-      }
-      base::FilePath registry_hive_file(profile_path);
-      registry_hive_file = registry_hive_file.AppendASCII("NTUSER.DAT");
-
-      result = RegLoadKey(HKEY_USERS, profile_sid,
-                          registry_hive_file.value().c_str());
-      if (result != ERROR_SUCCESS) {
-        LOG(ERROR) << "Error loading registry hive: " << result;
-        continue;
-      }
-
-      VLOG(1) << "Loaded registry hive for " << profile_sid;
-      loaded_hive = true;
-    }
-
-    base::win::RegKey user_reg_root(
-        HKEY_USERS, profile_sid, KEY_ALL_ACCESS);
-
-    LONG result = user_reg_root.DeleteKey(active_setup_path.c_str());
-    if (result != ERROR_SUCCESS) {
-      result = user_reg_root.DeleteKey(alternate_active_setup_path.c_str());
-      if (result != ERROR_SUCCESS && result != ERROR_FILE_NOT_FOUND) {
-        LOG(ERROR) << "Failed to delete key at " << active_setup_path
-                   << " and at " << alternate_active_setup_path
-                   << ", result: " << result;
-      }
-    }
-
-    if (loaded_hive) {
-      user_reg_root.Close();
-      if (RegUnLoadKey(HKEY_USERS, profile_sid) == ERROR_SUCCESS)
-        VLOG(1) << "Unloaded registry hive for " << profile_sid;
-      else
-        LOG(ERROR) << "Error unloading registry hive for " << profile_sid;
-    }
-  }
-}
-
 InstallStatus UninstallProduct(const InstallationState& original_state,
                                const InstallerState& installer_state,
                                const base::FilePath& setup_exe,
                                const Product& product,
                                bool remove_all,
                                bool force_uninstall,
                                const CommandLine& cmd_line) {
   InstallStatus status = installer::UNINSTALL_CONFIRMED;
   BrowserDistribution* browser_dist = product.distribution();
   const base::string16 chrome_exe(
@@ skipping 248 matching lines @@
 
   // 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 we are the Chrome Binaries.
 
-  std::vector<base::FilePath> local_state_folders;
-  GetLocalStateFolders(product, &local_state_folders);
-  base::FilePath backup_state_file(BackupLocalStateFile(local_state_folders));
+  base::FilePath user_data_dir(GetUserDataDir(product));
+  base::FilePath backup_state_file(BackupLocalStateFile(user_data_dir));
 
   if (product.is_chrome_app_host()) {
     DeleteAppHostFilesAndFolders(installer_state, product_state->version());
   } else 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)
-    DeleteLocalState(local_state_folders, product.is_chrome_frame());
+    DeleteUserDataDir(user_data_dir, product.is_chrome_frame());
 
   if (!force_uninstall) {
     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())
@@ skipping 70 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