On uninstall ask whether to delete profile.

chrome/installer/setup/uninstall.cc

 // Copyright (c) 2006-2008 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 //
 // This file defines the methods useful for uninstalling Chrome.
 
 #include "chrome/installer/setup/uninstall.h"
 
 #include "base/file_util.h"
 #include "base/path_service.h"
@@ skipping 81 matching lines @@
   }
 }
 
 // Deletes all installed files of Chromium and Folders. Before deleting it
 // needs to move setup.exe in a temp folder because the current process
 // is using that file. It returns false when it can not get the path to
 // installation folder, in all other cases it returns true even in case
 // of error (only logs the error).
 bool DeleteFilesAndFolders(const std::wstring& exe_path, bool system_uninstall,
     const installer::Version& installed_version,
-    std::wstring* local_state_path) {
+    std::wstring* local_state_path, bool delete_profile) {
   std::wstring install_path(installer::GetChromeInstallPath(system_uninstall));
   if (install_path.empty()) {
     LOG(ERROR) << "Could not get installation destination path.";
     return false;  // Nothing else we can do for uninstall, so we return.
   } else {
     LOG(INFO) << "install destination path: " << install_path;
   }
 
   // Move setup.exe to the temp path.
   std::wstring setup_exe(installer::GetInstallerPathUnderChrome(
@@ skipping 16 matching lines @@
 
   LOG(INFO) << "Deleting install path " << install_path;
   if (!file_util::Delete(install_path, true)) {
     LOG(ERROR) << "Failed to delete folder (1st try): " << install_path;
     // Try closing any running chrome processes and deleting files once again.
     CloseAllChromeProcesses();
     if (!file_util::Delete(install_path, true))
       LOG(ERROR) << "Failed to delete folder (2nd try): " << install_path;
   }
 
+  if (delete_profile) {
+    LOG(INFO) << "Deleting user profile" << user_local_state.value();
+    if (!file_util::Delete(user_local_state, true))
+      LOG(ERROR) << "Failed to delete user profle dir: "
+                 << user_local_state.value();
+  }
+
   // Now check and delete if the parent directories are empty
   // For example Google\Chrome or Chromium
   std::wstring parent_dir = file_util::GetDirectoryFromPath(install_path);
   if (!parent_dir.empty() && file_util::IsDirectoryEmpty(parent_dir)) {
     if (!file_util::Delete(parent_dir, true))
       LOG(ERROR) << "Failed to delete folder: " << parent_dir;
     parent_dir = file_util::GetDirectoryFromPath(parent_dir);
     if (!parent_dir.empty() &&
         file_util::IsDirectoryEmpty(parent_dir)) {
       if (!file_util::Delete(parent_dir, true))
@@ skipping 46 matching lines @@
   //          give this method some brains and not kill chrome.exe launched
   //          by us, we will not uninstall if we get this return code).
   LOG(INFO) << "Launching Chrome to do uninstall tasks.";
   if (installer::LaunchChromeAndWaitForResult(system_uninstall,
                                               kCmdLineOptions,
                                               &exit_code)) {
     LOG(INFO) << "chrome.exe launched for uninstall confirmation returned: "
               << exit_code;
     if ((exit_code == ResultCodes::UNINSTALL_CHROME_ALIVE) ||
         (exit_code == ResultCodes::UNINSTALL_USER_CANCEL) ||
-        (exit_code == ResultCodes::HUNG))
+        (exit_code == ResultCodes::HUNG)) {
       return installer_util::UNINSTALL_CANCELLED;
+    } else if (exit_code == ResultCodes::UNINSTALL_DELETE_PROFILE) {
+      return installer_util::UNINSTALL_DELETE_PROFILE;
+    }
   } else {
     LOG(ERROR) << "Failed to launch chrome.exe for uninstall confirmation.";
   }
 
   return installer_util::UNINSTALL_CONFIRMED;
 }
 }  // namespace
 
 
 installer_util::InstallStatus installer_setup::UninstallChrome(
     const std::wstring& exe_path, bool system_uninstall,
     const installer::Version& installed_version,
     bool remove_all, bool force_uninstall) {
+  installer_util::InstallStatus status = installer_util::UNINSTALL_CONFIRMED;
   if (!force_uninstall) {
-    installer_util::InstallStatus status =
-        IsChromeActiveOrUserCancelled(system_uninstall);
-    if (status != installer_util::UNINSTALL_CONFIRMED)
+    status = IsChromeActiveOrUserCancelled(system_uninstall);
+    if (status != installer_util::UNINSTALL_CONFIRMED &&
+        status != installer_util::UNINSTALL_DELETE_PROFILE)
       return status;
   } else {
     // Since --force-uninstall command line option is used, we are going to
     // do silent uninstall. Try to close all running Chrome instances.
     CloseAllChromeProcesses();
   }
 
   // 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.
@@ skipping 84 matching lines @@
     scoped_ptr<WorkItemList> dll_list(WorkItem::CreateWorkItemList());
     if (InstallUtil::BuildDLLRegistrationList(dll_path, kDllsToRegister,
                                               kNumDllsToRegister, false,
                                               dll_list.get())) {
       dll_list->Do();
     }
   }
 
   // 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 = (status == installer_util::UNINSTALL_DELETE_PROFILE);
   std::wstring local_state_path;
+  installer_util::InstallStatus ret = installer_util::UNINSTALL_SUCCESSFUL;
   if (!DeleteFilesAndFolders(exe_path, system_uninstall, installed_version,
-                             &local_state_path))
-    return installer_util::UNINSTALL_FAILED;
+                             &local_state_path, delete_profile))
+    ret = installer_util::UNINSTALL_FAILED;
 
   if (!force_uninstall) {
     LOG(INFO) << "Uninstallation complete. Launching Uninstall survey.";
     dist->DoPostUninstallOperations(installed_version, local_state_path);
   }
 
   // Try and delete the preserved local state once the post-install
   // operations are complete.
   if (!local_state_path.empty())
     file_util::Delete(local_state_path, false);
 
-  return installer_util::UNINSTALL_SUCCESSFUL;
+  return ret;
 }