Get rid of FromWStringHack in chrome_mini_installer.cc.

chrome/test/mini_installer_test/chrome_mini_installer.cc

 // Copyright (c) 2010 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"
 #include "base/registry.h"
 #include "base/string_number_conversions.h"
 #include "base/string_util.h"
 #include "chrome/installer/util/browser_distribution.h"
 #include "chrome/installer/util/google_update_constants.h"
 #include "chrome/test/mini_installer_test/mini_installer_test_constants.h"
 #include "chrome/test/mini_installer_test/mini_installer_test_util.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
-// Constructor.
 ChromeMiniInstaller::ChromeMiniInstaller(const std::wstring& install_type,
-    bool is_chrome_frame) : is_chrome_frame_(is_chrome_frame),
-                            install_type_(install_type) {
+                                         bool is_chrome_frame)
+    : is_chrome_frame_(is_chrome_frame),
+      install_type_(install_type),
+      has_diff_installer_(false),
+      has_full_installer_(false),
+      has_prev_installer_(false) {
   installer_name_ = StringPrintf(L"%ls (%ls)",
       mini_installer_constants::kChromeBuildType, install_type_.c_str());
-
-  has_diff_installer_ = false;
-  has_full_installer_ = false;
-  has_prev_installer_ = false;
 }
 
 void ChromeMiniInstaller::SetBuildUnderTest(const std::wstring& build) {
   // Locate the full, diff, and previous installers.
   const wchar_t * build_prefix;
   if (LowerCaseEqualsASCII(build, "dev"))
     build_prefix = mini_installer_constants::kDevChannelBuild;
   else if (LowerCaseEqualsASCII(build, "stable"))
     build_prefix = mini_installer_constants::kStableChannelBuild;
   else if (LowerCaseEqualsASCII(build, "latest"))
@@ skipping 91 matching lines @@
   InstallMiniInstaller(over_install, full_installer_);
 }
 
 // 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(FilePath::FromWStringHack(path)));
+  ASSERT_TRUE(file_util::PathExists(FilePath(path)));
   LaunchInstaller(path, exe_name.c_str());
   BrowserDistribution* dist = BrowserDistribution::GetDistribution();
   ASSERT_TRUE(CheckRegistryKey(dist->GetVersionKey()));
   VerifyInstall(over_install);
 }
 
 // This method tests the standalone installer by verifying the steps listed at:
 // https://sites.google.com/a/google.com/chrome-pmo/
 // standalone-installers/testing-standalone-installers
 // This method applies appropriate tags to standalone installer and deletes
 // old installer before running the new tagged installer. It also verifies
 // that the installed version is correct.
 void ChromeMiniInstaller::InstallStandaloneInstaller() {
-  standalone_installer = true;
   file_util::Delete(mini_installer_constants::kStandaloneInstaller, true);
   std::wstring tag_installer_command;
   ASSERT_TRUE(MiniInstallerTestUtil::GetCommandForTagging(
       &tag_installer_command));
   base::LaunchApp(tag_installer_command, true, false, NULL);
   std::wstring installer_path = MiniInstallerTestUtil::GetFilePath(
       mini_installer_constants::kStandaloneInstaller);
   InstallMiniInstaller(false, installer_path);
   ASSERT_TRUE(VerifyStandaloneInstall());
   file_util::Delete(mini_installer_constants::kStandaloneInstaller, true);
@@ skipping 85 matching lines @@
     MiniInstallerTestUtil::CloseProcesses(L"IEXPLORE.EXE");
   MiniInstallerTestUtil::CloseProcesses(installer_util::kChromeExe);
   MiniInstallerTestUtil::CloseProcesses(installer_util::kNaClExe);
   std::wstring uninstall_path = GetUninstallPath();
   if (uninstall_path == L"") {
     printf("\n %ls install is in a weird state. Cleaning the machine...\n",
             product_name.c_str());
     CleanChromeInstall();
     return;
   }
-  ASSERT_TRUE(file_util::PathExists(FilePath::FromWStringHack(uninstall_path)));
+  ASSERT_TRUE(file_util::PathExists(FilePath(uninstall_path)));
   std::wstring uninstall_args(L"\"");
   uninstall_args.append(uninstall_path);
   uninstall_args.append(L"\" --uninstall --force-uninstall");
   if (is_chrome_frame_)
     uninstall_args.append(L" --chrome-frame");
   if (install_type_ == mini_installer_constants::kSystemInstall)
     uninstall_args = uninstall_args + L" --system-level";
   base::LaunchApp(uninstall_args, false, false, NULL);
   if (is_chrome_frame_)
     ASSERT_TRUE(CloseUninstallWindow());
@@ skipping 158 matching lines @@
   pv_key.append(dist->GetAppGuid());
 
   RegKey key;
   if (key.Open(GetRootRegistryKey(), pv_key.c_str(), KEY_ALL_ACCESS))
     ASSERT_TRUE(key.DeleteValue(L"pv"));
   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);
