Add test for Chrome install with existing Chrome Frame Multi-install

chrome/test/mini_installer_test/chrome_mini_installer.cc

 // Copyright (c) 2011 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 <algorithm>
 
 #include "base/command_line.h"
 #include "base/file_util.h"
@@ skipping 165 matching lines @@
   ASSERT_TRUE(GetFullInstaller(&full_installer));
   InstallMiniInstaller(over_install, full_installer);
 }
 
 // Installs the Chrome mini-installer, checks the registry and shortcuts.
 void ChromeMiniInstaller::InstallMiniInstaller(bool over_install,
                                                const FilePath& path) {
   LOG(INFO) << "Install level is: "
       << (system_install_ ? "system" : "user");
   RunInstaller(CommandLine(path));
-
   std::string version;
   ASSERT_TRUE(GetChromeVersionFromRegistry(&version))
       << "Install failed: unable to get version.";
   VerifyInstall(over_install);
 }
 
 CommandLine ChromeMiniInstaller::GetBaseMultiInstallCommand() {
   FilePath mini_installer;
   if (!GetMiniInstaller(&mini_installer))
     return CommandLine(CommandLine::NO_PROGRAM);
   CommandLine cmd(mini_installer);
   cmd.AppendSwitch(installer::switches::kMultiInstall);
   return cmd;
 }
 
 void ChromeMiniInstaller::InstallChromeUsingMultiInstall() {
   CommandLine cmd = GetBaseMultiInstallCommand();
   cmd.AppendSwitch(installer::switches::kChrome);
-  RunInstaller(cmd);
+  RunInstallerCommand(cmd);
 
   // Verify installation.
   InstallationValidator::InstallationType type =
       installer::ExpectValidInstallation(system_install_);
   BrowserDistribution* dist = GetCurrentBrowserDistribution();
   ASSERT_TRUE(InstallUtil::IsMultiInstall(dist, system_install_));
   EXPECT_TRUE(type & InstallationValidator::ProductBits::CHROME_MULTI);
   FindChromeShortcut();
   LaunchChrome(true);
 }
 
 void ChromeMiniInstaller::InstallChromeFrameUsingMultiInstall() {
   CommandLine cmd = GetBaseMultiInstallCommand();
-  RunInstaller(cmd);
+  cmd.AppendSwitch(installer::switches::kDoNotCreateShortcuts);
+  cmd.AppendSwitch(installer::switches::kDoNotLaunchChrome);
+  cmd.AppendSwitch(installer::switches::kDoNotRegisterForUpdateLaunch);
+  cmd.AppendSwitch(installer::switches::kChromeFrame);
+  RunInstallerCommand(cmd);
 
   // Verify installation.
   InstallationValidator::InstallationType type =
       installer::ExpectValidInstallation(system_install_);
   BrowserDistribution* dist = GetCurrentBrowserDistribution();
   ASSERT_TRUE(InstallUtil::IsMultiInstall(dist, system_install_));
   EXPECT_TRUE(type & InstallationValidator::ProductBits::CHROME_FRAME_MULTI);
   // Launch IE
   LaunchIE(L"gcf:about:version");
   if (system_install_) {
     MiniInstallerTestUtil::VerifyProcessLaunch(installer::kChromeExe, true);
   } else {
     MiniInstallerTestUtil::VerifyProcessLaunch(
         installer::kChromeFrameHelperExe, true);
   }
   FindChromeShortcut();
 }
 
 void ChromeMiniInstaller::InstallChromeAndChromeFrame(bool ready_mode) {
   CommandLine cmd = GetBaseMultiInstallCommand();
   cmd.AppendSwitch(installer::switches::kChrome);
   cmd.AppendSwitch(installer::switches::kChromeFrame);
   if (ready_mode)
     cmd.AppendSwitch(installer::switches::kChromeFrameReadyMode);
-  RunInstaller(cmd);
+  RunInstallerCommand(cmd);
   // Verify installation.
   InstallationValidator::InstallationType type =
       installer::ExpectValidInstallation(system_install_);
   BrowserDistribution* dist = GetCurrentBrowserDistribution();
   ASSERT_TRUE(InstallUtil::IsMultiInstall(dist, system_install_));
   EXPECT_TRUE(type & InstallationValidator::ProductBits::CHROME_MULTI);
   if (ready_mode) {
     EXPECT_TRUE(type &
         InstallationValidator::ProductBits::CHROME_FRAME_READY_MODE);
   }
@@ skipping 91 matching lines @@
     MiniInstallerTestUtil::CloseProcesses(
         mini_installer_constants::kIEProcessName);
   } else {
     MiniInstallerTestUtil::CloseProcesses(installer::kNaClExe);
   }
   MiniInstallerTestUtil::CloseProcesses(installer::kChromeExe);
   if (repair_type == ChromeMiniInstaller::VERSION_FOLDER) {
     std::string build_number;
     ASSERT_TRUE(GetChromeVersionFromRegistry(&build_number));
     FilePath install_path;
-    ASSERT_TRUE(GetChromeInstallDirectoryLocation(&install_path));
+    ASSERT_TRUE(GetInstallDirectory(&install_path));
     install_path = install_path.AppendASCII(build_number);
     ASSERT_TRUE(file_util::Delete(install_path, true));
   } 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));
   LaunchChrome(false);
   LOG(INFO) << "Installing Chrome again to see if it can be repaired.";
