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 164 matching lines @@
   FilePath full_installer;
   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));
-
+  ASSERT_TRUE(file_util::PathExists(path));
+  CommandLine installer(path);
+  if (is_chrome_frame_) {
+    installer.AppendSwitch(installer::switches::kDoNotCreateShortcuts);
+    installer.AppendSwitch(installer::switches::kDoNotLaunchChrome);
+    installer.AppendSwitch(installer::switches::kDoNotRegisterForUpdateLaunch);
+    installer.AppendSwitch(installer::switches::kChromeFrame);
+  }
+  RunInstaller(installer);
   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);
@@ skipping 12 matching lines @@
       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();
+  cmd.AppendSwitch(installer::switches::kDoNotCreateShortcuts);
+  cmd.AppendSwitch(installer::switches::kDoNotLaunchChrome);
+  cmd.AppendSwitch(installer::switches::kDoNotRegisterForUpdateLaunch);
+  cmd.AppendSwitch(installer::switches::kChromeFrame);
   RunInstaller(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");
@@ skipping 66 matching lines @@
   LOG(INFO) << "Tagging command: " << command.GetCommandLineString();
   return command;
 }
 
 // Installs chromesetup.exe, waits for the install to finish and then
 // checks the registry and shortcuts.
 void ChromeMiniInstaller::InstallMetaInstaller() {
   // Install Google Chrome through meta installer.
   CommandLine installer(FilePath::FromWStringHack(
       mini_installer_constants::kChromeMetaInstallerExe));
+  ASSERT_TRUE(file_util::PathExists(installer.GetProgram()));
+  if (is_chrome_frame_) {
+    installer.AppendSwitch(installer::switches::kDoNotCreateShortcuts);
+    installer.AppendSwitch(installer::switches::kDoNotLaunchChrome);
+    installer.AppendSwitch(installer::switches::kDoNotRegisterForUpdateLaunch);
+    installer.AppendSwitch(installer::switches::kChromeFrame);
+  }
   RunInstaller(installer);
+
   ASSERT_TRUE(MiniInstallerTestUtil::VerifyProcessClose(
       mini_installer_constants::kChromeMetaInstallerExecutable));
 
   std::wstring chrome_google_update_state_key(
       google_update::kRegPathClients);
   chrome_google_update_state_key.append(L"\\");
 
   BrowserDistribution* dist = GetCurrentBrowserDistribution();
   chrome_google_update_state_key.append(dist->GetAppGuid());
 
@@ skipping 30 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 23 matching lines @@
 }
 
 // Get HKEY based on install type.
 HKEY ChromeMiniInstaller::GetRootRegistryKey() {
   HKEY type = HKEY_CURRENT_USER;
   if (system_install_)
     type = HKEY_LOCAL_MACHINE;
   return type;
 }
 
-// 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);
-  }
   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;
 }