(re-commit) Implement installation of the Chrome App Host.

chrome/installer/setup/install_worker_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/install_worker.h"
 
 #include "base/win/registry.h"
 #include "base/version.h"
 #include "chrome/common/chrome_constants.h"
 #include "chrome/installer/util/delete_reg_key_work_item.h"
@@ skipping 173 matching lines @@
   virtual void TearDown() {
   }
 
   void MaybeAddBinariesToInstallationState(
       bool system_level,
       MockInstallationState* installation_state) {
     if (installation_state->GetProductState(
             system_level, BrowserDistribution::CHROME_BINARIES) == NULL) {
       MockProductState product_state;
       product_state.set_version(new Version(*current_version_));
+      product_state.set_brand(L"TEST");
+      product_state.set_multi_install(true);
+      BrowserDistribution* dist =
+          BrowserDistribution::GetSpecificDistribution(
+              BrowserDistribution::CHROME_BINARIES);
+      FilePath install_path =
+          installer::GetChromeInstallPath(system_level, dist);
+      product_state.SetUninstallProgram(
+          install_path.AppendASCII(current_version_->GetString())
+          .Append(installer::kInstallerDir)
+          .Append(installer::kSetupExe));
+      product_state.AddUninstallSwitch(installer::switches::kUninstall);
+      product_state.AddUninstallSwitch(installer::switches::kMultiInstall);
+      if (system_level)
+        product_state.AddUninstallSwitch(installer::switches::kSystemLevel);
       installation_state->SetProductState(system_level,
                                           BrowserDistribution::CHROME_BINARIES,
                                           product_state);
     }
   }
 
   void AddChromeToInstallationState(
       bool system_level,
       bool multi_install,
       bool with_chrome_frame_ready_mode,
@@ skipping 91 matching lines @@
     installer_state->set_operation(operation);
     // Hope this next one isn't checked for now.
     installer_state->set_state_key(L"PROBABLY_INVALID_REG_PATH");
     installer_state->set_state_type(BrowserDistribution::CHROME_BROWSER);
     installer_state->set_package_type(multi_install ?
                                           InstallerState::MULTI_PACKAGE :
                                           InstallerState::SINGLE_PACKAGE);
     return installer_state.release();
   }
 
