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

This more or less reverts r149968.

BUG=none
TBR=sky@chromium.org

Review URL: https://codereview.chromium.org/218683013

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@261457 0039d316-1c4b-4281-b951-d872f2087c98

chrome/common/chrome_constants.cc

@@ -244,8 +244,6 @@ const int kHighestRendererOomScore = 1000;
 #endif
 
 #if defined(OS_WIN)
-// This is used by chrome in Windows 8 metro mode.
-const wchar_t kMetroChromeUserDataSubDir[] = L"Metro";
 const wchar_t kMetroNavigationAndSearchMessage[] =
     L"CHROME_METRO_NAV_SEARCH_REQUEST";
 const wchar_t kMetroGetCurrentTabInfoMessage[] =

chrome/common/chrome_constants.h

@@ -126,8 +126,6 @@ extern const int kHighestRendererOomScore;
 #endif
 
 #if defined(OS_WIN)
-// Used by Metro Chrome to create the profile under a custom subdirectory.
-extern const wchar_t kMetroChromeUserDataSubDir[];
 // Used by Metro Chrome to initiate navigation and search requests.
 extern const wchar_t kMetroNavigationAndSearchMessage[];
 // Used by Metro Chrome to get information about the current tab.

chrome/installer/setup/uninstall.cc

@@ -50,8 +50,8 @@
 #include "rlz/lib/rlz_lib.h"
 
 using base::win::RegKey;
