Remove some deprecated file_util wstring functions.

chrome/test/mini_installer_test/chrome_mini_installer.cc

 // Copyright (c) 2009 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/test/mini_installer_test/chrome_mini_installer.h"
 
 #include "base/file_util.h"
 #include "base/path_service.h"
 #include "base/platform_thread.h"
 #include "base/process_util.h"
@@ skipping 94 matching lines @@
   InstallMiniInstaller(over_install, full_installer_file_name);
 }
 
 // Installs the Chrome mini-installer, checks the registry and shortcuts.
 void ChromeMiniInstaller::InstallMiniInstaller(bool over_install,
                                                const std::wstring& path) {
   std::wstring exe_name = file_util::GetFilenameFromPath(path);
   printf("\nChrome will be installed at %ls level\n", install_type_.c_str());
   printf("\nWill proceed with the test only if this path exists: %ls\n\n",
          path.c_str());
-  ASSERT_TRUE(file_util::PathExists(path));
+  ASSERT_TRUE(file_util::PathExists(FilePath::FromWStringHack(path)));
   LaunchInstaller(path, exe_name.c_str());
   BrowserDistribution* dist = BrowserDistribution::GetDistribution();
   ASSERT_TRUE(CheckRegistryKey(dist->GetVersionKey()));
   printf("\nInstall Checks:\n\n");
   if ((install_type_ == mini_installer_constants::kUserInstall) &&
       (!over_install))
     CloseFirstRunUIDialog(over_install);
   PlatformThread::Sleep(800);
   FindChromeShortcut();
   LaunchAndCloseChrome(over_install);
@@ skipping 97 matching lines @@
   }
   printf("\n\nUninstalling Chrome...\n");
   printf("Closing Chrome processes, if any...\n");
   MiniInstallerTestUtil::CloseProcesses(installer_util::kChromeExe);
   std::wstring uninstall_path = GetUninstallPath();
   if (uninstall_path == L"") {
     printf("\n Chrome install is in a weird state. Cleaning the machine...\n");
     CleanChromeInstall();
     return;
   }
-  ASSERT_TRUE(file_util::PathExists(uninstall_path));
+  ASSERT_TRUE(file_util::PathExists(FilePath::FromWStringHack(uninstall_path)));
   std::wstring uninstall_args = L"\"" + uninstall_path +
                                 L"\"" + L" --uninstall --force-uninstall";
   if (install_type_ == mini_installer_constants::kSystemInstall)
     uninstall_args = uninstall_args + L" --system-level";
   base::LaunchApp(uninstall_args, false, false, NULL);
   printf("Launched setup.exe. Here are the commands passed: %ls\n",
          uninstall_args.c_str());
   // ASSERT_TRUE(CloseUninstallWindow());
   ASSERT_TRUE(MiniInstallerTestUtil::VerifyProcessClose(
       mini_installer_constants::kChromeSetupExecutable));
