Add product-specific flags to the rename command in the registry. This fixes...

chrome/installer/util/installation_validator.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.
 
 // Implementation of the installation validator.
 
 #include "chrome/installer/util/installation_validator.h"
 
 #include <algorithm>
 
 #include "base/logging.h"
 #include "base/version.h"
 #include "chrome/installer/util/browser_distribution.h"
 #include "chrome/installer/util/helper.h"
 #include "chrome/installer/util/installation_state.h"
 
 namespace installer {
 
 BrowserDistribution::Type
     InstallationValidator::ChromeRules::distribution_type() const {
   return BrowserDistribution::CHROME_BROWSER;
 }
 
-void InstallationValidator::ChromeRules::AddUninstallSwitchExpectations(
+void InstallationValidator::ChromeRules::AddProductSwitchExpectations(
     const InstallationState& machine_state,
     bool system_install,
     const ProductState& product_state,
     SwitchExpectations* expectations) const {
   const bool is_multi_install =
       product_state.uninstall_command().HasSwitch(switches::kMultiInstall);
 
   // --chrome should be present iff --multi-install.
   expectations->push_back(std::make_pair(std::string(switches::kChrome),
                                          is_multi_install));
   // --chrome-frame --ready-mode should be present iff CF in ready mode.
   const ProductState* cf_state =
       machine_state.GetProductState(system_install,
                                     BrowserDistribution::CHROME_FRAME);
   const bool ready_mode =
       cf_state != NULL &&
       cf_state->uninstall_command().HasSwitch(switches::kChromeFrameReadyMode);
   expectations->push_back(std::make_pair(std::string(switches::kChromeFrame),
                                          ready_mode));
   expectations->push_back(
       std::make_pair(std::string(switches::kChromeFrameReadyMode), ready_mode));
 }
 
 BrowserDistribution::Type
     InstallationValidator::ChromeFrameRules::distribution_type() const {
   return BrowserDistribution::CHROME_FRAME;
 }
 
-void InstallationValidator::ChromeFrameRules::AddUninstallSwitchExpectations(
+void InstallationValidator::ChromeFrameRules::AddProductSwitchExpectations(
     const InstallationState& machine_state,
     bool system_install,
     const ProductState& product_state,
     SwitchExpectations* expectations) const {
   // --chrome-frame must be present.
   expectations->push_back(std::make_pair(std::string(switches::kChromeFrame),
                                          true));
   // --chrome must not be present.
   expectations->push_back(std::make_pair(std::string(switches::kChrome),
                                          false));
@@ skipping 157 matching lines @@
   ValidateSetupPath(ctx, command.GetProgram(), "uninstaller", is_valid);
 
   const bool is_multi_install = ctx.state.is_multi_install();
   SwitchExpectations expected;
 
   expected.push_back(std::make_pair(std::string(switches::kUninstall), true));
   expected.push_back(std::make_pair(std::string(switches::kSystemLevel),
                                     ctx.system_install));
   expected.push_back(std::make_pair(std::string(switches::kMultiInstall),
                                     is_multi_install));
-  ctx.rules.AddUninstallSwitchExpectations(ctx.machine_state,
-                                           ctx.system_install,
-                                           ctx.state, &expected);
+  ctx.rules.AddProductSwitchExpectations(ctx.machine_state,
+                                         ctx.system_install,
+                                         ctx.state, &expected);
 
   ValidateCommandExpectations(ctx, command, expected, source, is_valid);
 }
 
 // Validates the rename command for the product described by |ctx|.
 void InstallationValidator::ValidateRenameCommand(const ProductContext& ctx,
                                                   bool* is_valid) {
   DCHECK(is_valid);
   DCHECK(!ctx.state.rename_cmd().empty());
 
   CommandLine command = CommandLine::FromString(ctx.state.rename_cmd());
 
   ValidateSetupPath(ctx, command.GetProgram(), "in-use renamer", is_valid);
 
   SwitchExpectations expected;
 
   expected.push_back(std::make_pair(std::string(switches::kRenameChromeExe),
                                     true));
   expected.push_back(std::make_pair(std::string(switches::kSystemLevel),
                                     ctx.system_install));
   expected.push_back(std::make_pair(std::string(switches::kMultiInstall),
                                     ctx.state.is_multi_install()));
+  ctx.rules.AddProductSwitchExpectations(ctx.machine_state,
+                                         ctx.system_install,
+                                         ctx.state, &expected);
 
   ValidateCommandExpectations(ctx, command, expected, "in-use renamer",
                               is_valid);
 }
 
 // Validates the "opv" and "cmd" values for the product described in |ctx|.
 void InstallationValidator::ValidateOldVersionValues(
     const ProductContext& ctx,
     bool* is_valid) {
   DCHECK(is_valid);
@@ skipping 134 matching lines @@
                                                      InstallationType* type) {
   DCHECK(type);
   InstallationState machine_state;
 
   machine_state.Initialize();
 
   return ValidateInstallationTypeForState(machine_state, system_level, type);
 }
 
 }  // namespace installer