Remove Chrome Frame ready-mode.

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/setup/setup_util.h"
@@ skipping 202 matching lines @@
         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,
       MockInstallationState* installation_state) {
     if (multi_install)
       MaybeAddBinariesToInstallationState(system_level, installation_state);
     MockProductState product_state;
     product_state.set_version(new Version(*current_version_));
     product_state.set_multi_install(multi_install);
     product_state.set_brand(L"TEST");
     product_state.set_eula_accepted(1);
     BrowserDistribution* dist =
         BrowserDistribution::GetSpecificDistribution(
             BrowserDistribution::CHROME_BROWSER);
     base::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);
     if (system_level)
       product_state.AddUninstallSwitch(installer::switches::kSystemLevel);
     if (multi_install) {
       product_state.AddUninstallSwitch(installer::switches::kMultiInstall);
       product_state.AddUninstallSwitch(installer::switches::kChrome);
-      if (with_chrome_frame_ready_mode) {
-        product_state.AddUninstallSwitch(installer::switches::kChromeFrame);
-        product_state.AddUninstallSwitch(
-            installer::switches::kChromeFrameReadyMode);
-      }
     }
 
     installation_state->SetProductState(system_level,
                                         BrowserDistribution::CHROME_BROWSER,
                                         product_state);
   }
 
   void AddChromeFrameToInstallationState(
       bool system_level,
       bool multi_install,
-      bool ready_mode,
       MockInstallationState* installation_state) {
     if (multi_install)
       MaybeAddBinariesToInstallationState(system_level, installation_state);
     MockProductState product_state;
     product_state.set_version(new Version(*current_version_));
     product_state.set_multi_install(multi_install);
     BrowserDistribution* dist =
         BrowserDistribution::GetSpecificDistribution(
             multi_install ? BrowserDistribution::CHROME_BINARIES :
                 BrowserDistribution::CHROME_FRAME);
     base::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::kChromeFrame);
     if (system_level)
       product_state.AddUninstallSwitch(installer::switches::kSystemLevel);
-    if (multi_install) {
+    if (multi_install)
       product_state.AddUninstallSwitch(installer::switches::kMultiInstall);
-      if (ready_mode) {
-        product_state.AddUninstallSwitch(
-            installer::switches::kChromeFrameReadyMode);
-      }
-    }
 
     installation_state->SetProductState(system_level,
                                         BrowserDistribution::CHROME_FRAME,
                                         product_state);
   }
 
   MockInstallationState* BuildChromeInstallationState(bool system_level,
                                                       bool multi_install) {
     scoped_ptr<MockInstallationState> installation_state(
         new MockInstallationState());
-    AddChromeToInstallationState(system_level, multi_install, false,
+    AddChromeToInstallationState(system_level, multi_install,
                                  installation_state.get());
     return installation_state.release();
   }
 
   static MockInstallerState* BuildBasicInstallerState(
       bool system_install,
       bool multi_install,
       const InstallationState& machine_state,
       InstallerState::Operation operation) {
     scoped_ptr<MockInstallerState> installer_state(new MockInstallerState());
@@ skipping 55 matching lines @@
               BrowserDistribution::CHROME_BROWSER);
       scoped_ptr<Product> product(new Product(dist));
       if (installer_state->is_multi_install())
         product->SetOption(installer::kOptionMultiInstall, true);
       installer_state->AddProduct(&product);
     }
   }
 
   static void AddChromeFrameToInstallerState(
       const InstallationState& machine_state,
-      bool ready_mode,
       MockInstallerState* installer_state) {
     // Fresh install or upgrade?
     const ProductState* cf =
         machine_state.GetProductState(installer_state->system_install(),
                                       BrowserDistribution::CHROME_FRAME);
     if (cf != NULL) {
       installer_state->AddProductFromState(BrowserDistribution::CHROME_FRAME,
                                            *cf);
     } else {
       BrowserDistribution* dist =
           BrowserDistribution::GetSpecificDistribution(
               BrowserDistribution::CHROME_FRAME);
       scoped_ptr<Product> product(new Product(dist));
-      if (installer_state->is_multi_install()) {
+      if (installer_state->is_multi_install())
         product->SetOption(installer::kOptionMultiInstall, true);
-        if (ready_mode)
-          product->SetOption(installer::kOptionReadyMode, true);
-      }
       installer_state->AddProduct(&product);
     }
   }
 
   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) {
       // We don't want to include Chrome Binaries for uninstall if the machine
       // has other products. For simplicity, we check Chrome Frame only.
       bool machine_has_other_products =
           machine_state.GetProductState(system_install,
               BrowserDistribution::CHROME_FRAME) != NULL;
       if (operation != InstallerState::UNINSTALL || !machine_has_other_products)
         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());
+    AddChromeFrameToInstallerState(machine_state, installer_state.get());
     return installer_state.release();
   }
 
  protected:
   scoped_ptr<Version> current_version_;
   scoped_ptr<Version> new_version_;
   base::FilePath archive_path_;
   base::FilePath installation_path_;
   base::FilePath setup_path_;
   base::FilePath src_path_;
@@ skipping 53 matching lines @@
  protected:
   virtual void SetUp() OVERRIDE {
     InstallWorkerTest::SetUp();
 
     const ParamType& param = GetParam();
     system_level_ = std::tr1::get<0>(param);
     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,
+    AddChromeFrameToInstallationState(system_level_, multi_install_,
                                       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,
+    AddChromeFrameToInstallerState(*installation_state_,
                                    installer_state_.get());
   }
 
   scoped_ptr<MockInstallationState> installation_state_;
   scoped_ptr<MockInstallerState> installer_state_;
   bool system_level_;
   bool multi_install_;
   HKEY root_key_;
 };
 