@@ skipping 152 matching lines @@
   printf("Deleted %ls key\n", pv_key.c_str());
 }
 
 // Verifies if Chrome shortcut exists.
 void ChromeMiniInstaller::FindChromeShortcut() {
   std::wstring username, path, append_path, uninstall_lnk, shortcut_path;
   bool return_val = false;
   path = GetStartMenuShortcutPath();
   file_util::AppendToPath(&path, mini_installer_constants::kChromeBuildType);
   // Verify if path exists.
-  if (file_util::PathExists(path)) {
+  if (file_util::PathExists(FilePath::FromWStringHack(path))) {
     return_val = true;
     uninstall_lnk = path;
     file_util::AppendToPath(&path,
                             mini_installer_constants::kChromeLaunchShortcut);
     file_util::AppendToPath(&uninstall_lnk,
                             mini_installer_constants::kChromeUninstallShortcut);
-    ASSERT_TRUE(file_util::PathExists(path));
-    ASSERT_TRUE(file_util::PathExists(uninstall_lnk));
+    ASSERT_TRUE(file_util::PathExists(FilePath::FromWStringHack(path)));
+    ASSERT_TRUE(file_util::PathExists(
+        FilePath::FromWStringHack(uninstall_lnk)));
   }
   if (return_val)
     printf("Chrome shortcuts found are:\n%ls\n%ls\n\n",
            path.c_str(), uninstall_lnk.c_str());
   else
     printf("Chrome shortcuts not found\n\n");
 }
 
 // This method returns path to either program files
 // or documents and setting based on the install type.
@@ skipping 20 matching lines @@
 std::wstring ChromeMiniInstaller::GetUninstallPath() {
   std::wstring username, append_path, path, reg_key_value;
   if (!GetChromeVersionFromRegistry(&reg_key_value))
     return L"";
   path = GetChromeInstallDirectoryLocation();
   file_util::AppendToPath(&path, mini_installer_constants::kChromeAppDir);
   file_util::AppendToPath(&path, reg_key_value);
   file_util::AppendToPath(&path, installer_util::kInstallerDir);
   file_util::AppendToPath(&path,
       mini_installer_constants::kChromeSetupExecutable);
-  if (!file_util::PathExists(path)) {
+  if (!file_util::PathExists(FilePath::FromWStringHack(path))) {
     printf("This uninstall path is not correct %ls. Will not proceed further",
            path.c_str());
     return L"";
   }
   printf("uninstall path is %ls\n", path.c_str());
   return path;
 }
 
 // Returns Chrome pv registry key value
 bool ChromeMiniInstaller::GetChromeVersionFromRegistry(
@@ skipping 12 matching lines @@
 HKEY ChromeMiniInstaller::GetRootRegistryKey() {
   HKEY type = HKEY_CURRENT_USER;
   if (install_type_ == mini_installer_constants::kSystemInstall)
     type = HKEY_LOCAL_MACHINE;
   return type;
 }
 
 // Launches the chrome installer and waits for it to end.
 void ChromeMiniInstaller::LaunchInstaller(const std::wstring& path,
                                           const wchar_t* process_name) {
-  ASSERT_TRUE(file_util::PathExists(path));
+  ASSERT_TRUE(file_util::PathExists(FilePath::FromWStringHack(path)));
   if (install_type_ == mini_installer_constants::kSystemInstall) {
     std::wstring launch_args = L" -system-level";
     base::LaunchApp(L"\"" + path + L"\"" + launch_args, false, false, NULL);
   } else {
     base::LaunchApp(L"\"" + path + L"\"", false, false, NULL);
   }
   printf("Waiting while this process is running  %ls ....\n", process_name);
   MiniInstallerTestUtil::VerifyProcessLaunch(process_name, true);
   ASSERT_TRUE(MiniInstallerTestUtil::VerifyProcessClose(process_name));
 }
 
 // Gets the path to launch Chrome.
 bool ChromeMiniInstaller::GetChromeLaunchPath(std::wstring* launch_path) {
   std::wstring path;
   path = GetChromeInstallDirectoryLocation();
   file_util::AppendToPath(&path, mini_installer_constants::kChromeAppDir);
   file_util::AppendToPath(&path, installer_util::kChromeExe);
   launch_path->assign(path);
-  return(file_util::PathExists(path));
+  return(file_util::PathExists(FilePath::FromWStringHack(path)));
 }
 
 // Launch Chrome to see if it works after overinstall. Then close it.
 void ChromeMiniInstaller::LaunchAndCloseChrome(bool over_install) {
   VerifyChromeLaunch(true);
   if ((install_type_ == mini_installer_constants::kSystemInstall) &&
       (!over_install))
     CloseFirstRunUIDialog(over_install);
   MiniInstallerTestUtil::CloseProcesses(installer_util::kChromeExe);
 }
@@ skipping 31 matching lines @@
 // This method will verify if the installed build is correct.
 bool ChromeMiniInstaller::VerifyStandaloneInstall() {
   std::wstring reg_key_value_returned, standalone_installer_version;
   MiniInstallerTestUtil::GetStandaloneVersion(&standalone_installer_version);
   GetChromeVersionFromRegistry(&reg_key_value_returned);
   if (standalone_installer_version.compare(reg_key_value_returned) == 0)
     return true;
   else
     return false;
 }