+  static void AddChromeBinariesToInstallerState(
+      const InstallationState& machine_state,
+      MockInstallerState* installer_state) {
+    if (!installer_state->is_multi_install()) {
+      NOTREACHED();
+      return;
+    }
+    if (installer_state->FindProduct(BrowserDistribution::CHROME_BINARIES))
+      return;
+
+    // Fresh install or upgrade?
+    const ProductState* chrome_binaries =
+        machine_state.GetProductState(installer_state->system_install(),
+                                      BrowserDistribution::CHROME_BINARIES);
+    if (chrome_binaries != NULL) {
+      installer_state->AddProductFromState(BrowserDistribution::CHROME_BINARIES,
+                                           *chrome_binaries);
+    } else {
+      BrowserDistribution* dist =
+          BrowserDistribution::GetSpecificDistribution(
+              BrowserDistribution::CHROME_BINARIES);
+      scoped_ptr<Product> product(new Product(dist));
+      product->SetOption(installer::kOptionMultiInstall, true);
+      installer_state->AddProduct(&product);
+    }
+  }
+
   static void AddChromeToInstallerState(
       const InstallationState& machine_state,
       MockInstallerState* installer_state) {
     // Fresh install or upgrade?
     const ProductState* chrome =
         machine_state.GetProductState(installer_state->system_install(),
                                       BrowserDistribution::CHROME_BROWSER);
     if (chrome != NULL &&
         chrome->is_multi_install() == installer_state->is_multi_install()) {
       installer_state->AddProductFromState(BrowserDistribution::CHROME_BROWSER,
@@ skipping 35 matching lines @@
   }
 
   static MockInstallerState* BuildChromeInstallerState(
       bool system_install,
       bool multi_install,
       const InstallationState& machine_state,
       InstallerState::Operation operation) {
     scoped_ptr<MockInstallerState> installer_state(
         BuildBasicInstallerState(system_install, multi_install, machine_state,
                                  operation));
+    if (multi_install)
+      AddChromeBinariesToInstallerState(machine_state, installer_state.get());
     AddChromeToInstallerState(machine_state, installer_state.get());
     return installer_state.release();
   }
 
   static MockInstallerState* BuildChromeFrameInstallerState(
       bool system_install,
       bool multi_install,
       bool ready_mode,
       const InstallationState& machine_state,
       InstallerState::Operation operation) {
+    // This method only works for installation/upgrade.
+    DCHECK(operation != InstallerState::UNINSTALL);
     scoped_ptr<MockInstallerState> installer_state(
         BuildBasicInstallerState(system_install, multi_install, machine_state,
                                  operation));
+    if (multi_install)
+      AddChromeBinariesToInstallerState(machine_state, installer_state.get());
     AddChromeFrameToInstallerState(machine_state, ready_mode,
                                    installer_state.get());
     return installer_state.release();
   }
 
  protected:
   scoped_ptr<Version> current_version_;
   scoped_ptr<Version> new_version_;
   FilePath archive_path_;
   FilePath installation_path_;
@@ skipping 61 matching lines @@
     multi_install_ = std::tr1::get<1>(param);
     root_key_ = system_level_ ? HKEY_LOCAL_MACHINE : HKEY_CURRENT_USER;
 
     installation_state_.reset(new MockInstallationState());
     AddChromeFrameToInstallationState(system_level_, multi_install_, false,
                                       installation_state_.get());
     installer_state_.reset(BuildBasicInstallerState(
         system_level_, multi_install_, *installation_state_,
         multi_install_ ? InstallerState::MULTI_UPDATE :
             InstallerState::SINGLE_INSTALL_OR_UPDATE));
+    if (multi_install_)
+      AddChromeBinariesToInstallerState(*installation_state_,
+                                        installer_state_.get());
     AddChromeFrameToInstallerState(*installation_state_, false,
                                    installer_state_.get());
   }
 
   scoped_ptr<MockInstallationState> installation_state_;
   scoped_ptr<MockInstallerState> installer_state_;
   bool system_level_;
   bool multi_install_;
   HKEY root_key_;
 };
