Remove Chrome Frame ready-mode.

chrome/installer/util/installation_validator_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 <map>
 
 #include "base/command_line.h"
 #include "base/files/file_path.h"
 #include "base/logging.h"
 #include "base/memory/ref_counted.h"
@@ skipping 36 matching lines @@
 
 enum Vehicle {
   GOOGLE_UPDATE,
   MSI
 };
 
 enum ChannelModifier {
   CM_MULTI        = 0x01,
   CM_CHROME       = 0x02,
   CM_CHROME_FRAME = 0x04,
-  CM_READY_MODE   = 0x08,
-  CM_FULL         = 0x10
+  CM_FULL         = 0x08

[robertshield, 2013/12/11 20:56:49]

is it necessary / a good idea to give CM_FULL a new value, could we leave it as
0x10, possibly renaming CM_READY_MODE to CM_DEPRECATED_DO_NOT_USE?

[grt (UTC plus 2), 2013/12/11 22:13:55]

To my knowledge these values aren't persisted. I think it will look more
confusing to have a gap or a meaningless value there. Perhaps I'm missing
something, though. Do you see a risk/problem here?

[robertshield, 2013/12/11 22:19:14]

Not a concrete one, just more of a general reaction to re-assigning enum values.
I originally misread this file as being not test code, if this value is never
persisted, all is well. Carry on :-)

 };
 
 const wchar_t* const kChromeChannels[] = {
   L"",
   L"1.1-beta",
   L"2.0-dev"
 };
 
 const wchar_t* const kChromeFrameChannels[] = {
   L"",
@@ skipping 68 matching lines @@
     return install_level == USER_LEVEL ? user_products_ : system_products_;
   }
 };
 
 // static
 const FakeProductState::ChannelMethodForModifier
     FakeProductState::kChannelMethods[] = {
   { CM_MULTI,        &ChannelInfo::SetMultiInstall },
   { CM_CHROME,       &ChannelInfo::SetChrome },
   { CM_CHROME_FRAME, &ChannelInfo::SetChromeFrame },
-  { CM_READY_MODE,   &ChannelInfo::SetReadyMode },
   { CM_FULL,         &ChannelInfo::SetFullSuffix }
 };
 
 // static
 base::FilePath FakeProductState::GetSetupPath(
     BrowserDistribution::Type dist_type,
     Level install_level,
     int channel_modifiers) {
   const bool is_multi_install = (channel_modifiers & CM_MULTI) != 0;
   return installer::GetChromeInstallPath(
@@ skipping 39 matching lines @@
   DCHECK(version);
 
   const bool is_multi_install = (channel_modifiers & CM_MULTI) != 0;
   uninstall_command_ = CommandLine(GetSetupExePath(dist_type, install_level,
                                                    version, channel_modifiers));
   uninstall_command_.AppendSwitch(installer::switches::kUninstall);
   if (install_level == SYSTEM_LEVEL)
     uninstall_command_.AppendSwitch(installer::switches::kSystemLevel);
   if (is_multi_install) {
     uninstall_command_.AppendSwitch(installer::switches::kMultiInstall);
-    if (dist_type == BrowserDistribution::CHROME_BROWSER) {
+    if (dist_type == BrowserDistribution::CHROME_BROWSER)
       uninstall_command_.AppendSwitch(installer::switches::kChrome);
-      if ((channel_modifiers & CM_READY_MODE) != 0) {
-        uninstall_command_.AppendSwitch(installer::switches::kChromeFrame);
-        uninstall_command_.AppendSwitch(
-            installer::switches::kChromeFrameReadyMode);
-      }
-    } else if (dist_type == BrowserDistribution::CHROME_FRAME) {
+    else if (dist_type == BrowserDistribution::CHROME_FRAME)
       uninstall_command_.AppendSwitch(installer::switches::kChromeFrame);
-      if ((channel_modifiers & CM_READY_MODE) != 0) {
-        uninstall_command_.AppendSwitch(
-            installer::switches::kChromeFrameReadyMode);
-      }
-    }
   } else if (dist_type == BrowserDistribution::CHROME_FRAME) {
     uninstall_command_.AppendSwitch(installer::switches::kChromeFrame);
   }
   if (vehicle == MSI)
     uninstall_command_.AppendSwitch(installer::switches::kMsi);
 }
 
 // Adds the "install-extension" Google Update product command.
 void FakeProductState::AddInstallExtensionCommand(
     BrowserDistribution::Type dist_type,
@@ skipping 195 matching lines @@
   ttm[InstallationValidator::NO_PRODUCTS] = 0;
   ttm[InstallationValidator::CHROME_SINGLE] = 0;
   ttm[InstallationValidator::CHROME_MULTI] = CM_MULTI | CM_CHROME;
   ttm[InstallationValidator::CHROME_FRAME_SINGLE] = 0;
   ttm[InstallationValidator::CHROME_FRAME_SINGLE_CHROME_SINGLE] = 0;
   ttm[InstallationValidator::CHROME_FRAME_SINGLE_CHROME_MULTI] =
       CM_MULTI | CM_CHROME;
   ttm[InstallationValidator::CHROME_FRAME_MULTI] = CM_MULTI | CM_CHROME_FRAME;
   ttm[InstallationValidator::CHROME_FRAME_MULTI_CHROME_MULTI] =
       CM_MULTI | CM_CHROME_FRAME | CM_CHROME;
-  ttm[InstallationValidator::CHROME_FRAME_READY_MODE_CHROME_MULTI] =
-      CM_MULTI | CM_CHROME_FRAME | CM_CHROME | CM_READY_MODE;
 }
 
 // static
 void InstallationValidatorTest::TearDownTestCase() {
   logging::SetLogMessageHandler(old_log_message_handler_);
   old_log_message_handler_ = NULL;
 
   delete type_to_modifiers_;
   type_to_modifiers_ = NULL;
 }
@@ skipping 29 matching lines @@
 
 // static
 void InstallationValidatorTest::set_validation_error_recipient(
     ValidationErrorRecipient* recipient) {
   validation_error_recipient_ = recipient;
 }
 
 // static
 // Populates |state| with the state of a valid installation of product
 // |prod_type|.  |inst_type| dictates properties of the installation
-// (multi-install, ready-mode, etc).
+// (multi-install, etc).
 void InstallationValidatorTest::MakeProductState(
     BrowserDistribution::Type prod_type,
     InstallationValidator::InstallationType inst_type,
     Level install_level,
     Channel channel,
     Vehicle vehicle,
     FakeProductState* state) {
   DCHECK(state);
 
   const bool is_multi_install =
       prod_type == BrowserDistribution::CHROME_BINARIES ||
       (prod_type == BrowserDistribution::CHROME_BROWSER &&
        (inst_type & InstallationValidator::ProductBits::CHROME_MULTI) != 0) ||
       (prod_type == BrowserDistribution::CHROME_FRAME &&
        (inst_type &
-           (InstallationValidator::ProductBits::CHROME_FRAME_MULTI |
-            InstallationValidator::ProductBits::CHROME_FRAME_READY_MODE)) != 0);
+           InstallationValidator::ProductBits::CHROME_FRAME_MULTI) != 0);
 
   const wchar_t* const* channels = &kChromeChannels[0];
   if (prod_type == BrowserDistribution::CHROME_FRAME && !is_multi_install)
     channels = &kChromeFrameChannels[0];  // SxS GCF has its own channel names.
   const int channel_modifiers =
       is_multi_install ? GetChannelModifiers(inst_type) : 0;
 
   state->Clear();
   state->SetChannel(channels[channel], channel_modifiers);
   state->SetVersion(chrome::kChromeVersion);
   state->SetUninstallCommand(prod_type, install_level, chrome::kChromeVersion,
                              channel_modifiers, vehicle);
   state->set_multi_install(is_multi_install);
   if (prod_type == BrowserDistribution::CHROME_BINARIES) {
-    if (inst_type == InstallationValidator::CHROME_MULTI ||
-         inst_type ==
-             InstallationValidator::CHROME_FRAME_READY_MODE_CHROME_MULTI) {
+    if (inst_type == InstallationValidator::CHROME_MULTI) {
       state->AddQuickEnableCfCommand(prod_type, install_level,
                                      chrome::kChromeVersion, channel_modifiers);
     }
     state->AddQueryEULAAcceptanceCommand(prod_type,
                                          install_level,
                                          chrome::kChromeVersion,
                                          channel_modifiers);
   }
   if (prod_type == BrowserDistribution::CHROME_BINARIES) {
     state->AddQuickEnableApplicationHostCommand(prod_type,
@@ skipping 21 matching lines @@
     Channel channel,
     Vehicle vehicle,
     FakeInstallationState* state) {
   DCHECK(state);
 
   static const int kChromeMask =
       (InstallationValidator::ProductBits::CHROME_SINGLE |
        InstallationValidator::ProductBits::CHROME_MULTI);
   static const int kChromeFrameMask =
       (InstallationValidator::ProductBits::CHROME_FRAME_SINGLE |
-       InstallationValidator::ProductBits::CHROME_FRAME_MULTI |
-       InstallationValidator::ProductBits::CHROME_FRAME_READY_MODE);
+       InstallationValidator::ProductBits::CHROME_FRAME_MULTI);
   static const int kBinariesMask =
       (InstallationValidator::ProductBits::CHROME_MULTI |
-       InstallationValidator::ProductBits::CHROME_FRAME_MULTI |
-       InstallationValidator::ProductBits::CHROME_FRAME_READY_MODE);
+       InstallationValidator::ProductBits::CHROME_FRAME_MULTI);
 
   FakeProductState prod_state;
 
   if ((inst_type & kChromeMask) != 0) {
     MakeProductState(BrowserDistribution::CHROME_BROWSER, inst_type,
                      install_level, channel, vehicle, &prod_state);
     state->SetProductState(BrowserDistribution::CHROME_BROWSER, install_level,
                            prod_state);
   }
 
@@ skipping 36 matching lines @@
 INSTANTIATE_TEST_CASE_P(
     AllValidInstallations,
     InstallationValidatorTest,
     Values(InstallationValidator::NO_PRODUCTS,
            InstallationValidator::CHROME_SINGLE,
            InstallationValidator::CHROME_MULTI,
            InstallationValidator::CHROME_FRAME_SINGLE,
            InstallationValidator::CHROME_FRAME_SINGLE_CHROME_SINGLE,
            InstallationValidator::CHROME_FRAME_SINGLE_CHROME_MULTI,
            InstallationValidator::CHROME_FRAME_MULTI,
-           InstallationValidator::CHROME_FRAME_MULTI_CHROME_MULTI,
-           InstallationValidator::CHROME_FRAME_READY_MODE_CHROME_MULTI));
+           InstallationValidator::CHROME_FRAME_MULTI_CHROME_MULTI));