Merge the installer, installer_util and setup_util namespaces into a single i...

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/command_line.h"
 #include "base/file_util.h"
 #include "base/path_service.h"
 #include "base/platform_thread.h"
@@ skipping 192 matching lines @@
 // This method will first install Chrome. Deletes either registry or
 // folder based on the passed argument, then tries to launch Chrome.
 // Then installs Chrome again to repair.
 void ChromeMiniInstaller::Repair(
     ChromeMiniInstaller::RepairChrome repair_type) {
   InstallFullInstaller(false);
   if (is_chrome_frame_) {
     MiniInstallerTestUtil::CloseProcesses(
         mini_installer_constants::kIEProcessName);
   } else {
-    MiniInstallerTestUtil::CloseProcesses(installer_util::kNaClExe);
+    MiniInstallerTestUtil::CloseProcesses(installer::kNaClExe);
   }
-  MiniInstallerTestUtil::CloseProcesses(installer_util::kChromeExe);
+  MiniInstallerTestUtil::CloseProcesses(installer::kChromeExe);
   if (repair_type == ChromeMiniInstaller::VERSION_FOLDER) {
     DeleteFolder(L"version_folder");
     printf("Deleted folder. Now trying to launch chrome\n");
   } else if (repair_type == ChromeMiniInstaller::REGISTRY) {
     DeletePvRegistryKey();
     printf("Deleted registry. Now trying to launch chrome\n");
   }
   FilePath current_path;
   ASSERT_TRUE(MiniInstallerTestUtil::ChangeCurrentDirectory(&current_path));
   VerifyChromeLaunch(false);
@@ skipping 20 matching lines @@
     product_name = mini_installer_constants::kChromeProductName;
   BrowserDistribution* dist = BrowserDistribution::GetDistribution();
   if (!CheckRegistryKey(dist->GetVersionKey())) {
     printf("%ls is not installed.\n", product_name.c_str());
     return;
   }
   if (is_chrome_frame_) {
     MiniInstallerTestUtil::CloseProcesses(
         mini_installer_constants::kIEProcessName);
   } else {
-    MiniInstallerTestUtil::CloseProcesses(installer_util::kNaClExe);
+    MiniInstallerTestUtil::CloseProcesses(installer::kNaClExe);
   }
-  MiniInstallerTestUtil::CloseProcesses(installer_util::kChromeExe);
+  MiniInstallerTestUtil::CloseProcesses(installer::kChromeExe);
   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(uninstall_path)));
   std::wstring uninstall_args(L"\"");
   uninstall_args.append(uninstall_path);
@@ skipping 54 matching lines @@
   }
   return true;
 }
 
 // Closes Chrome browser.
 bool ChromeMiniInstaller::CloseChromeBrowser() {
   int timer = 0;
   HWND handle = NULL;
   // This loop iterates through all of the top-level Windows
   // named Chrome_WidgetWin_0 and closes them
-  while ((base::GetProcessCount(installer_util::kChromeExe, NULL) > 0) &&
+  while ((base::GetProcessCount(installer::kChromeExe, NULL) > 0) &&
          (timer < 40000)) {
     // Chrome may have been launched, but the window may not have appeared
     // yet. Wait for it to appear for 10 seconds, but exit if it takes longer
     // than that.
     while (!handle && timer < 10000) {
       handle = FindWindowEx(NULL, handle, L"Chrome_WidgetWin_0", NULL);
       if (!handle) {
         PlatformThread::Sleep(100);
         timer = timer + 100;
       }
     }
     if (!handle)
       return false;
     SetForegroundWindow(handle);
     LRESULT _result = SendMessage(handle, WM_CLOSE, 1, 0);
     if (_result != 0)
       return false;
     PlatformThread::Sleep(1000);
     timer = timer + 1000;
   }
-  if (base::GetProcessCount(installer_util::kChromeExe, NULL) > 0) {
+  if (base::GetProcessCount(installer::kChromeExe, NULL) > 0) {
     printf("Chrome.exe is still running even after closing all windows\n");
     return false;
   }
-  if (base::GetProcessCount(installer_util::kNaClExe, NULL) > 0) {
+  if (base::GetProcessCount(installer::kNaClExe, NULL) > 0) {
     printf("NaCl.exe is still running even after closing all windows\n");
     return false;
   }
   return true;
 }
 
 // Checks for Chrome registry keys.
 bool ChromeMiniInstaller::CheckRegistryKey(const std::wstring& key_path) {
   RegKey key;
   if (!key.Open(GetRootRegistryKey(), key_path.c_str(), KEY_ALL_ACCESS)) {
@@ skipping 130 matching lines @@
   if (!GetChromeVersionFromRegistry(&reg_key_value))
     return std::wstring();
   path = GetChromeInstallDirectoryLocation();
   if (is_chrome_frame_) {
     file_util::AppendToPath(&path,
         mini_installer_constants::kChromeFrameAppDir);
   } 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, installer::kInstallerDir);
   file_util::AppendToPath(&path,
       mini_installer_constants::kChromeSetupExecutable);
   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;
 }
@@ skipping 41 matching lines @@
   printf("Waiting while this process is running  %ls ....\n", process_name);
   MiniInstallerTestUtil::VerifyProcessLaunch(process_name, true);
   ASSERT_TRUE(MiniInstallerTestUtil::VerifyProcessHandleClosed(app_handle));
 }
 
 // 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);
+  file_util::AppendToPath(&path, installer::kChromeExe);
   launch_path->assign(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);
+        installer::kChromeExe, true);
   }