-using installer::InstallStatus;
-using installer::MasterPreferences;
+
+namespace installer {
 
 namespace {
 
@@ -64,7 +64,7 @@ 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()) {
@@ -77,16 +77,16 @@ void DeleteInstallTempDir(const base::FilePath& target_path) {
 // 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 &&
@@ -112,17 +112,16 @@ void AddChannelValueUpdateWorkItems(
 // 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());
@@ -147,9 +146,8 @@ void ProcessGoogleUpdateItems(
   }
 }
 
-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,
@@ -158,12 +156,11 @@ void ProcessOnOsUpgradeWorkItems(
     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() {
@@ -187,9 +184,8 @@ void ClearRlzProductState() {
 // * 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,
+void CheckShouldRemoveSetupAndArchive(const InstallationState& original_state,
+                                      const InstallerState& installer_state,
                                       bool* remove_setup,
                                       bool* remove_archive) {
   *remove_setup = true;
@@ -204,8 +200,7 @@ void CheckShouldRemoveSetupAndArchive(
     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(
+      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...
@@ -260,10 +255,6 @@ bool RemoveInstallerFiles(const base::FilePath& installer_directory,
   return success;
 }
 
-}  // namespace
-
-namespace installer {
-
 // Kills all Chrome processes, immediately.
 void CloseAllChromeProcesses() {
   base::CleanupProcesses(installer::kChromeExe, base::TimeDelta(),
@@ -395,62 +386,51 @@ DeleteResult DeleteEmptyDir(const base::FilePath& path) {
   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;
+      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);
-    break;
-  }
   return backup;
 }
 
-// Deletes all user data directories for a product.
-DeleteResult DeleteLocalState(
-    const std::vector<base::FilePath>& local_state_folders,
+// Deletes a given user data directory as well as the containing product
+// directories if they are empty (e.g., "Google\Chrome").
+DeleteResult DeleteUserDataDir(const base::FilePath& user_data_dir,
                                bool schedule_on_failure) {
-  if (local_state_folders.empty())
+  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)) {
+  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_local_state.value();
+               << user_data_dir.value();
     if (schedule_on_failure) {
-        ScheduleDirectoryForDeletion(user_local_state);
+      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());
@@ -522,27 +502,6 @@ bool MoveSetupOutOfInstallFolder(const InstallerState& installer_state,
   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();
@@ -758,6 +717,164 @@ void RemoveFiletypeRegistration(const InstallerState& installer_state,
   }
 }
 
+// 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,
@@ -929,141 +1046,6 @@ const wchar_t kChromeExtProgId[] = L"ChromiumExt";
   }
 }
 
-// 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,
@@ -1332,9 +1314,8 @@ InstallStatus UninstallProduct(const InstallationState& original_state,
   // 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());
@@ -1350,7 +1331,7 @@ InstallStatus UninstallProduct(const InstallationState& original_state,
   }
 
   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.";

chrome/installer/util/auto_launch_util.cc

@@ -53,10 +53,7 @@ base::string16 ProfileToKeyName(const base::string16& profile_directory) {
         BrowserDistribution::GetSpecificDistribution(
             BrowserDistribution::CHROME_BROWSER);
     installer::Product product(distribution);
-    std::vector<base::FilePath> data_dir_paths;
-    product.GetUserDataPaths(&data_dir_paths);
-    if (!data_dir_paths.empty())
-      path = data_dir_paths[0];
+    path = product.GetUserDataPath();
   }
   path = path.Append(profile_directory);
 

chrome/installer/util/helper.cc

@@ -7,8 +7,6 @@
 #include "base/files/file_path.h"
 #include "base/logging.h"
 #include "base/path_service.h"
-#include "base/win/windows_version.h"
-#include "chrome/common/chrome_constants.h"
 #include "chrome/installer/util/browser_distribution.h"
 #include "chrome/installer/util/install_util.h"
 #include "chrome/installer/util/installation_state.h"
@@ -43,27 +41,8 @@ base::FilePath GetChromeInstallPath(bool system_install,
   return GetChromeInstallBasePath(system_install, dist, kInstallBinaryDir);
 }
 
-// TODO(gab): Cleanup this method (kMetroChromeUserDataSubDir is deprecated).
-void GetChromeUserDataPaths(BrowserDistribution* dist,
-                            std::vector<base::FilePath>* paths) {
-  const bool has_metro_data =
-      base::win::GetVersion() >= base::win::VERSION_WIN8 &&
-      dist->GetDefaultBrowserControlPolicy() !=
-          BrowserDistribution::DEFAULT_BROWSER_UNSUPPORTED;
-
-  base::FilePath data_dir(GetChromeInstallBasePath(false, dist,
-                                                   kInstallUserDataDir));
-  if (data_dir.empty()) {
-    paths->clear();
-  } else {
-    paths->resize(has_metro_data ? 2 : 1);
-    (*paths)[0] = data_dir;
-    if (has_metro_data) {
-      (*paths)[1] = data_dir.DirName().Append(
-          chrome::kMetroChromeUserDataSubDir);
-    }
-  }
-  DCHECK(!paths->empty());
+base::FilePath GetChromeUserDataPath(BrowserDistribution* dist) {
+  return GetChromeInstallBasePath(false, dist, kInstallUserDataDir);
 }
 
 BrowserDistribution* GetBinariesDistribution(bool system_install) {

chrome/installer/util/helper.h

@@ -8,7 +8,6 @@
 #define CHROME_INSTALLER_UTIL_HELPER_H_
 
 #include <string>
-#include <vector>
 
 class BrowserDistribution;
 
@@ -25,16 +24,12 @@ namespace installer {
 //                 location (Document And Settings\<user>\Local Settings...)
 base::FilePath GetChromeInstallPath(bool system_install, BrowserDistribution* dist);
 
-// Returns the path(s) to the directory that holds the user data (primary and,
-// if applicable to |dist|, alternate).  This is always inside a user's local
-// application data folder (e.g., "AppData\Local or "Local Settings\Application
-// Data" in %USERPROFILE%). Note that these are the defaults and do not take
-// into account that they can be overriden with a command line parameter.
-// |paths| may be empty on return, but is guaranteed not to contain empty paths
-// otherwise. If more than one path is returned, they are guaranteed to be
-// siblings.
-void GetChromeUserDataPaths(BrowserDistribution* dist,
-                            std::vector<base::FilePath>* paths);
+// Returns the path to the directory that holds the user data.  This is always
+// inside a user's local application data folder (e.g., "AppData\Local" or
+// "Local Settings\Application Data" in %USERPROFILE%). Note that this is the
+// default user data directory and does not take into account that it can be
+// overriden with a command line parameter.
+base::FilePath GetChromeUserDataPath(BrowserDistribution* dist);
 
 // Returns the distribution corresponding to the current process's binaries.
 // In the case of a multi-install product, this will be the CHROME_BINARIES

chrome/installer/util/install_util.cc

@@ -414,12 +414,11 @@ bool InstallUtil::GetSentinelFilePath(const base::FilePath::CharType* file,
                                       BrowserDistribution* dist,
                                       base::FilePath* path) {
   // TODO(msw): Use PathService to obtain the correct DIR_USER_DATA.
-  std::vector<base::FilePath> user_data_dir_paths;
-  installer::GetChromeUserDataPaths(dist, &user_data_dir_paths);
+  base::FilePath user_data_dir(installer::GetChromeUserDataPath(dist));
 
-  if (user_data_dir_paths.empty())
+  if (user_data_dir.empty())
     return false;
-  *path = user_data_dir_paths[0].Append(file);
+  *path = user_data_dir.Append(file);
   return true;
 }
 

chrome/installer/util/product.cc

@@ -62,8 +62,8 @@ void Product::InitializeFromUninstallCommand(
   operations_->ReadOptions(uninstall_command, &options_);
 }
 
-void Product::GetUserDataPaths(std::vector<base::FilePath>* paths) const {
-  GetChromeUserDataPaths(distribution_, paths);
+base::FilePath Product::GetUserDataPath() const {
+  return GetChromeUserDataPath(distribution_);
 }
 
 bool Product::LaunchChrome(const base::FilePath& application_path) const {

chrome/installer/util/product.h

@@ -81,15 +81,12 @@ class Product {
       return options_.erase(option) != 0;
   }
 
-  // Returns the path(s) to the directory that holds the user data (primary
-  // and, if applicable to |dist|, alternate).  This is always inside a user's
-  // local application data folder (e.g., "AppData\Local or "Local
-  // Settings\Application Data" in %USERPROFILE%). Note that these are the
-  // defaults and do not take into account that they can be overriden with a
-  // command line parameter.  |paths| may be empty on return, but is guaranteed
-  // not to contain empty paths otherwise. If more than one path is returned,
-  // they are guaranteed to be siblings.
-  void GetUserDataPaths(std::vector<base::FilePath>* paths) const;
+  // Returns the path to the directory that holds the user data.  This is always
+  // inside a user's local application data folder (e.g., "AppData\Local" or
+  // "Local Settings\Application Data" in %USERPROFILE%). Note that this is the
+  // default user data directory and does not take into account that it can be
+  // overriden with a command line parameter.
+  base::FilePath GetUserDataPath() const;
 
   // Launches Chrome without waiting for it to exit.
   bool LaunchChrome(const base::FilePath& application_path) const;

chrome/installer/util/product_unittest.cc

@@ -7,7 +7,6 @@
 #include "base/logging.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/test/test_reg_util_win.h"
-#include "chrome/common/chrome_constants.h"
 #include "chrome/installer/util/chrome_frame_distribution.h"
 #include "chrome/installer/util/google_update_constants.h"
 #include "chrome/installer/util/installation_state.h"
@@ -71,19 +70,10 @@ TEST_F(ProductTest, MAYBE_ProductInstallBasic) {
   BrowserDistribution* distribution = product->distribution();
   EXPECT_EQ(BrowserDistribution::CHROME_BROWSER, distribution->GetType());
 
-  std::vector<base::FilePath> user_data_paths;
-  product->GetUserDataPaths(&user_data_paths);
-  EXPECT_GE(user_data_paths.size(), static_cast<size_t>(1));
-  const base::FilePath& user_data = user_data_paths[0];
-  EXPECT_FALSE(user_data_paths[0].empty());
+  base::FilePath user_data(product->GetUserDataPath());
+  EXPECT_FALSE(user_data.empty());
   EXPECT_NE(std::wstring::npos,
-            user_data_paths[0].value().find(installer::kInstallUserDataDir));
-  if (user_data_paths.size() > 1) {
-    EXPECT_FALSE(user_data_paths[1].empty());
-    EXPECT_NE(
-        std::wstring::npos,
-        user_data_paths[1].value().find(chrome::kMetroChromeUserDataSubDir));
-  }
+            user_data.value().find(installer::kInstallUserDataDir));
 
   base::FilePath program_files;
   PathService::Get(base::DIR_PROGRAM_FILES, &program_files);

chrome/installer/util/user_experiment.cc

@@ -427,21 +427,15 @@ void LaunchBrowserUserExperiment(const CommandLine& base_cmd_line,
     }
     // Check browser usage inactivity by the age of the last-write time of the
     // most recently-used chrome user data directory.
-    std::vector<base::FilePath> user_data_dirs;
     BrowserDistribution* dist = BrowserDistribution::GetSpecificDistribution(
         BrowserDistribution::CHROME_BROWSER);
-    GetChromeUserDataPaths(dist, &user_data_dirs);
-    int dir_age_hours = -1;
-    for (size_t i = 0; i < user_data_dirs.size(); ++i) {
-      int this_age = GetDirectoryWriteAgeInHours(
-          user_data_dirs[i].value().c_str());
-      if (this_age >= 0 && (dir_age_hours < 0 || this_age < dir_age_hours))
-        dir_age_hours = this_age;
-    }
+    base::FilePath user_data_dir(GetChromeUserDataPath(dist));
 
     const bool experiment_enabled = false;
     const int kThirtyDays = 30 * 24;
 
+    int dir_age_hours = GetDirectoryWriteAgeInHours(
+        user_data_dir.value().c_str());
     if (!experiment_enabled) {
       VLOG(1) << "Toast experiment is disabled.";
       return;