Add base:: to string16s in chrome/.

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 158 matching lines @@
 }
 
 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.
-  string16 reactivation_brand_wide;
+  base::string16 reactivation_brand_wide;
   if (GoogleUpdateSettings::GetReactivationBrand(&reactivation_brand_wide)) {
     std::string reactivation_brand(WideToASCII(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
@@ skipping 476 matching lines @@
 
   return should_delete;
 }
 
 // Removes XP-era filetype registration making Chrome the default browser.
 // MSDN (see http://msdn.microsoft.com/library/windows/desktop/cc144148.aspx)
 // tells us not to do this, but certain applications break following
 // uninstallation if we don't.
 void RemoveFiletypeRegistration(const InstallerState& installer_state,
                                 HKEY root,
-                                const string16& browser_entry_suffix) {
-  string16 classes_path(ShellUtil::kRegClasses);
+                                const base::string16& browser_entry_suffix) {
+  base::string16 classes_path(ShellUtil::kRegClasses);
   classes_path.push_back(base::FilePath::kSeparators[0]);
 
   BrowserDistribution* distribution = BrowserDistribution::GetDistribution();
-  const string16 prog_id(
+  const base::string16 prog_id(
       distribution->GetBrowserProgIdPrefix() + browser_entry_suffix);
 
   // Delete each filetype association if it references this Chrome.  Take care
   // not to delete the association if it references a system-level install of
   // Chrome (only a risk if the suffix is empty).  Don't delete the whole key
   // since other apps may have stored data there.
   std::vector<const wchar_t*> cleared_assocs;
   if (installer_state.system_install() ||
       !browser_entry_suffix.empty() ||
       !base::win::RegKey(HKEY_LOCAL_MACHINE, (classes_path + prog_id).c_str(),
                          KEY_QUERY_VALUE).Valid()) {
     InstallUtil::ValueEquals prog_id_pred(prog_id);
     for (const wchar_t* const* filetype =
          &ShellUtil::kPotentialFileAssociations[0]; *filetype != NULL;
          ++filetype) {
       if (InstallUtil::DeleteRegistryValueIf(
               root, (classes_path + *filetype).c_str(), NULL,
               prog_id_pred) == InstallUtil::DELETED) {
         cleared_assocs.push_back(*filetype);
       }
     }
   }
 
   // For all filetype associations in HKLM that have just been removed, attempt
   // to restore some reasonable value.  We have no definitive way of knowing
   // what handlers are the most appropriate, so we use a fixed mapping based on
   // the default values for a fresh install of Windows.
   if (root == HKEY_LOCAL_MACHINE) {
-    string16 assoc;
+    base::string16 assoc;
     base::win::RegKey key;
 
     for (size_t i = 0; i < cleared_assocs.size(); ++i) {
       const wchar_t* replacement_prog_id = NULL;
       assoc.assign(cleared_assocs[i]);
 
       // Inelegant, but simpler than a pure data-driven approach.
       if (assoc == L".htm" || assoc == L".html")
         replacement_prog_id = L"htmlfile";
       else if (assoc == L".xht" || assoc == L".xhtml")
@@ skipping 13 matching lines @@
         LOG(ERROR) << "Failed to restore system-level filetype association "
                    << assoc << " = " << replacement_prog_id;
       }
     }
   }
 }
 
 bool DeleteChromeRegistrationKeys(const InstallerState& installer_state,
                                   BrowserDistribution* dist,
                                   HKEY root,
-                                  const string16& browser_entry_suffix,
+                                  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;
   }
 
   base::FilePath chrome_exe(installer_state.target_path().Append(kChromeExe));
 
   // Delete Software\Classes\ChromeHTML.
-  const string16 prog_id(
+  const base::string16 prog_id(
       dist->GetBrowserProgIdPrefix() + browser_entry_suffix);
-  string16 reg_prog_id(ShellUtil::kRegClasses);
+  base::string16 reg_prog_id(ShellUtil::kRegClasses);
   reg_prog_id.push_back(base::FilePath::kSeparators[0]);
   reg_prog_id.append(prog_id);
   InstallUtil::DeleteRegistryKey(root, reg_prog_id);
 
   // Delete Software\Classes\Chrome.
-  string16 reg_app_id(ShellUtil::kRegClasses);
+  base::string16 reg_app_id(ShellUtil::kRegClasses);
   reg_app_id.push_back(base::FilePath::kSeparators[0]);
   // Append the requested suffix manually here (as ShellUtil::GetBrowserModelId
   // would otherwise try to figure out the currently installed suffix).
   reg_app_id.append(dist->GetBaseAppId() + browser_entry_suffix);
   InstallUtil::DeleteRegistryKey(root, reg_app_id);
 
   // Delete all Start Menu Internet registrations that refer to this Chrome.
   {
     using base::win::RegistryKeyIterator;
     InstallUtil::ProgramCompare open_command_pred(chrome_exe);
-    string16 client_name;
-    string16 client_key;
-    string16 open_key;
+    base::string16 client_name;
+    base::string16 client_key;
+    base::string16 open_key;
     for (RegistryKeyIterator iter(root, ShellUtil::kRegStartMenuInternet);
          iter.Valid(); ++iter) {
       client_name.assign(iter.Name());
       client_key.assign(ShellUtil::kRegStartMenuInternet)
           .append(1, L'\\')
           .append(client_name);
       open_key.assign(client_key).append(ShellUtil::kRegShellOpen);
       if (InstallUtil::DeleteRegistryKeyIf(root, client_key, open_key, NULL,
               open_command_pred) != InstallUtil::NOT_FOUND) {
         // Delete the default value of SOFTWARE\Clients\StartMenuInternet if it
         // references this Chrome (i.e., if it was made the default browser).
         InstallUtil::DeleteRegistryValueIf(
             root, ShellUtil::kRegStartMenuInternet, NULL,
             InstallUtil::ValueEquals(client_name));
         // Also delete the value for the default user if we're operating in
         // HKLM.
         if (root == HKEY_LOCAL_MACHINE) {
           InstallUtil::DeleteRegistryValueIf(
               HKEY_USERS,
-              string16(L".DEFAULT\\").append(
+              base::string16(L".DEFAULT\\").append(
                   ShellUtil::kRegStartMenuInternet).c_str(),
               NULL, InstallUtil::ValueEquals(client_name));
         }
       }
     }
   }
 
   // Delete Software\RegisteredApplications\Chromium
   InstallUtil::DeleteRegistryValue(
       root, ShellUtil::kRegRegisteredApplications,
       dist->GetBaseAppName() + browser_entry_suffix);
 
   // Delete the App Paths and Applications keys that let Explorer find Chrome:
   // http://msdn.microsoft.com/en-us/library/windows/desktop/ee872121
-  string16 app_key(ShellUtil::kRegClasses);
+  base::string16 app_key(ShellUtil::kRegClasses);
   app_key.push_back(base::FilePath::kSeparators[0]);
   app_key.append(L"Applications");
   app_key.push_back(base::FilePath::kSeparators[0]);
   app_key.append(installer::kChromeExe);
   InstallUtil::DeleteRegistryKey(root, app_key);
 
-  string16 app_path_key(ShellUtil::kAppPathsRegistryKey);
+  base::string16 app_path_key(ShellUtil::kAppPathsRegistryKey);
   app_path_key.push_back(base::FilePath::kSeparators[0]);
   app_path_key.append(installer::kChromeExe);
   InstallUtil::DeleteRegistryKey(root, app_path_key);
 
   // Cleanup OpenWithList and OpenWithProgids:
   // http://msdn.microsoft.com/en-us/library/bb166549
-  string16 file_assoc_key;
-  string16 open_with_list_key;
-  string16 open_with_progids_key;
+  base::string16 file_assoc_key;
+  base::string16 open_with_list_key;
+  base::string16 open_with_progids_key;
   for (int i = 0; ShellUtil::kPotentialFileAssociations[i] != NULL; ++i) {
     file_assoc_key.assign(ShellUtil::kRegClasses);
     file_assoc_key.push_back(base::FilePath::kSeparators[0]);
     file_assoc_key.append(ShellUtil::kPotentialFileAssociations[i]);
     file_assoc_key.push_back(base::FilePath::kSeparators[0]);
 
     open_with_list_key.assign(file_assoc_key);
     open_with_list_key.append(L"OpenWithList");
     open_with_list_key.push_back(base::FilePath::kSeparators[0]);
     open_with_list_key.append(installer::kChromeExe);
     InstallUtil::DeleteRegistryKey(root, open_with_list_key);
 
     open_with_progids_key.assign(file_assoc_key);
     open_with_progids_key.append(ShellUtil::kRegOpenWithProgids);
     InstallUtil::DeleteRegistryValue(root, open_with_progids_key, prog_id);
   }
 
   // Cleanup in case Chrome had been made the default browser.
 
   // Delete the default value of SOFTWARE\Clients\StartMenuInternet if it
   // references this Chrome.  Do this explicitly here for the case where HKCU is
   // being processed; the iteration above will have no hits since registration
   // lives in HKLM.
   InstallUtil::DeleteRegistryValueIf(
       root, ShellUtil::kRegStartMenuInternet, NULL,
       InstallUtil::ValueEquals(dist->GetBaseAppName() + browser_entry_suffix));
 
   // Delete each protocol association if it references this Chrome.
   InstallUtil::ProgramCompare open_command_pred(chrome_exe);
-  string16 parent_key(ShellUtil::kRegClasses);
+  base::string16 parent_key(ShellUtil::kRegClasses);
   parent_key.push_back(base::FilePath::kSeparators[0]);
-  const string16::size_type base_length = parent_key.size();
-  string16 child_key;
+  const base::string16::size_type base_length = parent_key.size();
+  base::string16 child_key;
   for (const wchar_t* const* proto =
            &ShellUtil::kPotentialProtocolAssociations[0];
        *proto != NULL;
        ++proto) {
     parent_key.resize(base_length);
     parent_key.append(*proto);
     child_key.assign(parent_key).append(ShellUtil::kRegShellOpen);
     InstallUtil::DeleteRegistryKeyIf(root, parent_key, child_key, NULL,
                                      open_command_pred);
   }
 
   RemoveFiletypeRegistration(installer_state, root, browser_entry_suffix);
 
   *exit_code = installer::UNINSTALL_SUCCESSFUL;
   return true;
 }
 
 void RemoveChromeLegacyRegistryKeys(BrowserDistribution* dist,
-                                    const string16& chrome_exe) {
+                                    const base::string16& chrome_exe) {
   // We used to register Chrome to handle crx files, but this turned out
   // to be not worth the hassle. Remove these old registry entries if
   // they exist. See: http://codereview.chromium.org/210007
 
 #if defined(GOOGLE_CHROME_BUILD)
 const wchar_t kChromeExtProgId[] = L"ChromeExt";
 #else
 const wchar_t kChromeExtProgId[] = L"ChromiumExt";
 #endif
 
   HKEY roots[] = { HKEY_LOCAL_MACHINE, HKEY_CURRENT_USER };
   for (size_t i = 0; i < arraysize(roots); ++i) {
-    string16 suffix;
+    base::string16 suffix;
     if (roots[i] == HKEY_LOCAL_MACHINE)
       suffix = ShellUtil::GetCurrentInstallationSuffix(dist, chrome_exe);
 
     // Delete Software\Classes\ChromeExt,
-    string16 ext_prog_id(ShellUtil::kRegClasses);
+    base::string16 ext_prog_id(ShellUtil::kRegClasses);
     ext_prog_id.push_back(base::FilePath::kSeparators[0]);
     ext_prog_id.append(kChromeExtProgId);
     ext_prog_id.append(suffix);
     InstallUtil::DeleteRegistryKey(roots[i], ext_prog_id);
 
     // Delete Software\Classes\.crx,
-    string16 ext_association(ShellUtil::kRegClasses);
+    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.
@@ skipping 16 matching lines @@
   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 string16 active_setup_path(
+  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.
-  string16 alternate_active_setup_path(active_setup_path);
+  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;
 
-      string16 reg_profile_info_path(kProfileList);
+      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);
 
-      string16 profile_path;
+      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,
@@ skipping 32 matching lines @@
 
 InstallStatus UninstallProduct(const InstallationState& original_state,
                                const InstallerState& installer_state,
                                const base::FilePath& setup_path,
                                const Product& product,
                                bool remove_all,
                                bool force_uninstall,
                                const CommandLine& cmd_line) {
   InstallStatus status = installer::UNINSTALL_CONFIRMED;
   BrowserDistribution* browser_dist = product.distribution();
-  const string16 chrome_exe(
+  const base::string16 chrome_exe(
       installer_state.target_path().Append(installer::kChromeExe).value());
 
   bool is_chrome = product.is_chrome();
 
   VLOG(1) << "UninstallProduct: " << browser_dist->GetDisplayName();
 
   if (force_uninstall) {
     // Since --force-uninstall command line option is used, we are going to
     // do silent uninstall. Try to close all running Chrome instances.
     // NOTE: We don't do this for Chrome Frame.
     if (is_chrome)
       CloseAllChromeProcesses();
   } else if (is_chrome) {
     // no --force-uninstall so lets show some UI dialog boxes.
     status = IsChromeActiveOrUserCancelled(installer_state, product);
     if (status != installer::UNINSTALL_CONFIRMED &&
         status != installer::UNINSTALL_DELETE_PROFILE)
       return status;
 
-    const string16 suffix(ShellUtil::GetCurrentInstallationSuffix(browser_dist,
-                                                                  chrome_exe));
+    const base::string16 suffix(
+        ShellUtil::GetCurrentInstallationSuffix(browser_dist, chrome_exe));
 
     // Check if we need admin rights to cleanup HKLM (the conditions for
     // requiring a cleanup are the same as the conditions to do the actual
     // cleanup where DeleteChromeRegistrationKeys() is invoked for
     // HKEY_LOCAL_MACHINE below). If we do, try to launch another uninstaller
     // (silent) in elevated mode to do HKLM cleanup.
     // And continue uninstalling in the current process also to do HKCU cleanup.
     if (remove_all &&
         ShellUtil::QuickIsChromeRegisteredInHKLM(
             browser_dist, chrome_exe, suffix) &&
@@ skipping 49 matching lines @@
     }
 
     DeleteShortcuts(installer_state, product, base::FilePath(chrome_exe));
   }
 
   // Delete the registry keys (Uninstall key and Version key).
   HKEY reg_root = installer_state.root_key();
 
   // Note that we must retrieve the distribution-specific data before deleting
   // product.GetVersionKey().
-  string16 distribution_data(browser_dist->GetDistributionData(reg_root));
+  base::string16 distribution_data(browser_dist->GetDistributionData(reg_root));
 
   // 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);
 
   InstallStatus ret = installer::UNKNOWN_STATUS;
 
   if (is_chrome) {
-    const string16 suffix(ShellUtil::GetCurrentInstallationSuffix(browser_dist,
-                                                                  chrome_exe));
+    const base::string16 suffix(
+        ShellUtil::GetCurrentInstallationSuffix(browser_dist, chrome_exe));
 
     // Remove all Chrome registration keys.
     // Registration data is put in HKCU for both system level and user level
     // installs.
     DeleteChromeRegistrationKeys(installer_state, browser_dist,
                                  HKEY_CURRENT_USER, suffix, &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(installer_state, browser_dist,
-                                   HKEY_CURRENT_USER, string16(), &ret);
+                                   HKEY_CURRENT_USER, base::string16(), &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;
+      base::string16 old_style_suffix;
       if (ShellUtil::GetOldUserSpecificRegistrySuffix(&old_style_suffix) &&
           suffix != old_style_suffix) {
         DeleteChromeRegistrationKeys(installer_state, browser_dist,
                                      HKEY_CURRENT_USER, old_style_suffix, &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
@@ skipping 56 matching lines @@
       original_state.GetProductState(installer_state.system_install(),
                                      browser_dist->GetType());
 
   // Delete shared registry keys as well (these require admin rights) if
   // remove_all option is specified.
   if (remove_all) {
     if (!InstallUtil::IsChromeSxSProcess() && is_chrome) {
       // Delete media player registry key that exists only in HKLM.
       // We don't delete this key in SxS uninstall or Chrome Frame uninstall
       // as we never set the key for those products.
-      string16 reg_path(installer::kMediaPlayerRegPath);
+      base::string16 reg_path(installer::kMediaPlayerRegPath);
       reg_path.push_back(base::FilePath::kSeparators[0]);
       reg_path.append(installer::kChromeExe);
       InstallUtil::DeleteRegistryKey(HKEY_LOCAL_MACHINE, reg_path);
     }
 
     // Unregister any dll servers that we may have registered for this
     // product.
     if (product_state != NULL) {
       std::vector<base::FilePath> com_dll_list;
       product.AddComDllList(&com_dll_list);
@@ skipping 138 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