Add base:: to string16s in chrome/.

chrome/installer/setup/install_worker.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 contains the definitions of the installer functions that build
 // the WorkItemList used to install the application.
 
 #include "chrome/installer/setup/install_worker.h"
 
 #include <oaidl.h>
@@ skipping 71 matching lines @@
 // built.
 // TODO(robertshield): Remove this when Chrome Frame works with Aura.
 const wchar_t kIELowRightsPolicyCurrentGuid[] =
     L"{E0A900DF-9611-4446-86BD-4B1D47E7DB2A}";
 #endif
 
 const wchar_t kElevationPolicyKeyPath[] =
     L"SOFTWARE\\Microsoft\\Internet Explorer\\Low Rights\\ElevationPolicy\\";
 
 void GetIELowRightsElevationPolicyKeyPath(ElevationPolicyId policy,
-                                          string16* key_path) {
+                                          base::string16* key_path) {
   DCHECK(policy == CURRENT_ELEVATION_POLICY || policy == OLD_ELEVATION_POLICY);
   key_path->assign(kElevationPolicyKeyPath,
                    arraysize(kElevationPolicyKeyPath) - 1);
   if (policy == CURRENT_ELEVATION_POLICY) {
 #if defined(OMIT_CHROME_FRAME)
     key_path->append(kIELowRightsPolicyCurrentGuid,
                      arraysize(kIELowRightsPolicyCurrentGuid) - 1);
 #else
     wchar_t cf_clsid[64];
     int len = StringFromGUID2(__uuidof(ChromeFrame), &cf_clsid[0],
@@ skipping 101 matching lines @@
         // system-level archive.
         install_list->AddCopyTreeWorkItem(archive_path.value(),
                                           archive_dst.value(),
                                           temp_path.value(),
                                           WorkItem::ALWAYS);
       }
     }
   }
 }
 
