Add base:: to string16s in chrome/.

chrome/installer/setup/setup_main.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.
 
 #include "chrome/installer/setup/setup_main.h"
 
 #include <windows.h>
 #include <msi.h>
 #include <shellapi.h>
 #include <shlobj.h>
@@ skipping 246 matching lines @@
                                                       install_list.get());
   }
   // old_chrome.exe is still in use in most cases, so ignore failures here.
   install_list->AddDeleteTreeWorkItem(chrome_old_exe, temp_path.path())->
       set_ignore_failure(true);
 
   // Add work items to delete the "opv", "cpv", and "cmd" values from all
   // products we're operating on (which including the multi-install binaries).
   const Products& products = installer_state->products();
   HKEY reg_root = installer_state->root_key();
-  string16 version_key;
+  base::string16 version_key;
   for (Products::const_iterator it = products.begin(); it < products.end();
        ++it) {
     version_key = (*it)->distribution()->GetVersionKey();
     install_list->AddDeleteRegValueWorkItem(
         reg_root, version_key, google_update::kRegOldVersionField);
     install_list->AddDeleteRegValueWorkItem(
         reg_root, version_key, google_update::kRegCriticalVersionField);
     install_list->AddDeleteRegValueWorkItem(
         reg_root, version_key, google_update::kRegRenameCmdField);
   }
@@ skipping 576 matching lines @@
     (*it)->distribution()->UpdateInstallStatus(
         system_install, archive_type, install_status);
   }
 
   UninstallBinariesIfUnused(original_state, *installer_state, &install_status);
 
   installer_state->UpdateStage(installer::NO_STAGE);
   return install_status;
 }
 