@@ skipping 86 matching lines @@
 
   DeleteUserDataFolder();
   MiniInstallerTestUtil::CloseProcesses(
       mini_installer_constants::kIEProcessName);
 }
 
 // Will clean up the machine if Chrome install is messed up.
 void ChromeMiniInstaller::CleanChromeInstall() {
   DeletePvRegistryKey();
   FilePath install_path;
-  ASSERT_TRUE(GetChromeInstallDirectoryLocation(&install_path));
+  ASSERT_TRUE(GetInstallDirectory(&install_path));
   ASSERT_TRUE(file_util::Delete(install_path, true));
 }
 
 bool ChromeMiniInstaller::CloseUninstallWindow() {
   HWND hndl = NULL;
   int timer = 0;
   std::wstring window_name;
   if (is_chrome_frame_)
     window_name = mini_installer_constants::kChromeFrameAppName;
   else
@@ skipping 141 matching lines @@
   }
   if (return_val) {
     LOG(INFO) << "Found Chrome shortcuts:\n"
               << path.value() << "\n"
               << uninstall_lnk.value();
   } else {
     LOG(INFO) << "No Chrome shortcuts found.";
   }
 }
 
-bool ChromeMiniInstaller::GetChromeInstallDirectoryLocation(FilePath* path) {
+bool ChromeMiniInstaller::GetInstallDirectory(FilePath* path) {
   BrowserDistribution* dist = GetCurrentBrowserDistribution();
-  *path = installer::GetChromeInstallPath(system_install_, dist);
+    *path = installer::GetChromeInstallPath(system_install_, dist);
   FilePath parent;
   if (system_install_) {
     PathService::Get(base::DIR_PROGRAM_FILES, &parent);
     return file_util::ContainsPath(parent, *path);
   } else {
     PathService::Get(base::DIR_LOCAL_APP_DATA, &parent);
     return file_util::ContainsPath(parent, *path);
   }
 }
 
@@ skipping 33 matching lines @@
 // Launches the chrome installer and waits for it to end.
 void ChromeMiniInstaller::RunInstaller(const CommandLine& command) {
   ASSERT_TRUE(file_util::PathExists(command.GetProgram()));
   CommandLine installer(command);
   if (is_chrome_frame_) {
     installer.AppendSwitch(installer::switches::kDoNotCreateShortcuts);
     installer.AppendSwitch(installer::switches::kDoNotLaunchChrome);
     installer.AppendSwitch(installer::switches::kDoNotRegisterForUpdateLaunch);
     installer.AppendSwitch(installer::switches::kChromeFrame);
   }
+  RunInstallerCommand(installer);
+}
+
+void ChromeMiniInstaller::RunInstallerCommand(const CommandLine& command) {
+  ASSERT_TRUE(file_util::PathExists(command.GetProgram()));
+  CommandLine installer(command);
   if (system_install_) {
     installer.AppendSwitch(installer::switches::kSystemLevel);
   }
 
   LOG(INFO) << "Running installer command: "
       << installer.GetCommandLineString();
   base::ProcessHandle app_handle;
   ASSERT_TRUE(
       base::LaunchProcess(installer, base::LaunchOptions(), &app_handle))
       << "Installer failed.";
   ASSERT_TRUE(base::WaitForSingleProcess(app_handle, 60 * 1000))
       << "Installer did not complete.";
 }
 
 void ChromeMiniInstaller::LaunchChrome(bool kill) {
   MiniInstallerTestUtil::CloseProcesses(installer::kChromeExe);
 
   FilePath install_path;
-  ASSERT_TRUE(GetChromeInstallDirectoryLocation(&install_path));
+  ASSERT_TRUE(GetInstallDirectory(&install_path));
   install_path = install_path.Append(installer::kChromeExe);
   CommandLine browser(install_path);
 
   FilePath exe = browser.GetProgram();
   LOG(INFO) << "Browser launch command: " << browser.GetCommandLineString();
   base::ProcessHandle chrome;
   ASSERT_TRUE(base::LaunchProcess(browser, base::LaunchOptions(), &chrome))
       << "Could not launch process: " << exe.value();
 
   if (kill) {
@@ skipping 192 matching lines @@
   }
 
   if (installer.empty()) {
     LOG(WARNING) << "Failed to find installer with pattern: " << pattern;
     return false;
   }
 
   *path = installer;
   return true;
 }