Add base:: to string16s in chrome/.

chrome/installer/util/install_util.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.
 //
 // See the corresponding header file for description of the functions in this
 // file.
 
 #include "chrome/installer/util/install_util.h"
 
 #include <shellapi.h>
@@ skipping 107 matching lines @@
     } else {
       NOTREACHED() << "Unable to get default monitor";
     }
     ::SetForegroundWindow(foreground_window);
   }
   return foreground_window;
 }
 
 }  // namespace
 
-string16 InstallUtil::GetActiveSetupPath(BrowserDistribution* dist) {
+base::string16 InstallUtil::GetActiveSetupPath(BrowserDistribution* dist) {
   static const wchar_t kInstalledComponentsPath[] =
       L"Software\\Microsoft\\Active Setup\\Installed Components\\";
   return kInstalledComponentsPath + dist->GetActiveSetupGuid();
 }
 
 void InstallUtil::TriggerActiveSetupCommand() {
-  string16 active_setup_reg(
+  base::string16 active_setup_reg(
       GetActiveSetupPath(BrowserDistribution::GetDistribution()));
   base::win::RegKey active_setup_key(
       HKEY_LOCAL_MACHINE, active_setup_reg.c_str(), KEY_QUERY_VALUE);
-  string16 cmd_str;
+  base::string16 cmd_str;
   LONG read_status = active_setup_key.ReadValue(L"StubPath", &cmd_str);
   if (read_status != ERROR_SUCCESS) {
     LOG(ERROR) << active_setup_reg << ", " << read_status;
     // This should never fail if Chrome is registered at system-level, but if it
     // does there is not much else to be done.
     return;
   }
 
   CommandLine cmd(CommandLine::FromString(cmd_str));
   // Force creation of shortcuts as the First Run beacon might land between now
@@ skipping 64 matching lines @@
 
 void InstallUtil::GetChromeVersion(BrowserDistribution* dist,
                                    bool system_install,
                                    Version* version) {
   DCHECK(dist);
   RegKey key;
   HKEY reg_root = (system_install) ? HKEY_LOCAL_MACHINE : HKEY_CURRENT_USER;
   LONG result = key.Open(reg_root, dist->GetVersionKey().c_str(),
                          KEY_QUERY_VALUE);
 
-  string16 version_str;
+  base::string16 version_str;
   if (result == ERROR_SUCCESS)
     result = key.ReadValue(google_update::kRegVersionField, &version_str);
 
   *version = Version();
   if (result == ERROR_SUCCESS && !version_str.empty()) {
     VLOG(1) << "Existing " << dist->GetDisplayName() << " version found "
             << version_str;
     *version = Version(WideToASCII(version_str));
   } else {
     DCHECK_EQ(ERROR_FILE_NOT_FOUND, result);
     VLOG(1) << "No existing " << dist->GetDisplayName()
             << " install found.";
   }
 }
 
 void InstallUtil::GetCriticalUpdateVersion(BrowserDistribution* dist,
                                            bool system_install,
                                            Version* version) {
   DCHECK(dist);
   RegKey key;
   HKEY reg_root = (system_install) ? HKEY_LOCAL_MACHINE : HKEY_CURRENT_USER;
   LONG result =
       key.Open(reg_root, dist->GetVersionKey().c_str(), KEY_QUERY_VALUE);
 
-  string16 version_str;
+  base::string16 version_str;
   if (result == ERROR_SUCCESS)
     result = key.ReadValue(google_update::kRegCriticalVersionField,
                            &version_str);
 
   *version = Version();
   if (result == ERROR_SUCCESS && !version_str.empty()) {
     VLOG(1) << "Critical Update version for " << dist->GetDisplayName()
             << " found " << version_str;
     *version = Version(WideToASCII(version_str));
   } else {
     DCHECK_EQ(ERROR_FILE_NOT_FOUND, result);
     VLOG(1) << "No existing " << dist->GetDisplayName()
             << " install found.";
   }
 }
 
 bool InstallUtil::IsOSSupported() {
   // We do not support Win2K or older, or XP without service pack 2.
   VLOG(1) << base::SysInfo::OperatingSystemName() << ' '
           << base::SysInfo::OperatingSystemVersion();
   base::win::Version version = base::win::GetVersion();
   return (version > base::win::VERSION_XP) ||
       ((version == base::win::VERSION_XP) &&
        (base::win::OSInfo::GetInstance()->service_pack().major >= 2));
 }
 
-void InstallUtil::AddInstallerResultItems(bool system_install,
-                                          const string16& state_key,
-                                          installer::InstallStatus status,
-                                          int string_resource_id,
-                                          const string16* const launch_cmd,
-                                          WorkItemList* install_list) {
+void InstallUtil::AddInstallerResultItems(
+    bool system_install,
+    const base::string16& state_key,
+    installer::InstallStatus status,
+    int string_resource_id,
+    const base::string16* const launch_cmd,
+    WorkItemList* install_list) {
   DCHECK(install_list);
   const HKEY root = system_install ? HKEY_LOCAL_MACHINE : HKEY_CURRENT_USER;
   DWORD installer_result = (GetInstallReturnCode(status) == 0) ? 0 : 1;
   install_list->AddCreateRegKeyWorkItem(root, state_key);
   install_list->AddSetRegValueWorkItem(root, state_key,
                                        installer::kInstallerResult,
                                        installer_result, true);
   install_list->AddSetRegValueWorkItem(root, state_key,
                                        installer::kInstallerError,
                                        static_cast<DWORD>(status), true);
   if (string_resource_id != 0) {
-    string16 msg = installer::GetLocalizedString(string_resource_id);
+    base::string16 msg = installer::GetLocalizedString(string_resource_id);
     install_list->AddSetRegValueWorkItem(root, state_key,
         installer::kInstallerResultUIString, msg, true);
   }
   if (launch_cmd != NULL && !launch_cmd->empty()) {
     install_list->AddSetRegValueWorkItem(root, state_key,
         installer::kInstallerSuccessLaunchCmdLine, *launch_cmd, true);
   }
 }
 
 void InstallUtil::UpdateInstallerStage(bool system_install,
-                                       const string16& state_key_path,
+                                       const base::string16& state_key_path,
                                        installer::InstallerStage stage) {
   DCHECK_LE(static_cast<installer::InstallerStage>(0), stage);
   DCHECK_GT(installer::NUM_STAGES, stage);
   const HKEY root = system_install ? HKEY_LOCAL_MACHINE : HKEY_CURRENT_USER;
   RegKey state_key;
   LONG result = state_key.Open(root, state_key_path.c_str(),
                                KEY_QUERY_VALUE | KEY_SET_VALUE);
   if (result == ERROR_SUCCESS) {
     if (stage == installer::NO_STAGE) {
       result = state_key.DeleteValue(installer::kInstallerExtraCode1);
@@ skipping 45 matching lines @@
 bool CheckIsChromeSxSProcess() {
   CommandLine* command_line = CommandLine::ForCurrentProcess();
   CHECK(command_line);
 
   if (command_line->HasSwitch(installer::switches::kChromeSxS))
     return true;
 
   // Also return true if we are running from Chrome SxS installed path.
   base::FilePath exe_dir;
   PathService::Get(base::DIR_EXE, &exe_dir);
-  string16 chrome_sxs_dir(installer::kGoogleChromeInstallSubDir2);
+  base::string16 chrome_sxs_dir(installer::kGoogleChromeInstallSubDir2);
   chrome_sxs_dir.append(installer::kSxSSuffix);
 
   // This is SxS if current EXE is in or under (possibly multiple levels under)
   // |chrome_sxs_dir|\|installer::kInstallBinaryDir|
   std::vector<base::FilePath::StringType> components;
   exe_dir.GetComponents(&components);
   // We need at least 1 element in the array for the behavior of the following
   // loop to be defined.  This should always be true, since we're splitting the
   // path to our executable and one of the components will be the drive letter.
   DCHECK(!components.empty());
@@ skipping 51 matching lines @@
   }
 
   *path = path->Append(file);
   return true;
 }
 
 // This method tries to delete a registry key and logs an error message
 // in case of failure. It returns true if deletion is successful (or the key did
 // not exist), otherwise false.
 bool InstallUtil::DeleteRegistryKey(HKEY root_key,
-                                    const string16& key_path) {
+                                    const base::string16& key_path) {
   VLOG(1) << "Deleting registry key " << key_path;
   LONG result = ::SHDeleteKey(root_key, key_path.c_str());
   if (result != ERROR_SUCCESS && result != ERROR_FILE_NOT_FOUND) {
     LOG(ERROR) << "Failed to delete registry key: " << key_path
                << " error: " << result;
     return false;
   }
   return true;
 }
 
 // This method tries to delete a registry value and logs an error message
 // in case of failure. It returns true if deletion is successful (or the key did
 // not exist), otherwise false.
 bool InstallUtil::DeleteRegistryValue(HKEY reg_root,
-                                      const string16& key_path,
-                                      const string16& value_name) {
+                                      const base::string16& key_path,
+                                      const base::string16& value_name) {
   RegKey key;
   LONG result = key.Open(reg_root, key_path.c_str(), KEY_SET_VALUE);
   if (result == ERROR_SUCCESS)
     result = key.DeleteValue(value_name.c_str());
   if (result != ERROR_SUCCESS && result != ERROR_FILE_NOT_FOUND) {
     LOG(ERROR) << "Failed to delete registry value: " << value_name
                << " error: " << result;
     return false;
   }
   return true;
 }
 
 // static
 InstallUtil::ConditionalDeleteResult InstallUtil::DeleteRegistryKeyIf(
     HKEY root_key,
-    const string16& key_to_delete_path,
-    const string16& key_to_test_path,
+    const base::string16& key_to_delete_path,
+    const base::string16& key_to_test_path,
     const wchar_t* value_name,
     const RegistryValuePredicate& predicate) {
   DCHECK(root_key);
   ConditionalDeleteResult delete_result = NOT_FOUND;
   RegKey key;
-  string16 actual_value;
+  base::string16 actual_value;
   if (key.Open(root_key, key_to_test_path.c_str(),
                KEY_QUERY_VALUE) == ERROR_SUCCESS &&
       key.ReadValue(value_name, &actual_value) == ERROR_SUCCESS &&
       predicate.Evaluate(actual_value)) {
     key.Close();
     delete_result = DeleteRegistryKey(root_key, key_to_delete_path)
         ? DELETED : DELETE_FAILED;
   }
   return delete_result;
 }
 
 // static
 InstallUtil::ConditionalDeleteResult InstallUtil::DeleteRegistryValueIf(
     HKEY root_key,
     const wchar_t* key_path,
     const wchar_t* value_name,
     const RegistryValuePredicate& predicate) {
   DCHECK(root_key);
   DCHECK(key_path);
   ConditionalDeleteResult delete_result = NOT_FOUND;
   RegKey key;
-  string16 actual_value;
+  base::string16 actual_value;
   if (key.Open(root_key, key_path,
                KEY_QUERY_VALUE | KEY_SET_VALUE) == ERROR_SUCCESS &&
       key.ReadValue(value_name, &actual_value) == ERROR_SUCCESS &&
       predicate.Evaluate(actual_value)) {
     LONG result = key.DeleteValue(value_name);
     if (result != ERROR_SUCCESS) {
       LOG(ERROR) << "Failed to delete registry value: "
                  << (value_name ? value_name : L"(Default)")
                  << " error: " << result;
       delete_result = DELETE_FAILED;
     }
     delete_result = DELETED;
   }
   return delete_result;
 }
 
-bool InstallUtil::ValueEquals::Evaluate(const string16& value) const {
+bool InstallUtil::ValueEquals::Evaluate(const base::string16& value) const {
   return value == value_to_match_;
 }
 
 // static
 int InstallUtil::GetInstallReturnCode(installer::InstallStatus status) {
   switch (status) {
     case installer::FIRST_INSTALL_SUCCESS:
     case installer::INSTALL_REPAIRED:
     case installer::NEW_VERSION_UPDATED:
     case installer::IN_USE_UPDATED:
     case installer::UNUSED_BINARIES_UNINSTALLED:
       return 0;
     default:
       return status;
   }
 }
 
 // static
-void InstallUtil::MakeUninstallCommand(const string16& program,
-                                       const string16& arguments,
+void InstallUtil::MakeUninstallCommand(const base::string16& program,
+                                       const base::string16& arguments,
                                        CommandLine* command_line) {
   *command_line = CommandLine::FromString(L"\"" + program + L"\" " + arguments);
 }
 
 // static
-string16 InstallUtil::GetCurrentDate() {
+base::string16 InstallUtil::GetCurrentDate() {
   static const wchar_t kDateFormat[] = L"yyyyMMdd";
   wchar_t date_str[arraysize(kDateFormat)] = {0};
   int len = GetDateFormatW(LOCALE_INVARIANT, 0, NULL, kDateFormat,
                            date_str, arraysize(date_str));
   if (len) {
     --len;  // Subtract terminating \0.
   } else {
     PLOG(DFATAL) << "GetDateFormat";
   }
 
-  return string16(date_str, len);
+  return base::string16(date_str, len);
 }
 
 // Open |path| with minimal access to obtain information about it, returning
 // true and populating |handle| on success.
 // static
 bool InstallUtil::ProgramCompare::OpenForInfo(const base::FilePath& path,
                                               base::win::ScopedHandle* handle) {
   DCHECK(handle);
   handle->Set(base::CreatePlatformFile(path, base::PLATFORM_FILE_OPEN, NULL,
                                        NULL));
@@ skipping 21 matching lines @@
     PLOG(WARNING) << "Failed getting information for "
                   << path_to_match_.value()
                   << "; falling back to path string comparisons.";
     file_handle_.Close();
   }
 }
 
 InstallUtil::ProgramCompare::~ProgramCompare() {
 }
 
-bool InstallUtil::ProgramCompare::Evaluate(const string16& value) const {
+bool InstallUtil::ProgramCompare::Evaluate(const base::string16& value) const {
   // Suss out the exe portion of the value, which is expected to be a command
   // line kinda (or exactly) like:
   // "c:\foo\bar\chrome.exe" -- "%1"
   base::FilePath program(CommandLine::FromString(value).GetProgram());
   if (program.empty()) {
     LOG(WARNING) << "Failed to parse an executable name from command line: \""
                  << value << "\"";
     return false;
   }
 
@@ skipping 15 matching lines @@
   // Open the program and see if it references the expected file.
   base::win::ScopedHandle handle;
   BY_HANDLE_FILE_INFORMATION info = {};
 
   return (OpenForInfo(path, &handle) &&
           GetInfo(handle, &info) &&
           info.dwVolumeSerialNumber == file_info_.dwVolumeSerialNumber &&
           info.nFileIndexHigh == file_info_.nFileIndexHigh &&
           info.nFileIndexLow == file_info_.nFileIndexLow);
 }