-  MiniInstallerTestUtil::CloseProcesses(installer_util::kChromeExe);
+  MiniInstallerTestUtil::CloseProcesses(installer::kChromeExe);
 }
 
 // This method will get Chrome exe path and launch it.
 void ChromeMiniInstaller::VerifyChromeLaunch(bool expected_status) {
   std::wstring launch_path;
   GetChromeLaunchPath(&launch_path);
-  LaunchBrowser(launch_path, L"", installer_util::kChromeExe, expected_status);
+  LaunchBrowser(launch_path, L"", installer::kChromeExe, expected_status);
 }
 
 // Verifies Chrome/Chrome Frame install.
 void ChromeMiniInstaller::VerifyInstall(bool over_install) {
   if (is_chrome_frame_) {
     VerifyChromeFrameInstall();
   } else {
     if ((install_type_ == mini_installer_constants::kUserInstall) &&
         (!over_install)) {
       MiniInstallerTestUtil::VerifyProcessLaunch(
-          installer_util::kChromeExe, true);
+          installer::kChromeExe, true);
     }
     PlatformThread::Sleep(800);
     FindChromeShortcut();
     LaunchAndCloseChrome(over_install);
   }
 }
 
 // This method will verify if ChromeFrame installed successfully. It will
 // launch IE with cf:about:version, then check if
 // chrome.exe process got spawned.
 void ChromeMiniInstaller::VerifyChromeFrameInstall() {
   FilePath browser_path;
   PathService::Get(base::DIR_PROGRAM_FILES, &browser_path);
   browser_path = browser_path.Append(mini_installer_constants::kIELocation);
   browser_path = browser_path.Append(mini_installer_constants::kIEProcessName);
 
   CommandLine cmd_line(browser_path);
   cmd_line.AppendArgNative(L"gcf:about:version");
 
   // Launch IE
   base::LaunchApp(cmd_line, false, false, NULL);
 
   // Check if Chrome process got spawned.
-  MiniInstallerTestUtil::VerifyProcessLaunch(installer_util::kChromeExe, true);
+  MiniInstallerTestUtil::VerifyProcessLaunch(installer::kChromeExe, true);
 
   // Verify if IExplore folder got created
   FilePath path = GetUserDataDirPath();
   path = path.AppendASCII("IEXPLORE");
   if (!file_util::PathExists(path)) {
     // The profile folder for IE 6 and 7 lives in the user's Temporary Internet
     // Files folder. Check there if the previous one was not found.
     PathService::Get(base::DIR_IE_INTERNET_CACHE, &path);
     path = path.AppendASCII("Google Chrome Frame");
   }
@@ skipping 39 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;
 }