Use base namespace for string16 in components and cloud_print.

cloud_print/common/win/install_utils.cc

 // Copyright 2013 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 "cloud_print/common/win/install_utils.h"
 
 #include <windows.h>
 
 #include "base/command_line.h"
 #include "base/file_util.h"
@@ skipping 25 matching lines @@
 const wchar_t kDisplayVersion[] = L"DisplayVersion";
 const wchar_t kDisplayIcon[] = L"DisplayIcon";
 const wchar_t kDisplayName[] = L"DisplayName";
 const wchar_t kPublisher[] = L"Publisher";
 const wchar_t kNoModify[] = L"NoModify";
 const wchar_t kNoRepair[] = L"NoRepair";
 
 }  // namespace
 
 
-void SetGoogleUpdateKeys(const string16& product_id,
-                         const string16& product_name) {
+void SetGoogleUpdateKeys(const base::string16& product_id,
+                         const base::string16& product_name) {
   base::win::RegKey key;
   if (key.Create(HKEY_LOCAL_MACHINE,
                  (cloud_print::kClientsKey + product_id).c_str(),
                  KEY_SET_VALUE) != ERROR_SUCCESS) {
     LOG(ERROR) << "Unable to open key";
   }
 
   // Get the version from the resource file.
-  string16 version_string;
+  base::string16 version_string;
   scoped_ptr<FileVersionInfo> version_info(
       FileVersionInfo::CreateFileVersionInfoForCurrentModule());
 
   if (version_info.get()) {
     FileVersionInfoWin* version_info_win =
         static_cast<FileVersionInfoWin*>(version_info.get());
     version_string = version_info_win->product_version();
   } else {
     LOG(ERROR) << "Unable to get version string";
     // Use a random version string so that Google Update has something to go by.
     version_string = L"0.0.0.99";
   }
 
   if (key.WriteValue(kVersionKey, version_string.c_str()) != ERROR_SUCCESS ||
       key.WriteValue(kNameKey, product_name.c_str()) != ERROR_SUCCESS) {
     LOG(ERROR) << "Unable to set registry keys";
   }
 }
 
-void SetGoogleUpdateError(const string16& product_id, const string16& message) {
+void SetGoogleUpdateError(const base::string16& product_id,
+                          const base::string16& message) {
   LOG(ERROR) << message;
   base::win::RegKey key;
   if (key.Create(HKEY_LOCAL_MACHINE,
                  (cloud_print::kClientStateKey + product_id).c_str(),
                  KEY_SET_VALUE) != ERROR_SUCCESS) {
     LOG(ERROR) << "Unable to open key";
   }
 
   if (key.WriteValue(kRegValueInstallerResult,
                      kInstallerResultFailedCustomError) != ERROR_SUCCESS ||
       key.WriteValue(kRegValueInstallerResultUIString,
                      message.c_str()) != ERROR_SUCCESS) {
       LOG(ERROR) << "Unable to set registry keys";
   }
 }
 
-void DeleteGoogleUpdateKeys(const string16& product_id) {
+void DeleteGoogleUpdateKeys(const base::string16& product_id) {
   base::win::RegKey key;
   if (key.Open(HKEY_LOCAL_MACHINE,
                (cloud_print::kClientsKey + product_id).c_str(),
                DELETE) != ERROR_SUCCESS) {
     LOG(ERROR) << "Unable to open key to delete";
     return;
   }
   if (key.DeleteKey(L"") != ERROR_SUCCESS) {
     LOG(ERROR) << "Unable to delete key";
   }
 }
 
-void CreateUninstallKey(const string16& uninstall_id,
-                        const string16& product_name,
+void CreateUninstallKey(const base::string16& uninstall_id,
+                        const base::string16& product_name,
                         const std::string& uninstall_switch) {
   // Now write the Windows Uninstall entries
   // Minimal error checking here since the install can continue
   // if this fails.
   base::win::RegKey key;
   if (key.Create(HKEY_LOCAL_MACHINE,
                  (cloud_print::kUninstallKey + uninstall_id).c_str(),
                  KEY_SET_VALUE) != ERROR_SUCCESS) {
     LOG(ERROR) << "Unable to open key";
     return;
@@ skipping 21 matching lines @@
     key.WriteValue(kPublisher, version_info_win->company_name().c_str());
   } else {
     LOG(ERROR) << "Unable to get version string";
   }
   key.WriteValue(kDisplayName, product_name.c_str());
   key.WriteValue(kDisplayIcon, unstall_binary.value().c_str());
   key.WriteValue(kNoModify, 1);
   key.WriteValue(kNoRepair, 1);
 }
 
-void DeleteUninstallKey(const string16& uninstall_id) {
+void DeleteUninstallKey(const base::string16& uninstall_id) {
   ::RegDeleteKey(HKEY_LOCAL_MACHINE,
                  (cloud_print::kUninstallKey + uninstall_id).c_str());
 }
 
-base::FilePath GetInstallLocation(const string16& uninstall_id) {
+base::FilePath GetInstallLocation(const base::string16& uninstall_id) {
   base::win::RegKey key;
   if (key.Open(HKEY_LOCAL_MACHINE,
                (cloud_print::kUninstallKey + uninstall_id).c_str(),
                KEY_QUERY_VALUE) != ERROR_SUCCESS) {
     // Not installed.
     return base::FilePath();
   }
-  string16 install_path_value;
+  base::string16 install_path_value;
   key.ReadValue(kInstallLocation, &install_path_value);
   return base::FilePath(install_path_value);
 }
 
 void DeleteProgramDir(const std::string& delete_switch) {
   base::FilePath installer_source;
   if (!PathService::Get(base::FILE_EXE, &installer_source))
     return;
   // Deletes only subdirs of program files.
   if (!IsProgramsFilesParent(installer_source))
@@ skipping 14 matching lines @@
 
 bool IsProgramsFilesParent(const base::FilePath& path) {
   base::FilePath program_files;
   if (!PathService::Get(base::DIR_PROGRAM_FILESX86, &program_files))
     return false;
   return program_files.IsParent(path);
 }
 
 }  // namespace cloud_print