-installer::InstallStatus ShowEULADialog(const string16& inner_frame) {
+installer::InstallStatus ShowEULADialog(const base::string16& inner_frame) {
   VLOG(1) << "About to show EULA";
-  string16 eula_path = installer::GetLocalizedEulaResource();
+  base::string16 eula_path = installer::GetLocalizedEulaResource();
   if (eula_path.empty()) {
     LOG(ERROR) << "No EULA path available";
     return installer::EULA_REJECTED;
   }
   // Newer versions of the caller pass an inner frame parameter that must
   // be given to the html page being launched.
   installer::EulaHTMLDialog dlg(eula_path, inner_frame);
   installer::EulaHTMLDialog::Outcome outcome = dlg.ShowModal();
   if (installer::EulaHTMLDialog::REJECTED == outcome) {
     LOG(ERROR) << "EULA rejected or EULA failure";
@@ skipping 20 matching lines @@
           file_util::WriteFile(eula_sentinel, "", 0) != -1);
 }
 
 void ActivateMetroChrome() {
   // Check to see if we're per-user or not. Need to do this since we may
   // not have been invoked with --system-level even for a machine install.
   wchar_t exe_path[MAX_PATH * 2] = {};
   GetModuleFileName(NULL, exe_path, arraysize(exe_path));
   bool is_per_user_install = InstallUtil::IsPerUserInstall(exe_path);
 
-  string16 app_model_id =
-      ShellUtil::GetBrowserModelId(BrowserDistribution::GetDistribution(),
-                                   is_per_user_install);
+  base::string16 app_model_id = ShellUtil::GetBrowserModelId(
+      BrowserDistribution::GetDistribution(), is_per_user_install);
 
   base::win::ScopedComPtr<IApplicationActivationManager> activator;
   HRESULT hr = activator.CreateInstance(CLSID_ApplicationActivationManager);
   if (SUCCEEDED(hr)) {
     DWORD pid = 0;
     hr = activator->ActivateApplication(
         app_model_id.c_str(), L"open", AO_NONE, &pid);
   }
 
   LOG_IF(ERROR, FAILED(hr)) << "Tried and failed to launch Metro Chrome. "
@@ skipping 14 matching lines @@
       original_state.GetProductState(false,
                                      BrowserDistribution::CHROME_BROWSER);
   if (!existing_chrome) {
     existing_chrome =
       original_state.GetProductState(true, BrowserDistribution::CHROME_BROWSER);
   }
   if (existing_chrome) {
     static const wchar_t kPleaseUninstallYourChromeMessage[] =
         L"You already have a full-installation (non-dev) of %1ls, please "
         L"uninstall it first using Add/Remove Programs in the control panel.";
-    string16 name(chrome_dist->GetDisplayName());
-    string16 message(base::StringPrintf(kPleaseUninstallYourChromeMessage,
-                                        name.c_str()));
+    base::string16 name(chrome_dist->GetDisplayName());
+    base::string16 message(
+        base::StringPrintf(kPleaseUninstallYourChromeMessage, name.c_str()));
 
     LOG(ERROR) << "Aborting operation: another installation of " << name
                << " was found, as a last resort (if the product is not present "
                   "in Add/Remove Programs), try executing: "
                << existing_chrome->uninstall_command().GetCommandLineString();
     MessageBox(NULL, message.c_str(), NULL, MB_ICONERROR);
     return installer::INSTALL_FAILED;
   }
 
   base::FilePath chrome_exe(
@@ skipping 84 matching lines @@
     if (*exit_code) {
       LOG(WARNING) << "setup.exe patching failed.";
       installer_state->WriteInstallerResult(
           status, IDS_SETUP_PATCH_FAILED_BASE, NULL);
     }
     // We will be exiting normally, so clear the stage indicator.
     installer_state->UpdateStage(installer::NO_STAGE);
   } else if (cmd_line.HasSwitch(installer::switches::kShowEula)) {
     // Check if we need to show the EULA. If it is passed as a command line
     // then the dialog is shown and regardless of the outcome setup exits here.
-    string16 inner_frame =
+    base::string16 inner_frame =
         cmd_line.GetSwitchValueNative(installer::switches::kShowEula);
     *exit_code = ShowEULADialog(inner_frame);
 
     if (installer::EULA_REJECTED != *exit_code) {
       if (GoogleUpdateSettings::SetEULAConsent(
               original_state, BrowserDistribution::GetDistribution(), true)) {
         CreateEULASentinel(BrowserDistribution::GetDistribution());
       }
       // For a metro-originated launch, we now need to launch back into metro.
       if (cmd_line.HasSwitch(installer::switches::kShowEulaForMetro))
@@ skipping 35 matching lines @@
       // control panel settings, or through website use of
       // registerProtocolHandler. These protocols are found in
       // ShellUtil::kPotentialProtocolAssociations.
       // The --register-url-protocol will additionally register Chrome as a
       // potential handler for the supplied protocol, and is used if a website
       // registers a handler for a protocol not found in
       // ShellUtil::kPotentialProtocolAssociations.
       // These options should only be used when setup.exe is launched with admin
       // rights. We do not make any user specific changes with this option.
       DCHECK(IsUserAnAdmin());
-      string16 chrome_exe(cmd_line.GetSwitchValueNative(
+      base::string16 chrome_exe(cmd_line.GetSwitchValueNative(
           installer::switches::kRegisterChromeBrowser));
-      string16 suffix;
+      base::string16 suffix;
       if (cmd_line.HasSwitch(
           installer::switches::kRegisterChromeBrowserSuffix)) {
         suffix = cmd_line.GetSwitchValueNative(
             installer::switches::kRegisterChromeBrowserSuffix);
       }
       if (cmd_line.HasSwitch(installer::switches::kRegisterURLProtocol)) {
-        string16 protocol = cmd_line.GetSwitchValueNative(
+        base::string16 protocol = cmd_line.GetSwitchValueNative(
             installer::switches::kRegisterURLProtocol);
         // ShellUtil::RegisterChromeForProtocol performs all registration
         // done by ShellUtil::RegisterChromeBrowser, as well as registering
         // with Windows as capable of handling the supplied protocol.
         if (ShellUtil::RegisterChromeForProtocol(
                 chrome_install->distribution(), chrome_exe, suffix, protocol,
                 false))
           status = installer::IN_USE_UPDATED;
       } else {
         if (ShellUtil::RegisterChromeBrowser(chrome_install->distribution(),
             chrome_exe, suffix, false))
           status = installer::IN_USE_UPDATED;
       }
     } else {
       LOG(DFATAL) << "Can't register browser - Chrome distribution not found";
     }
     *exit_code = InstallUtil::GetInstallReturnCode(status);
   } else if (cmd_line.HasSwitch(installer::switches::kRenameChromeExe)) {
     // If --rename-chrome-exe is specified, we want to rename the executables
     // and exit.
     *exit_code = RenameChromeExecutables(original_state, installer_state);
   } else if (cmd_line.HasSwitch(
                  installer::switches::kRemoveChromeRegistration)) {
     // This is almost reverse of --register-chrome-browser option above.
     // Here we delete Chrome browser registration. This option should only
     // be used when setup.exe is launched with admin rights. We do not
     // make any user specific changes in this option.
-    string16 suffix;
+    base::string16 suffix;
     if (cmd_line.HasSwitch(
             installer::switches::kRegisterChromeBrowserSuffix)) {
       suffix = cmd_line.GetSwitchValueNative(
           installer::switches::kRegisterChromeBrowserSuffix);
     }
     installer::InstallStatus tmp = installer::UNKNOWN_STATUS;
     const Product* chrome_install =
         installer_state->FindProduct(BrowserDistribution::CHROME_BROWSER);
     DCHECK(chrome_install);
     if (chrome_install) {
@@ skipping 116 matching lines @@
 
   // Popup a dialog that will prompt to reboot using the default system message.
   // TODO(robertshield): Add a localized, more specific string to the prompt.
   RestartDialog(NULL, NULL, EWX_REBOOT | EWX_FORCEIFHUNG);
   return true;
 }
 
 // Returns the Custom information for the client identified by the exe path
 // passed in. This information is used for crash reporting.
 google_breakpad::CustomClientInfo* GetCustomInfo(const wchar_t* exe_path) {
-  string16 product;
-  string16 version;
+  base::string16 product;
+  base::string16 version;
   scoped_ptr<FileVersionInfo> version_info(
       FileVersionInfo::CreateFileVersionInfo(base::FilePath(exe_path)));
   if (version_info.get()) {
     version = version_info->product_version();
     product = version_info->product_short_name();
   }
 
   if (version.empty())
     version = L"0.1.0.0";
 
@@ skipping 24 matching lines @@
   base::FilePath temp_directory;
   if (!base::GetTempDir(&temp_directory) || temp_directory.empty())
     return NULL;
 
   wchar_t exe_path[MAX_PATH * 2] = {0};
   GetModuleFileName(NULL, exe_path, arraysize(exe_path));
 
   // Build the pipe name. It can be either:
   // System-wide install: "NamedPipe\GoogleCrashServices\S-1-5-18"
   // Per-user install: "NamedPipe\GoogleCrashServices\<user SID>"
-  string16 user_sid = kSystemPrincipalSid;
+  base::string16 user_sid = kSystemPrincipalSid;
 
   if (!system_install) {
     if (!base::win::GetUserSidString(&user_sid)) {
       return NULL;
     }
   }
 
-  string16 pipe_name = kGoogleUpdatePipeName;
+  base::string16 pipe_name = kGoogleUpdatePipeName;
   pipe_name += user_sid;
 
   google_breakpad::ExceptionHandler* breakpad =
       new google_breakpad::ExceptionHandler(
           temp_directory.value(), NULL, NULL, NULL,
           google_breakpad::ExceptionHandler::HANDLER_ALL, kLargerDumpType,
           pipe_name.c_str(), GetCustomInfo(exe_path));
   return breakpad;
 }
 
@@ skipping 246 matching lines @@
 
     if (proceed_with_installation) {
       base::FilePath prefs_source_path(cmd_line.GetSwitchValueNative(
           switches::kInstallerData));
       install_status = InstallOrUpdateProduct(
           original_state, installer_state, cmd_line.GetProgram(),
           uncompressed_archive, temp_path.path(), src_path, prefs_source_path,
           prefs, *installer_version);
 
       int install_msg_base = IDS_INSTALL_FAILED_BASE;
-      string16 chrome_exe;
-      string16 quoted_chrome_exe;
+      base::string16 chrome_exe;
+      base::string16 quoted_chrome_exe;
       if (install_status == SAME_VERSION_REPAIR_FAILED) {
         if (installer_state.FindProduct(BrowserDistribution::CHROME_FRAME)) {
           install_msg_base = IDS_SAME_VERSION_REPAIR_FAILED_CF_BASE;
         } else {
           install_msg_base = IDS_SAME_VERSION_REPAIR_FAILED_BASE;
         }
       } else if (install_status != INSTALL_FAILED) {
         if (installer_state.target_path().empty()) {
           // If we failed to construct install path, it means the OS call to
           // get %ProgramFiles% or %AppData% failed. Report this as failure.
@@ skipping 38 matching lines @@
           prefs.GetBool(master_preferences::kDoNotLaunchChrome,
                         &do_not_launch_chrome);
           if (!system_install && !do_not_launch_chrome)
             chrome_install->LaunchChrome(installer_state.target_path());
         }
       } else if ((install_status == NEW_VERSION_UPDATED) ||
                  (install_status == IN_USE_UPDATED)) {
         const Product* chrome = installer_state.FindProduct(
             BrowserDistribution::CHROME_BROWSER);
         if (chrome != NULL) {
-          DCHECK_NE(chrome_exe, string16());
+          DCHECK_NE(chrome_exe, base::string16());
           RemoveChromeLegacyRegistryKeys(chrome->distribution(), chrome_exe);
         }
       }
 
       if (prefs.install_chrome_app_launcher() &&
           InstallUtil::GetInstallReturnCode(install_status) == 0) {
         std::string webstore_item(google_update::GetUntrustedDataValue(
             kInstallFromWebstore));
         if (!webstore_item.empty()) {
           bool success = InstallFromWebstore(webstore_item);
@@ skipping 212 matching lines @@
     // Call the newly updated setup.exe with kUncompressedArchive and
     // kMigrateChromeFrame to perform the migration.
     LaunchChromeFrameMigrationProcess(*chrome_frame_state, cmd_line,
                                       installer_directory, system_install);
   }
 
   VLOG(1) << "Installation complete, returning: " << return_code;
 
   return return_code;
 }