@@ skipping 209 matching lines @@
   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_,
+      BuildChromeFrameInstallerState(system_level_, false, *machine_state_,
                                      InstallerState::SINGLE_INSTALL_OR_UPDATE));
   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_,
+      BuildChromeFrameInstallerState(system_level_, true, *machine_state_,
                                      InstallerState::MULTI_INSTALL));
   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());
+  AddChromeFrameToInstallerState(*machine_state_, installer_state.get());
   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());
+  AddChromeToInstallationState(system_level_, true, machine_state_.get());
+  AddChromeFrameToInstallationState(system_level_, true, machine_state_.get());
   scoped_ptr<MockInstallerState> installer_state(
       BuildBasicInstallerState(system_level_, true, *machine_state_,
                                InstallerState::UNINSTALL));
   AddChromeToInstallerState(*machine_state_, installer_state.get());
   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());
+  AddChromeToInstallationState(system_level_, true, machine_state_.get());
+  AddChromeFrameToInstallationState(system_level_, false, machine_state_.get());
   scoped_ptr<MockInstallerState> installer_state(
       BuildBasicInstallerState(system_level_, true, *machine_state_,
                                InstallerState::UNINSTALL));
   AddChromeToInstallerState(*machine_state_, installer_state.get());
   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());
-  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() {
@@ skipping 50 matching lines @@
   scoped_ptr<MockInstallerState> installer_state(
       BuildChromeInstallerState(system_level_, true, *machine_state_,
                                 InstallerState::MULTI_INSTALL));
   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());
-  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());
+  AddChromeToInstallationState(system_level_, true, machine_state_.get());
+  AddChromeFrameToInstallationState(system_level_, false, machine_state_.get());
   scoped_ptr<MockInstallerState> installer_state(
       BuildBasicInstallerState(system_level_, false, *machine_state_,
                                InstallerState::UNINSTALL));
-  AddChromeFrameToInstallerState(*machine_state_, false, installer_state.get());
+  AddChromeFrameToInstallerState(*machine_state_, installer_state.get());
   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());
+  AddChromeToInstallationState(system_level_, true, machine_state_.get());
+  AddChromeFrameToInstallationState(system_level_, true, machine_state_.get());
   scoped_ptr<MockInstallerState> installer_state(
       BuildBasicInstallerState(system_level_, true, *machine_state_,
                                InstallerState::UNINSTALL));
-  AddChromeFrameToInstallerState(*machine_state_, false, installer_state.get());
+  AddChromeFrameToInstallerState(*machine_state_, installer_state.get());
   AddQuickEnableChromeFrameWorkItems(*installer_state,
                                      *machine_state_,
                                      setup_path_,
                                      *new_version_.get(),
                                      &work_item_list_);
 }
 
 TEST_F(InstallWorkerTest, WillProductBePresentAfterSetup) {
   BrowserDistribution::Type prod_type_list[] = {
     BrowserDistribution::CHROME_BROWSER,
@@ skipping 14 matching lines @@
 
   const bool system_level = false;
   const bool multi_install = true;
 
   // Loop over machine states: {No product, Chrome, CF, Chrome + CF}.
   for (int i_mach = 0; i_mach < (1 << NUM_TYPE); ++i_mach) {
     // i_mach is the machine state before operation, as bit mask.
     scoped_ptr<MockInstallationState> machine_state(
         new MockInstallationState());
     if ((i_mach & (1 << TYPE_BROWSER)) != 0) {  // Add Chrome.
-      AddChromeToInstallationState(system_level, multi_install, false,
+      AddChromeToInstallationState(system_level, multi_install,
                                    machine_state.get());
     }
     if ((i_mach & (1 << TYPE_CF)) != 0) {  // Add Chrome Frame.
-      AddChromeFrameToInstallationState(system_level, multi_install, false,
+      AddChromeFrameToInstallationState(system_level, multi_install,
                                         machine_state.get());
     }
 
     // Loop over operations: {uninstall, install/update}.
     for (int i_op = 0; i_op < arraysize(op_list); ++i_op) {
 
       // Loop over product types to operate on: {TYPE_BROWSER, TYPE_CF}.
       for (int i_type_op = 0; i_type_op < NUM_TYPE; ++i_type_op) {
         scoped_ptr<InstallerState> installer_state;
         if (i_type_op == TYPE_BROWSER) {
           installer_state.reset(BuildChromeInstallerState(
               system_level, multi_install, *machine_state, op_list[i_op]));
         } else if (i_type_op == TYPE_CF) {
           // Skip the CF uninstall case due to limitations in
           // BuildChromeFrameInstallerState().
           if (op_list[i_op] == InstallerState::UNINSTALL)
             continue;
 
           installer_state.reset(BuildChromeFrameInstallerState(
-              system_level, multi_install, false, *machine_state,
-              op_list[i_op]));
+              system_level, multi_install, *machine_state, op_list[i_op]));
         } else {
           NOTREACHED();
         }
 
         // Calculate the machine state after operation, as bit mask.
         // If uninstall, remove product with bitwise AND; else add with OR.
         int mach_after = (op_list[i_op] == InstallerState::UNINSTALL) ?
             i_mach & ~(1 << i_type_op) : i_mach | (1 << i_type_op);
 
         // Verify predicted presence of Chrome Binaries.
@@ skipping 14 matching lines @@
               prod_type_list[i_type_check]);
           bool prod_expect = (mach_after & (1 << i_type_check)) != 0;
           EXPECT_EQ(prod_expect, prod_res);
         }
       }
     }
   }
 }
 
 #endif  // defined(GOOGLE_CHROME_BUILD)