Remove multi-install from chrome/installer/setup.

chrome/installer/setup/installer_state_unittest.cc

 // Copyright (c) 2012 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/installer/setup/installer_state.h"
 
 #include <windows.h>
 #include <stddef.h>
 
 #include <fstream>
@@ skipping 44 matching lines @@
   DISALLOW_COPY_AND_ASSIGN(InstallerStateTest);
 };
 
 // An installer state on which we can access otherwise protected members.
 class MockInstallerState : public InstallerState {
  public:
   MockInstallerState() : InstallerState() { }
   void set_target_path(const base::FilePath& target_path) {
     target_path_ = target_path;
   }
-  static bool IsFileInUse(const base::FilePath& file) {
-    return InstallerState::IsFileInUse(file);
-  }
   const base::Version& critical_update_version() const {
     return critical_update_version_;
   }
 };
 
 TEST_F(InstallerStateTest, WithProduct) {
-  const bool multi_install = false;
   const bool system_level = true;
   base::CommandLine cmd_line = base::CommandLine::FromString(
       std::wstring(L"setup.exe") +
-      (multi_install ? L" --multi-install --chrome" : L"") +
       (system_level ? L" --system-level" : L""));
   MasterPreferences prefs(cmd_line);
   InstallationState machine_state;
   machine_state.Initialize();
   MockInstallerState installer_state;
   installer_state.Initialize(cmd_line, prefs, machine_state);
   installer_state.set_target_path(test_dir_.GetPath());
-  EXPECT_EQ(1U, installer_state.products().size());
   EXPECT_EQ(system_level, installer_state.system_install());
 
   const char kCurrentVersion[] = "1.2.3.4";
   base::Version current_version(kCurrentVersion);
 
   HKEY root = system_level ? HKEY_LOCAL_MACHINE : HKEY_CURRENT_USER;
   EXPECT_EQ(root, installer_state.root_key());
 
   {
     RegistryOverrideManager override_manager;
@@ skipping 19 matching lines @@
 
 TEST_F(InstallerStateTest, InstallerResult) {
   const bool system_level = true;
   HKEY root = system_level ? HKEY_LOCAL_MACHINE : HKEY_CURRENT_USER;
 
   RegKey key;
   std::wstring launch_cmd = L"hey diddle diddle";
   std::wstring value;
   DWORD dw_value;
 
-  // Check results for a fresh install of single Chrome and the same for an
-  // attempt at multi-install, which is now ignored.
+  // Check results for a fresh install of Chrome and the same for an attempt at
+  // multi-install, which is now ignored.
   static constexpr const wchar_t* kCommandLines[] = {
       L"setup.exe --system-level",
       L"setup.exe --system-level --multi-install --chrome",
   };
   for (const wchar_t* command_line : kCommandLines) {
     RegistryOverrideManager override_manager;
     override_manager.OverrideRegistry(root);
     base::CommandLine cmd_line = base::CommandLine::FromString(command_line);
     const MasterPreferences prefs(cmd_line);
     InstallationState machine_state;
@@ skipping 39 matching lines @@
   MasterPreferences prefs(cmd_line);
   InstallerState installer_state;
   installer_state.Initialize(cmd_line, prefs, machine_state);
 
   // Is the Chrome version picked up?
   std::unique_ptr<base::Version> version(
       installer_state.GetCurrentVersion(machine_state));
   EXPECT_TRUE(version.get() != NULL);
 }
 
-TEST_F(InstallerStateTest, IsFileInUse) {
-  base::ScopedTempDir temp_dir;
-  ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
-
-  base::FilePath temp_file;
-  ASSERT_TRUE(base::CreateTemporaryFileInDir(temp_dir.GetPath(), &temp_file));
-
-  EXPECT_FALSE(MockInstallerState::IsFileInUse(temp_file));
-
-  {
-    // Open a handle to the file with the same access mode and sharing options
-    // as the loader.
-    base::win::ScopedHandle temp_handle(CreateFile(
-        temp_file.value().c_str(), SYNCHRONIZE | FILE_EXECUTE,
-        FILE_SHARE_DELETE | FILE_SHARE_READ, NULL, OPEN_EXISTING, 0, 0));
-    ASSERT_TRUE(temp_handle.IsValid());
-
-    // The file should now be in use.
-    EXPECT_TRUE(MockInstallerState::IsFileInUse(temp_file));
-  }
-
-  // And once the handle is gone, it should no longer be in use.
-  EXPECT_FALSE(MockInstallerState::IsFileInUse(temp_file));
-}
-
 TEST_F(InstallerStateTest, InitializeTwice) {
   // Override these paths so that they can be found after the registry override
   // manager is in place.
   base::FilePath temp;
   PathService::Get(base::DIR_PROGRAM_FILES, &temp);
   base::ScopedPathOverride program_files_override(base::DIR_PROGRAM_FILES,
                                                   temp);
   PathService::Get(base::DIR_PROGRAM_FILESX86, &temp);
   base::ScopedPathOverride program_filesx86_override(base::DIR_PROGRAM_FILESX86,
                                                      temp);
@@ skipping 10 matching lines @@
   InstallerState installer_state;
 
   // Initialize the instance to install user-level Chrome.
   {
     base::CommandLine cmd_line(base::CommandLine::FromString(L"setup.exe"));
     MasterPreferences prefs(cmd_line);
     installer_state.Initialize(cmd_line, prefs, machine_state);
   }
   // Confirm the expected state.
   EXPECT_EQ(InstallerState::USER_LEVEL, installer_state.level());
-  EXPECT_EQ(InstallerState::SINGLE_PACKAGE, installer_state.package_type());
   EXPECT_EQ(InstallerState::SINGLE_INSTALL_OR_UPDATE,
             installer_state.operation());
   EXPECT_TRUE(wcsstr(installer_state.target_path().value().c_str(),
                      BrowserDistribution::GetSpecificDistribution(
                          BrowserDistribution::CHROME_BROWSER)
                          ->GetInstallSubDir()
                          .c_str()));
   EXPECT_FALSE(installer_state.verbose_logging());
   EXPECT_EQ(installer_state.state_key(),
             BrowserDistribution::GetSpecificDistribution(
                 BrowserDistribution::CHROME_BROWSER)->GetStateKey());
   EXPECT_EQ(installer_state.state_type(), BrowserDistribution::CHROME_BROWSER);
-  EXPECT_TRUE(installer_state.FindProduct(BrowserDistribution::CHROME_BROWSER));
 
   // Now initialize it to install system-level single Chrome.
   {
     base::CommandLine cmd_line(base::CommandLine::FromString(
         L"setup.exe --system-level --verbose-logging"));
     MasterPreferences prefs(cmd_line);
     installer_state.Initialize(cmd_line, prefs, machine_state);
   }
 
   // Confirm that the old state is gone.
   EXPECT_EQ(InstallerState::SYSTEM_LEVEL, installer_state.level());
-  EXPECT_EQ(InstallerState::SINGLE_PACKAGE, installer_state.package_type());
   EXPECT_EQ(InstallerState::SINGLE_INSTALL_OR_UPDATE,
             installer_state.operation());
   EXPECT_TRUE(wcsstr(installer_state.target_path().value().c_str(),
                      BrowserDistribution::GetSpecificDistribution(
                          BrowserDistribution::CHROME_BROWSER)->
                          GetInstallSubDir().c_str()));
   EXPECT_TRUE(installer_state.verbose_logging());
   EXPECT_EQ(installer_state.state_key(),
             BrowserDistribution::GetSpecificDistribution(
                 BrowserDistribution::CHROME_BROWSER)->GetStateKey());
   EXPECT_EQ(installer_state.state_type(), BrowserDistribution::CHROME_BROWSER);
-  EXPECT_TRUE(installer_state.FindProduct(BrowserDistribution::CHROME_BROWSER));
 }
 
 // A fixture for testing InstallerState::DetermineCriticalVersion.  Individual
 // tests must invoke Initialize() with a critical version.
 class InstallerStateCriticalVersionTest : public ::testing::Test {
  protected:
   InstallerStateCriticalVersionTest()
       : cmd_line_(base::CommandLine::NO_PROGRAM) {}
 
   // Creates a set of versions for use by all test runs.
@@ skipping 131 matching lines @@
   // Critical update newer than the new version.
   EXPECT_FALSE(
       installer_state.DetermineCriticalVersion(NULL, *pv_version_).IsValid());
   EXPECT_FALSE(
       installer_state.DetermineCriticalVersion(opv_version_, *pv_version_)
           .IsValid());
   EXPECT_FALSE(
       installer_state.DetermineCriticalVersion(pv_version_, *pv_version_)
           .IsValid());
 }