@@ skipping 200 matching lines @@
 
 const wchar_t QuickEnableAbsentTest::kRegKeyPath[] =
     L"Software\\Google\\Update\\Clients\\"
     L"{4DC8B4CA-1BDA-483e-B5FA-D3C12E15B62D}\\Commands\\quick-enable-cf";
 
 TEST_F(QuickEnableAbsentTest, CleanInstallSingleChrome) {
   // Install single Chrome on a clean system.
   scoped_ptr<MockInstallerState> installer_state(
       BuildChromeInstallerState(system_level_, false, *machine_state_,
                                 InstallerState::SINGLE_INSTALL_OR_UPDATE));
-  AddQuickEnableWorkItems(*installer_state, *machine_state_, &setup_path_,
-                          new_version_.get(), &work_item_list_);
+  AddQuickEnableChromeFrameWorkItems(*installer_state,
+                                     *machine_state_,
+                                     &setup_path_,
+                                     new_version_.get(),
+                                     &work_item_list_);
 }
 
 TEST_F(QuickEnableAbsentTest, CleanInstallSingleChromeFrame) {
   // Install single Chrome Frame on a clean system.
   scoped_ptr<MockInstallerState> installer_state(
       BuildChromeFrameInstallerState(system_level_, false, false,
                                      *machine_state_,
                                      InstallerState::SINGLE_INSTALL_OR_UPDATE));
-  AddQuickEnableWorkItems(*installer_state, *machine_state_, &setup_path_,
-                          new_version_.get(), &work_item_list_);
+  AddQuickEnableChromeFrameWorkItems(*installer_state,
+                                     *machine_state_,
+                                     &setup_path_,
+                                     new_version_.get(),
+                                     &work_item_list_);
 }
 
 TEST_F(QuickEnableAbsentTest, CleanInstallMultiChromeFrame) {
   // Install multi Chrome Frame on a clean system.
   scoped_ptr<MockInstallerState> installer_state(
       BuildChromeFrameInstallerState(system_level_, true, false,
                                      *machine_state_,
                                      InstallerState::MULTI_INSTALL));
-  AddQuickEnableWorkItems(*installer_state, *machine_state_, &setup_path_,
-                          new_version_.get(), &work_item_list_);
+  AddQuickEnableChromeFrameWorkItems(*installer_state,
+                                     *machine_state_,
+                                     &setup_path_,
+                                     new_version_.get(),
+                                     &work_item_list_);
 }
 
 TEST_F(QuickEnableAbsentTest, CleanInstallMultiChromeChromeFrame) {
   // Install multi Chrome and Chrome Frame on a clean system.
   scoped_ptr<MockInstallerState> installer_state(
       BuildBasicInstallerState(system_level_, true, *machine_state_,
                                InstallerState::MULTI_INSTALL));
+  AddChromeBinariesToInstallerState(*machine_state_, installer_state.get());
   AddChromeToInstallerState(*machine_state_, installer_state.get());
   AddChromeFrameToInstallerState(*machine_state_, false,
                                  installer_state.get());
-  AddQuickEnableWorkItems(*installer_state, *machine_state_, &setup_path_,
-                          new_version_.get(), &work_item_list_);
+  AddQuickEnableChromeFrameWorkItems(*installer_state,
+                                     *machine_state_,
+                                     &setup_path_,
+                                     new_version_.get(),
+                                     &work_item_list_);
 }
 
 TEST_F(QuickEnableAbsentTest, UninstallMultiChromeLeaveMultiChromeFrame) {
   // Uninstall multi Chrome on a machine with multi Chrome Frame.
   AddChromeToInstallationState(system_level_, true, false,
                                machine_state_.get());
   AddChromeFrameToInstallationState(system_level_, true, false,
                                     machine_state_.get());
   scoped_ptr<MockInstallerState> installer_state(
       BuildBasicInstallerState(system_level_, true, *machine_state_,
                                InstallerState::UNINSTALL));
   AddChromeToInstallerState(*machine_state_, installer_state.get());
-  AddQuickEnableWorkItems(*installer_state, *machine_state_, &setup_path_,
-                          new_version_.get(), &work_item_list_);
+  AddQuickEnableChromeFrameWorkItems(*installer_state,
+                                     *machine_state_,
+                                     &setup_path_,
+                                     new_version_.get(),
+                                     &work_item_list_);
 }
 
 TEST_F(QuickEnableAbsentTest, UninstallMultiChromeLeaveSingleChromeFrame) {
   // Uninstall multi Chrome on a machine with single Chrome Frame.
   AddChromeToInstallationState(system_level_, true, false,
                                machine_state_.get());
   AddChromeFrameToInstallationState(system_level_, false, false,
                                     machine_state_.get());
   scoped_ptr<MockInstallerState> installer_state(
       BuildBasicInstallerState(system_level_, true, *machine_state_,
                                InstallerState::UNINSTALL));
   AddChromeToInstallerState(*machine_state_, installer_state.get());
-  AddQuickEnableWorkItems(*installer_state, *machine_state_, &setup_path_,
-                          new_version_.get(), &work_item_list_);
+  AddChromeBinariesToInstallerState(*machine_state_, installer_state.get());
+  AddQuickEnableChromeFrameWorkItems(*installer_state,
+                                     *machine_state_,
+                                     &setup_path_,
+                                     new_version_.get(),
+                                     &work_item_list_);
 }
 
 TEST_F(QuickEnableAbsentTest, AcceptReadyMode) {
   // Accept ready-mode.
   AddChromeToInstallationState(system_level_, true, true,
                                machine_state_.get());
   AddChromeFrameToInstallationState(system_level_, true, true,
                                     machine_state_.get());
   scoped_ptr<MockInstallerState> installer_state(
       BuildBasicInstallerState(system_level_, true, *machine_state_,
                                InstallerState::UNINSTALL));
   AddChromeToInstallerState(*machine_state_, installer_state.get());
   AddChromeFrameToInstallerState(*machine_state_, false, installer_state.get());
-  AddQuickEnableWorkItems(*installer_state, *machine_state_, &setup_path_,
-                          new_version_.get(), &work_item_list_);
+  AddChromeBinariesToInstallerState(*machine_state_, installer_state.get());
+  AddQuickEnableChromeFrameWorkItems(*installer_state,
+                                     *machine_state_,
+                                     &setup_path_,
+                                     new_version_.get(),
+                                     &work_item_list_);
 }
 
 // Test scenarios under which the quick-enable-cf command should exist after the
 // run.
 class QuickEnablePresentTest : public InstallWorkerTest {
  public:
   virtual void SetUp() {
     InstallWorkerTest::SetUp();
     root_key_ = system_level_ ? HKEY_LOCAL_MACHINE : HKEY_CURRENT_USER;
     create_reg_key_work_item_.reset(
@@ skipping 40 matching lines @@
 
 const wchar_t QuickEnablePresentTest::kRegKeyPath[] =
     L"Software\\Google\\Update\\Clients\\"
     L"{4DC8B4CA-1BDA-483e-B5FA-D3C12E15B62D}\\Commands\\quick-enable-cf";
 
 TEST_F(QuickEnablePresentTest, CleanInstallMultiChrome) {
   // Install multi Chrome on a clean system.
   scoped_ptr<MockInstallerState> installer_state(
       BuildChromeInstallerState(system_level_, true, *machine_state_,
                                 InstallerState::MULTI_INSTALL));
-  AddQuickEnableWorkItems(*installer_state, *machine_state_, &setup_path_,
-                          new_version_.get(), &work_item_list_);
+  AddQuickEnableChromeFrameWorkItems(*installer_state,
+                                     *machine_state_,
+                                     &setup_path_,
+                                     new_version_.get(),
+                                     &work_item_list_);
 }
 
 TEST_F(QuickEnablePresentTest, CleanInstallMultiChromeReadyMode) {
   // Install multi Chrome with Chrome Frame ready-mode on a clean system.
   scoped_ptr<MockInstallerState> installer_state(
       BuildBasicInstallerState(system_level_, true, *machine_state_,
                                InstallerState::MULTI_INSTALL));
+  AddChromeBinariesToInstallerState(*machine_state_, installer_state.get());
   AddChromeToInstallerState(*machine_state_, installer_state.get());
   AddChromeFrameToInstallerState(*machine_state_, true,
                                  installer_state.get());
-  AddQuickEnableWorkItems(*installer_state, *machine_state_, &setup_path_,
-                          new_version_.get(), &work_item_list_);
+  AddQuickEnableChromeFrameWorkItems(*installer_state,
+                                     *machine_state_,
+                                     &setup_path_,
+                                     new_version_.get(),
+                                     &work_item_list_);
 }
 
 TEST_F(QuickEnablePresentTest, UninstallSingleChromeFrame) {
   // Uninstall single Chrome Frame on a machine with multi Chrome.
   AddChromeToInstallationState(system_level_, true, false,
                                machine_state_.get());
   AddChromeFrameToInstallationState(system_level_, false, false,
                                     machine_state_.get());
   scoped_ptr<MockInstallerState> installer_state(
       BuildBasicInstallerState(system_level_, false, *machine_state_,
                                InstallerState::UNINSTALL));
   AddChromeFrameToInstallerState(*machine_state_, false, installer_state.get());
-  AddQuickEnableWorkItems(*installer_state, *machine_state_, &setup_path_,
-                          new_version_.get(), &work_item_list_);
+  AddQuickEnableChromeFrameWorkItems(*installer_state,
+                                     *machine_state_,
+                                     &setup_path_,
+                                     new_version_.get(),
+                                     &work_item_list_);
 }
 
 TEST_F(QuickEnablePresentTest, UninstallMultiChromeFrame) {
   // Uninstall multi Chrome Frame on a machine with multi Chrome.
   AddChromeToInstallationState(system_level_, true, false,
                                machine_state_.get());
   AddChromeFrameToInstallationState(system_level_, true, false,
                                     machine_state_.get());
   scoped_ptr<MockInstallerState> installer_state(
       BuildBasicInstallerState(system_level_, true, *machine_state_,
                                InstallerState::UNINSTALL));
   AddChromeFrameToInstallerState(*machine_state_, false, installer_state.get());
-  AddQuickEnableWorkItems(*installer_state, *machine_state_, &setup_path_,
-                          new_version_.get(), &work_item_list_);
+  AddQuickEnableChromeFrameWorkItems(*installer_state,
+                                     *machine_state_,
+                                     &setup_path_,
+                                     new_version_.get(),
+                                     &work_item_list_);
 }
 
 #endif  // defined(GOOGLE_CHROME_BUILD)