+  FilePath uninstall_lnk;
+  FilePath path = GetStartMenuShortcutPath();
+  path = path.Append(mini_installer_constants::kChromeBuildType);
   // Verify if path exists.
-  if (file_util::PathExists(FilePath::FromWStringHack(path))) {
+  if (file_util::PathExists(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(FilePath::FromWStringHack(path)));
-    ASSERT_TRUE(file_util::PathExists(
-        FilePath::FromWStringHack(uninstall_lnk)));
+    path = path.Append(mini_installer_constants::kChromeLaunchShortcut);
+    uninstall_lnk = uninstall_lnk.Append(
+        mini_installer_constants::kChromeUninstallShortcut);
+    ASSERT_TRUE(file_util::PathExists(path));
+    ASSERT_TRUE(file_util::PathExists(uninstall_lnk));
   }
-  if (return_val)
+  if (return_val) {
     printf("Chrome shortcuts found are:\n%ls\n%ls\n\n",
-           path.c_str(), uninstall_lnk.c_str());
-  else
+           path.value().c_str(), uninstall_lnk.value().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.
 std::wstring ChromeMiniInstaller::GetChromeInstallDirectoryLocation() {
   FilePath path;
   if (install_type_ == mini_installer_constants::kSystemInstall)
     PathService::Get(base::DIR_PROGRAM_FILES, &path);
   else
     PathService::Get(base::DIR_LOCAL_APP_DATA, &path);
   return path.ToWStringHack();
 }
 
-// This method gets the shortcut path  from startmenu based on install type
-std::wstring ChromeMiniInstaller::GetStartMenuShortcutPath() {
+FilePath ChromeMiniInstaller::GetStartMenuShortcutPath() {
   FilePath path_name;
   if (install_type_ == mini_installer_constants::kSystemInstall)
     PathService::Get(base::DIR_COMMON_START_MENU, &path_name);
   else
     PathService::Get(base::DIR_START_MENU, &path_name);
-  return path_name.ToWStringHack();
+  return path_name;
 }
 
 // Gets the path for uninstall.
 std::wstring ChromeMiniInstaller::GetUninstallPath() {
-  std::wstring username, append_path, path, reg_key_value;
+  std::wstring path, reg_key_value;
   if (!GetChromeVersionFromRegistry(&reg_key_value))
-    return L"";
+    return std::wstring();
   path = GetChromeInstallDirectoryLocation();
-  if (is_chrome_frame_)
+  if (is_chrome_frame_) {
     file_util::AppendToPath(&path,
         mini_installer_constants::kChromeFrameAppDir);
-  else
+  } else {
     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(FilePath::FromWStringHack(path))) {
+  if (!file_util::PathExists(FilePath(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(FilePath::FromWStringHack(path)));
+  ASSERT_TRUE(file_util::PathExists(FilePath(path)));
   if (install_type_ == mini_installer_constants::kSystemInstall) {
     std::wstring launch_args;
     if (is_chrome_frame_) {
       launch_args.append(L" --do-not-create-shortcuts");
       launch_args.append(L" --do-not-register-for-update-launch");
       launch_args.append(L" --chrome-frame");
     }
     launch_args.append(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(FilePath::FromWStringHack(path)));
+  return file_util::PathExists(FilePath(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)) {
     MiniInstallerTestUtil::VerifyProcessLaunch(
         installer_util::kChromeExe, true);
   }
@@ skipping 88 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;
 }