-string16 GetRegCommandKey(BrowserDistribution* dist,
-                          const wchar_t* name) {
-  string16 cmd_key(dist->GetVersionKey());
+base::string16 GetRegCommandKey(BrowserDistribution* dist,
+                                const wchar_t* name) {
+  base::string16 cmd_key(dist->GetVersionKey());
   cmd_key.append(1, base::FilePath::kSeparators[0])
       .append(google_update::kRegCommandsKey)
       .append(1, base::FilePath::kSeparators[0])
       .append(name);
   return cmd_key;
 }
 
 // Adds work items to create (or delete if uninstalling) app commands to launch
 // the app with a switch. The following criteria should be true:
 //  1. The switch takes one parameter.
 //  2. The command send pings.
 //  3. The command is web accessible.
 //  4. The command is run as the user.
 void AddCommandWithParameterWorkItems(const InstallerState& installer_state,
                                       const InstallationState& machine_state,
                                       const Version& new_version,
                                       const Product& product,
                                       const wchar_t* command_key,
                                       const wchar_t* app,
                                       const char* command_with_parameter,
                                       WorkItemList* work_item_list) {
   DCHECK(command_key);
   DCHECK(app);
   DCHECK(command_with_parameter);
   DCHECK(work_item_list);
 
-  string16 full_cmd_key(GetRegCommandKey(product.distribution(), command_key));
+  base::string16 full_cmd_key(
+      GetRegCommandKey(product.distribution(), command_key));
 
   if (installer_state.operation() == InstallerState::UNINSTALL) {
     work_item_list->AddDeleteRegKeyWorkItem(
         installer_state.root_key(), full_cmd_key)->set_log_message(
             "removing " + WideToASCII(command_key) + " command");
   } else {
     CommandLine cmd_line(installer_state.target_path().Append(app));
     cmd_line.AppendSwitchASCII(command_with_parameter, "%1");
 
     AppCommand cmd(cmd_line.GetCommandLineString());
@@ skipping 91 matching lines @@
 
   bool will_have_chrome_binaries =
       WillProductBePresentAfterSetup(installer_state, machine_state,
                                      BrowserDistribution::CHROME_BINARIES);
 
   // For system-level binaries there is no way to keep the command state in sync
   // with the installation/uninstallation of the Application Launcher (which is
   // always at user-level).  So we do not try to remove the command, i.e., it
   // will always be installed if the Chrome Binaries are installed.
   if (will_have_chrome_binaries) {
-    string16 cmd_key(GetRegCommandKey(
-                         BrowserDistribution::GetSpecificDistribution(
+    base::string16 cmd_key(
+        GetRegCommandKey(BrowserDistribution::GetSpecificDistribution(
                              BrowserDistribution::CHROME_BINARIES),
                          kCmdQuickEnableApplicationHost));
     CommandLine cmd_line(GetGenericQuickEnableCommand(installer_state,
                                                       machine_state,
                                                       setup_path,
                                                       new_version));
     // kMultiInstall and kVerboseLogging were processed above.
     cmd_line.AppendSwitch(switches::kChromeAppLauncher);
     cmd_line.AppendSwitch(switches::kEnsureGoogleUpdatePresent);
     AppCommand cmd(cmd_line.GetCommandLineString());
@@ skipping 41 matching lines @@
 void AddDeleteUninstallShortcutsForMSIWorkItems(
     const InstallerState& installer_state,
     const Product& product,
     const base::FilePath& temp_path,
     WorkItemList* work_item_list) {
   DCHECK(installer_state.is_msi())
       << "This must only be called for MSI installations!";
 
   // First attempt to delete the old installation's ARP dialog entry.
   HKEY reg_root = installer_state.root_key();
-  string16 uninstall_reg(product.distribution()->GetUninstallRegPath());
+  base::string16 uninstall_reg(product.distribution()->GetUninstallRegPath());
 
   WorkItem* delete_reg_key = work_item_list->AddDeleteRegKeyWorkItem(
       reg_root, uninstall_reg);
   delete_reg_key->set_ignore_failure(true);
 
   // Then attempt to delete the old installation's start menu shortcut.
   base::FilePath uninstall_link;
   if (installer_state.system_install()) {
     PathService::Get(base::DIR_COMMON_START_MENU, &uninstall_link);
   } else {
@@ skipping 132 matching lines @@
   install_list->AddDeleteTreeWorkItem(
       target_path.Append(installer::kChromeOldExe), temp_path)->
           set_ignore_failure(true);
 }
 
 // Probes COM machinery to get an instance of delegate_execute.exe's
 // CommandExecuteImpl class.  This is required so that COM purges its cache of
 // the path to the binary, which changes on updates.  This callback
 // unconditionally returns true since an install should not be aborted if the
 // probe fails.
-bool ProbeCommandExecuteCallback(const string16& command_execute_id,
+bool ProbeCommandExecuteCallback(const base::string16& command_execute_id,
                                  const CallbackWorkItem& work_item) {
   // Noop on rollback.
   if (work_item.IsRollback())
     return true;
 
   CLSID class_id = {};
 
   HRESULT hr = CLSIDFromString(command_execute_id.c_str(), &class_id);
   if (FAILED(hr)) {
     LOG(DFATAL) << "Failed converting \"" << command_execute_id << "\" to "
                    "CLSID; hr=0x" << std::hex << hr;
   } else {
     base::win::ScopedComPtr<IUnknown> command_execute_impl;
     hr = command_execute_impl.CreateInstance(class_id, NULL,
                                              CLSCTX_LOCAL_SERVER);
     if (hr != REGDB_E_CLASSNOTREG) {
       LOG(ERROR) << "Unexpected result creating CommandExecuteImpl; hr=0x"
                  << std::hex << hr;
     }
   }
 
   return true;
 }
 
-void AddUninstallDelegateExecuteWorkItems(HKEY root,
-                                          const string16& delegate_execute_path,
-                                          WorkItemList* list) {
+void AddUninstallDelegateExecuteWorkItems(
+    HKEY root,
+    const base::string16& delegate_execute_path,
+    WorkItemList* list) {
   VLOG(1) << "Adding unregistration items for DelegateExecute verb handler in "
           << root;
   list->AddDeleteRegKeyWorkItem(root, delegate_execute_path);
 
   // In the past, the ICommandExecuteImpl interface and a TypeLib were both
   // registered.  Remove these since this operation may be updating a machine
   // that had the old registrations.
   list->AddDeleteRegKeyWorkItem(root,
                                 L"Software\\Classes\\Interface\\"
                                 L"{0BA0D4E9-2259-4963-B9AE-A839F7CB7544}");
@@ skipping 11 matching lines @@
 // (exclusively -- crrev.com/132596), registered a DelegateExecute class by
 // mistake (with the same GUID as Chrome). The fix stopped registering the bad
 // value, but didn't delete it. This is a problem for users who had installed
 // Canary before 20.0.1106.0 and now have a system-level Chrome, as the
 // left-behind Canary registrations in HKCU mask the HKLM registrations for the
 // same GUID. Cleanup those registrations if they still exist and belong to this
 // Canary (i.e., the registered delegate_execute's path is under |target_path|).
 void CleanupBadCanaryDelegateExecuteRegistration(
     const base::FilePath& target_path,
     WorkItemList* list) {
-  string16 google_chrome_delegate_execute_path(
+  base::string16 google_chrome_delegate_execute_path(
       L"Software\\Classes\\CLSID\\{5C65F4B0-3651-4514-B207-D10CB699B14B}");
-  string16 google_chrome_local_server_32(
+  base::string16 google_chrome_local_server_32(
       google_chrome_delegate_execute_path + L"\\LocalServer32");
 
   RegKey local_server_32_key;
-  string16 registered_server;
+  base::string16 registered_server;
   if (local_server_32_key.Open(HKEY_CURRENT_USER,
                                google_chrome_local_server_32.c_str(),
                                KEY_QUERY_VALUE) == ERROR_SUCCESS &&
       local_server_32_key.ReadValue(L"ServerExecutable",
                                     &registered_server) == ERROR_SUCCESS &&
       target_path.IsParent(base::FilePath(registered_server))) {
     scoped_ptr<WorkItemList> no_rollback_list(
         WorkItem::CreateNoRollbackWorkItemList());
     AddUninstallDelegateExecuteWorkItems(
         HKEY_CURRENT_USER, google_chrome_delegate_execute_path,
@@ skipping 27 matching lines @@
   // Do not quote the command line for the MSI invocation.
   base::FilePath install_path(installer_state.target_path());
   base::FilePath installer_path(
       installer_state.GetInstallerDirectory(new_version));
   installer_path = installer_path.Append(setup_path.BaseName());
 
   CommandLine uninstall_arguments(CommandLine::NO_PROGRAM);
   AppendUninstallCommandLineFlags(installer_state, product,
                                   &uninstall_arguments);
 
-  string16 update_state_key(browser_dist->GetStateKey());
+  base::string16 update_state_key(browser_dist->GetStateKey());
   install_list->AddCreateRegKeyWorkItem(reg_root, update_state_key);
   install_list->AddSetRegValueWorkItem(reg_root, update_state_key,
       installer::kUninstallStringField, installer_path.value(), true);
   install_list->AddSetRegValueWorkItem(reg_root, update_state_key,
       installer::kUninstallArgumentsField,
       uninstall_arguments.GetCommandLineString(), true);
 
   // MSI installations will manage their own uninstall shortcuts.
   if (!installer_state.is_msi() && product.ShouldCreateUninstallEntry()) {
     // We need to quote the command line for the Add/Remove Programs dialog.
     CommandLine quoted_uninstall_cmd(installer_path);
     DCHECK_EQ(quoted_uninstall_cmd.GetCommandLineString()[0], '"');
     quoted_uninstall_cmd.AppendArguments(uninstall_arguments, false);
 
-    string16 uninstall_reg = browser_dist->GetUninstallRegPath();
+    base::string16 uninstall_reg = browser_dist->GetUninstallRegPath();
     install_list->AddCreateRegKeyWorkItem(reg_root, uninstall_reg);
     install_list->AddSetRegValueWorkItem(reg_root, uninstall_reg,
         installer::kUninstallDisplayNameField, browser_dist->GetDisplayName(),
         true);
     install_list->AddSetRegValueWorkItem(reg_root,
         uninstall_reg, installer::kUninstallStringField,
         quoted_uninstall_cmd.GetCommandLineString(), true);
     install_list->AddSetRegValueWorkItem(reg_root,
                                          uninstall_reg,
                                          L"InstallLocation",
                                          install_path.value(),
                                          true);
 
     BrowserDistribution* dist = product.distribution();
-    string16 chrome_icon = ShellUtil::FormatIconLocation(
+    base::string16 chrome_icon = ShellUtil::FormatIconLocation(
         install_path.Append(dist->GetIconFilename()).value(),
         dist->GetIconIndex(BrowserDistribution::SHORTCUT_CHROME));
     install_list->AddSetRegValueWorkItem(reg_root, uninstall_reg,
                                          L"DisplayIcon", chrome_icon, true);
     install_list->AddSetRegValueWorkItem(reg_root, uninstall_reg,
                                          L"NoModify", static_cast<DWORD>(1),
                                          true);
     install_list->AddSetRegValueWorkItem(reg_root, uninstall_reg,
                                          L"NoRepair", static_cast<DWORD>(1),
                                          true);
@@ skipping 28 matching lines @@
 
 // Create Version key for a product (if not already present) and sets the new
 // product version as the last step.
 void AddVersionKeyWorkItems(HKEY root,
                             BrowserDistribution* dist,
                             const Version& new_version,
                             bool add_language_identifier,
                             WorkItemList* list) {
   // Create Version key for each distribution (if not already present) and set
   // the new product version as the last step.
-  string16 version_key(dist->GetVersionKey());
+  base::string16 version_key(dist->GetVersionKey());
   list->AddCreateRegKeyWorkItem(root, version_key);
 
-  string16 product_name(dist->GetDisplayName());
+  base::string16 product_name(dist->GetDisplayName());
   list->AddSetRegValueWorkItem(root, version_key, google_update::kRegNameField,
                                product_name, true);  // overwrite name also
   list->AddSetRegValueWorkItem(root, version_key,
                                google_update::kRegOopcrashesField,
                                static_cast<DWORD>(1),
                                false);  // set during first install
   if (add_language_identifier) {
     // Write the language identifier of the current translation.  Omaha's set of
     // languages is a superset of Chrome's set of translations with this one
     // exception: what Chrome calls "en-us", Omaha calls "en".  sigh.
-    string16 language(GetCurrentTranslation());
+    base::string16 language(GetCurrentTranslation());
     if (LowerCaseEqualsASCII(language, "en-us"))
       language.resize(2);
     list->AddSetRegValueWorkItem(root, version_key,
                                  google_update::kRegLangField, language,
                                  false);  // do not overwrite language
   }
   list->AddSetRegValueWorkItem(root, version_key,
                                google_update::kRegVersionField,
                                ASCIIToWide(new_version.GetString()),
                                true);  // overwrite version
 }
 
 // Mirror oeminstall the first time anything is installed multi.  There is no
 // need to update the value on future install/update runs since this value never
 // changes.  Note that the value is removed by Google Update after EULA
 // acceptance is processed.
 void AddOemInstallWorkItems(const InstallationState& original_state,
                             const InstallerState& installer_state,
                             WorkItemList* install_list) {
   DCHECK(installer_state.is_multi_install());
   const bool system_install = installer_state.system_install();
   if (!original_state.GetProductState(system_install,
                                       BrowserDistribution::CHROME_BINARIES)) {
     const HKEY root_key = installer_state.root_key();
-    string16 multi_key(
+    base::string16 multi_key(
         installer_state.multi_package_binaries_distribution()->GetStateKey());
 
     // Copy the value from Chrome unless Chrome isn't installed or being
     // installed.
     BrowserDistribution::Type source_type;
     if (installer_state.FindProduct(BrowserDistribution::CHROME_BROWSER)) {
       source_type = BrowserDistribution::CHROME_BROWSER;
     } else if (!installer_state.products().empty()) {
       // Pick a product, any product.
       source_type = installer_state.products()[0]->distribution()->GetType();
     } else {
       // Nothing is being installed?  Entirely unexpected, so do no harm.
       LOG(ERROR) << "No products found in AddOemInstallWorkItems";
       return;
     }
     const ProductState* source_product =
         original_state.GetNonVersionedProductState(system_install, source_type);
 
-    string16 oem_install;
+    base::string16 oem_install;
     if (source_product->GetOemInstall(&oem_install)) {
       VLOG(1) << "Mirroring oeminstall=\"" << oem_install << "\" from "
               << BrowserDistribution::GetSpecificDistribution(source_type)->
                      GetDisplayName();
       install_list->AddCreateRegKeyWorkItem(root_key, multi_key);
       // Always overwrite an old value.
       install_list->AddSetRegValueWorkItem(root_key, multi_key,
                                            google_update::kRegOemInstallField,
                                            oem_install, true);
     } else {
       // Clear any old value.
       install_list->AddDeleteRegValueWorkItem(
           root_key, multi_key, google_update::kRegOemInstallField);
     }
   }
 }
 
 // Mirror eulaaccepted the first time anything is installed multi.  There is no
 // need to update the value on future install/update runs since
 // GoogleUpdateSettings::SetEULAConsent will modify the value for both the
 // relevant product and for the binaries.
 void AddEulaAcceptedWorkItems(const InstallationState& original_state,
                               const InstallerState& installer_state,
                               WorkItemList* install_list) {
   DCHECK(installer_state.is_multi_install());
   const bool system_install = installer_state.system_install();
   if (!original_state.GetProductState(system_install,
                                       BrowserDistribution::CHROME_BINARIES)) {
     const HKEY root_key = installer_state.root_key();
-    string16 multi_key(
+    base::string16 multi_key(
         installer_state.multi_package_binaries_distribution()->GetStateKey());
 
     // Copy the value from the product with the greatest value.
     bool have_eula_accepted = false;
     BrowserDistribution::Type product_type;
     DWORD eula_accepted;
     const Products& products = installer_state.products();
     for (Products::const_iterator it = products.begin(); it < products.end();
          ++it) {
       const Product& product = **it;
@@ skipping 34 matching lines @@
                               WorkItemList* install_list) {
   // Is a multi-install product being installed or over-installed?
   if (installer_state.operation() != InstallerState::MULTI_INSTALL &&
       installer_state.operation() != InstallerState::MULTI_UPDATE) {
     VLOG(1) << "AddGoogleUpdateWorkItems noop: " << installer_state.operation();
     return;
   }
 
   const bool system_install = installer_state.system_install();
   const HKEY root_key = installer_state.root_key();
-  string16 multi_key(
+  base::string16 multi_key(
       installer_state.multi_package_binaries_distribution()->GetStateKey());
 
   // For system-level installs, make sure the ClientStateMedium key for the
   // binaries exists.
   if (system_install) {
     install_list->AddCreateRegKeyWorkItem(
         root_key,
         installer_state.multi_package_binaries_distribution()->
             GetStateMediumKey().c_str());
   }
 
   // Creating the ClientState key for binaries, if we're migrating to multi then
   // copy over Chrome's brand code if it has one. Chrome Frame currently never
   // has a brand code.
   if (installer_state.state_type() != BrowserDistribution::CHROME_BINARIES) {
     const ProductState* chrome_product_state =
         original_state.GetNonVersionedProductState(
             system_install, BrowserDistribution::CHROME_BROWSER);
 
-    const string16& brand(chrome_product_state->brand());
+    const base::string16& brand(chrome_product_state->brand());
     if (!brand.empty()) {
       install_list->AddCreateRegKeyWorkItem(root_key, multi_key);
       // Write Chrome's brand code to the multi key. Never overwrite the value
       // if one is already present (although this shouldn't happen).
       install_list->AddSetRegValueWorkItem(root_key,
                                            multi_key,
                                            google_update::kRegBrandField,
                                            brand,
                                            false);
     }
@@ skipping 26 matching lines @@
     BrowserDistribution* dist = (*scan)->distribution();
     const ProductState* product_state =
         original_state.GetNonVersionedProductState(
             installer_state.system_install(), dist->GetType());
     value_found = product_state->GetUsageStats(&usagestats);
   }
 
   // If a value was found, write it in the appropriate location for the
   // binaries and remove all values from the products.
   if (value_found) {
-    string16 state_key(
+    base::string16 state_key(
         installer_state.multi_package_binaries_distribution()->GetStateKey());
     install_list->AddCreateRegKeyWorkItem(root_key, state_key);
     // Overwrite any existing value so that overinstalls (where Omaha writes a
     // new value into a product's state key) pick up the correct value.
     install_list->AddSetRegValueWorkItem(root_key, state_key,
                                          google_update::kRegUsageStatsField,
                                          usagestats, true);
 
     for (Products::const_iterator scan = products.begin(), end = products.end();
          scan != end; ++scan) {
@@ skipping 48 matching lines @@
             setup_path.BaseName()));
 
     CommandLine rename(installer_path);
     rename.AppendSwitch(switches::kRenameChromeExe);
     if (installer_state.system_install())
       rename.AppendSwitch(switches::kSystemLevel);
 
     if (installer_state.verbose_logging())
       rename.AppendSwitch(switches::kVerboseLogging);
 
-    string16 version_key;
+    base::string16 version_key;
     for (size_t i = 0; i < products.size(); ++i) {
       BrowserDistribution* dist = products[i]->distribution();
       version_key = dist->GetVersionKey();
 
       if (current_version) {
         in_use_update_work_items->AddSetRegValueWorkItem(root, version_key,
             google_update::kRegOldVersionField,
             ASCIIToWide(current_version->GetString()), true);
       }
       if (critical_version.IsValid()) {
@@ skipping 30 matching lines @@
   // Append work items that will be executed if this was NOT an in-use update.
   {
     scoped_ptr<WorkItemList> regular_update_work_items(
         WorkItem::CreateConditionalWorkItemList(
             new Not(new ConditionRunIfFileExists(new_chrome_exe))));
     regular_update_work_items->set_log_message("RegularUpdateWorkItemList");
 
     // Since this was not an in-use-update, delete 'opv', 'cpv', and 'cmd' keys.
     for (size_t i = 0; i < products.size(); ++i) {
       BrowserDistribution* dist = products[i]->distribution();
-      string16 version_key(dist->GetVersionKey());
+      base::string16 version_key(dist->GetVersionKey());
       regular_update_work_items->AddDeleteRegValueWorkItem(root, version_key,
           google_update::kRegOldVersionField);
       regular_update_work_items->AddDeleteRegValueWorkItem(root, version_key,
           google_update::kRegCriticalVersionField);
       regular_update_work_items->AddDeleteRegValueWorkItem(root, version_key,
           google_update::kRegRenameCmdField);
     }
 
     if (installer_state.FindProduct(BrowserDistribution::CHROME_FRAME)) {
       AddDeleteOldIELowRightsPolicyWorkItems(installer_state,
@@ skipping 161 matching lines @@
   DCHECK(set_msi_work_item);
   set_msi_work_item->set_ignore_failure(true);
   set_msi_work_item->set_log_message("Could not write MSI marker!");
 }
 
 void AddDelegateExecuteWorkItems(const InstallerState& installer_state,
                                  const base::FilePath& target_path,
                                  const Version& new_version,
                                  const Product& product,
                                  WorkItemList* list) {
-  string16 handler_class_uuid;
+  base::string16 handler_class_uuid;
   BrowserDistribution* dist = product.distribution();
   if (!dist->GetCommandExecuteImplClsid(&handler_class_uuid)) {
     if (InstallUtil::IsChromeSxSProcess()) {
       CleanupBadCanaryDelegateExecuteRegistration(target_path, list);
     } else {
       VLOG(1) << "No DelegateExecute verb handler processing to do for "
               << dist->GetDisplayName();
     }
     return;
   }
 
   HKEY root = installer_state.root_key();
-  string16 delegate_execute_path(L"Software\\Classes\\CLSID\\");
+  base::string16 delegate_execute_path(L"Software\\Classes\\CLSID\\");
   delegate_execute_path.append(handler_class_uuid);
 
   // Unconditionally remove registration regardless of whether or not it is
   // needed since builds after r132190 included it when it wasn't strictly
   // necessary.  Do this removal before adding in the new key to ensure that
   // the COM probe/flush below does its job.
   AddUninstallDelegateExecuteWorkItems(root, delegate_execute_path, list);
 
   // Add work items to register the handler iff it is present.
   // See also shell_util.cc's GetProgIdEntries.
   if (installer_state.operation() != InstallerState::UNINSTALL) {
     VLOG(1) << "Adding registration items for DelegateExecute verb handler.";
 
     // Force COM to flush its cache containing the path to the old handler.
     list->AddCallbackWorkItem(base::Bind(&ProbeCommandExecuteCallback,
                                          handler_class_uuid));
 
     // The path to the exe (in the version directory).
     base::FilePath delegate_execute(target_path);
     if (new_version.IsValid())
       delegate_execute = delegate_execute.AppendASCII(new_version.GetString());
     delegate_execute = delegate_execute.Append(kDelegateExecuteExe);
 
     // Command-line featuring the quoted path to the exe.
-    string16 command(1, L'"');
+    base::string16 command(1, L'"');
     command.append(delegate_execute.value()).append(1, L'"');
 
     // Register the CommandExecuteImpl class in Software\Classes\CLSID\...
     list->AddCreateRegKeyWorkItem(root, delegate_execute_path);
     list->AddSetRegValueWorkItem(root, delegate_execute_path, L"",
                                  L"CommandExecuteImpl Class", true);
-    string16 subkey(delegate_execute_path);
+    base::string16 subkey(delegate_execute_path);
     subkey.append(L"\\LocalServer32");
     list->AddCreateRegKeyWorkItem(root, subkey);
     list->AddSetRegValueWorkItem(root, subkey, L"", command, true);
     list->AddSetRegValueWorkItem(root, subkey, L"ServerExecutable",
                                  delegate_execute.value(), true);
 
     subkey.assign(delegate_execute_path).append(L"\\Programmable");
     list->AddCreateRegKeyWorkItem(root, subkey);
   }
 }
 
 void AddActiveSetupWorkItems(const InstallerState& installer_state,
                              const base::FilePath& setup_path,
                              const Version& new_version,
                              const Product& product,
                              WorkItemList* list) {
   DCHECK(installer_state.operation() != InstallerState::UNINSTALL);
   BrowserDistribution* dist = 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 " << dist->GetDisplayName();
     return;
   }
   DCHECK(installer_state.RequiresActiveSetup());
 
   const HKEY root = HKEY_LOCAL_MACHINE;
-  const string16 active_setup_path(InstallUtil::GetActiveSetupPath(dist));
+  const base::string16 active_setup_path(InstallUtil::GetActiveSetupPath(dist));
 
   VLOG(1) << "Adding registration items for Active Setup.";
   list->AddCreateRegKeyWorkItem(root, active_setup_path);
   list->AddSetRegValueWorkItem(root, active_setup_path, L"",
                                dist->GetDisplayName(), true);
 
   base::FilePath active_setup_exe(installer_state.GetInstallerDirectory(
       new_version).Append(kActiveSetupExe));
   CommandLine cmd(active_setup_exe);
   cmd.AppendSwitch(installer::switches::kConfigureUserSettings);
@@ skipping 13 matching lines @@
 
   list->AddSetRegValueWorkItem(root, active_setup_path, L"Version",
                                kActiveSetupVersion, true);
 }
 
 void AddDeleteOldIELowRightsPolicyWorkItems(
     const InstallerState& installer_state,
     WorkItemList* install_list) {
   DCHECK(install_list);
 
-  string16 key_path;
+  base::string16 key_path;
   GetIELowRightsElevationPolicyKeyPath(OLD_ELEVATION_POLICY, &key_path);
   install_list->AddDeleteRegKeyWorkItem(installer_state.root_key(), key_path);
 }
 
 // Adds work items to copy the chrome_launcher IE low rights elevation policy
 // from the primary policy GUID to the "old" policy GUID.  Take care not to
 // perform the copy if there is already an old policy present, as the ones under
 // the main kElevationPolicyGuid would then correspond to an intermediate
 // version (current_version < pv < new_version).
 void AddCopyIELowRightsPolicyWorkItems(const InstallerState& installer_state,
                                        WorkItemList* install_list) {
   DCHECK(install_list);
 
-  string16 current_key_path;
-  string16 old_key_path;
+  base::string16 current_key_path;
+  base::string16 old_key_path;
 
   GetIELowRightsElevationPolicyKeyPath(CURRENT_ELEVATION_POLICY,
                                        &current_key_path);
   GetIELowRightsElevationPolicyKeyPath(OLD_ELEVATION_POLICY, &old_key_path);
   // Do not clobber existing old policies.
   install_list->AddCopyRegKeyWorkItem(installer_state.root_key(),
                                       current_key_path, old_key_path,
                                       WorkItem::IF_NOT_PRESENT);
 }
 
@@ skipping 40 matching lines @@
     VLOG(1) << "Cannot load " << kIEFrameDll;
   }
 }
 
 void AddOsUpgradeWorkItems(const InstallerState& installer_state,
                            const base::FilePath& setup_path,
                            const Version& new_version,
                            const Product& product,
                            WorkItemList* install_list) {
   const HKEY root_key = installer_state.root_key();
-  string16 cmd_key(GetRegCommandKey(product.distribution(), kCmdOnOsUpgrade));
+  base::string16 cmd_key(
+      GetRegCommandKey(product.distribution(), kCmdOnOsUpgrade));
 
   if (installer_state.operation() == InstallerState::UNINSTALL) {
     install_list->AddDeleteRegKeyWorkItem(root_key, cmd_key)->
         set_log_message("Removing OS upgrade command");
   } else {
     // Register with Google Update to have setup.exe --on-os-upgrade called on
     // OS upgrade.
     CommandLine cmd_line(installer_state
         .GetInstallerDirectory(new_version)
         .Append(setup_path.BaseName()));
@@ skipping 11 matching lines @@
     cmd.AddWorkItems(installer_state.root_key(), cmd_key, install_list);
   }
 }
 
 void AddQueryEULAAcceptanceWorkItems(const InstallerState& installer_state,
                                      const base::FilePath& setup_path,
                                      const Version& new_version,
                                      const Product& product,
                                      WorkItemList* work_item_list) {
   const HKEY root_key = installer_state.root_key();
-  string16 cmd_key(GetRegCommandKey(product.distribution(),
-                                    kCmdQueryEULAAcceptance));
+  base::string16 cmd_key(
+      GetRegCommandKey(product.distribution(), kCmdQueryEULAAcceptance));
   if (installer_state.operation() == InstallerState::UNINSTALL) {
     work_item_list->AddDeleteRegKeyWorkItem(root_key, cmd_key)->
         set_log_message("Removing query EULA acceptance command");
   } else {
     CommandLine cmd_line(installer_state
         .GetInstallerDirectory(new_version)
         .Append(setup_path.BaseName()));
     cmd_line.AppendSwitch(switches::kQueryEULAAcceptance);
     if (installer_state.system_install())
       cmd_line.AppendSwitch(installer::switches::kSystemLevel);
     if (installer_state.verbose_logging())
       cmd_line.AppendSwitch(installer::switches::kVerboseLogging);
     AppCommand cmd(cmd_line.GetCommandLineString());
     cmd.set_is_web_accessible(true);
     cmd.set_is_run_as_user(true);
     cmd.AddWorkItems(installer_state.root_key(), cmd_key, work_item_list);
   }
 }
 
 void AddQuickEnableChromeFrameWorkItems(const InstallerState& installer_state,
                                         WorkItemList* work_item_list) {
   DCHECK(work_item_list);
 
-  string16 cmd_key(GetRegCommandKey(
-                       BrowserDistribution::GetSpecificDistribution(
+  base::string16 cmd_key(
+      GetRegCommandKey(BrowserDistribution::GetSpecificDistribution(
                            BrowserDistribution::CHROME_BINARIES),
                        kCmdQuickEnableCf));
 
   // Unconditionally remove the legacy Quick Enable command from the binaries.
   // Do this even if multi-install Chrome isn't installed to ensure that it is
   // not left behind in any case.
   work_item_list->AddDeleteRegKeyWorkItem(
       installer_state.root_key(), cmd_key)->set_log_message(
           "removing " + WideToASCII(kCmdQuickEnableCf) + " command");
 
 }
 
 }  // namespace installer