src/chrome/installer/util/installation_validator_unittest.cc

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include <map>
   6
   7 #include "base/command_line.h"
   8 #include "base/files/file_path.h"
   9 #include "base/logging.h"
  10 #include "base/memory/ref_counted.h"
  11 #include "base/version.h"
  12 #include "chrome/common/chrome_constants.h"
  13 #include "chrome/common/chrome_switches.h"
  14 #include "chrome/installer/util/channel_info.h"
  15 #include "chrome/installer/util/helper.h"
  16 #include "chrome/installer/util/installation_state.h"
  17 #include "chrome/installer/util/installation_validator.h"
  18 #include "testing/gmock/include/gmock/gmock.h"
  19 #include "testing/gtest/include/gtest/gtest.h"
  20
  21 using installer::ChannelInfo;
  22 using installer::InstallationValidator;
  23 using installer::InstallationState;
  24 using installer::AppCommand;
  25 using installer::ProductState;
  26 using testing::_;
  27 using testing::StrictMock;
  28 using testing::Values;
  29
  30 namespace {
  31
  32 enum Channel {
  33   STABLE_CHANNEL,
  34   BETA_CHANNEL,
  35   DEV_CHANNEL
  36 };
  37
  38 enum PackageType {
  39   SINGLE_INSTALL,
  40   MULTI_INSTALL
  41 };
  42
  43 enum Level {
  44   USER_LEVEL,
  45   SYSTEM_LEVEL
  46 };
  47
  48 enum Vehicle {
  49   GOOGLE_UPDATE,
  50   MSI
  51 };
  52
  53 enum ChannelModifier {
  54   CM_MULTI        = 0x01,
  55   CM_CHROME       = 0x02,
  56   CM_CHROME_FRAME = 0x04,
  57   CM_READY_MODE   = 0x08,
  58   CM_FULL         = 0x10
  59 };
  60
  61 const wchar_t* const kChromeChannels[] = {
  62   L"",
  63   L"1.1-beta",
  64   L"2.0-dev"
  65 };
  66
  67 const wchar_t* const kChromeFrameChannels[] = {
  68   L"",
  69   L"beta",
  70   L"dev"
  71 };
  72
  73 class FakeProductState : public ProductState {
  74  public:
  75   void SetChannel(const wchar_t* base, int channel_modifiers);
  76   void SetVersion(const char* version);
  77   void SetUninstallCommand(BrowserDistribution::Type dist_type,
  78                            Level install_level,
  79                            const char* version,
  80                            int channel_modifiers,
  81                            Vehicle vehicle);
  82   void AddInstallExtensionCommand(BrowserDistribution::Type dist_type,
  83                                   Level install_level,
  84                                   const char* version,
  85                                   int channel_modifiers);
  86   void AddOsUpgradeCommand(BrowserDistribution::Type dist_type,
  87                            Level install_level,
  88                            const char* version,
  89                            int channel_modifiers);
  90   void AddQueryEULAAcceptanceCommand(BrowserDistribution::Type dist_type,
  91                                      Level install_level,
  92                                      const char* version,
  93                                      int channel_modifiers);
  94   void AddQuickEnableApplicationHostCommand(BrowserDistribution::Type dist_type,
  95                                             Level install_level,
  96                                             const char* version,
  97                                             int channel_modifiers);
  98   void AddQuickEnableCfCommand(BrowserDistribution::Type dist_type,
  99                                Level install_level,
 100                                const char* version,
 101                                int channel_modifiers);
 102   void set_multi_install(bool is_multi_install) {
 103     multi_install_ = is_multi_install;
 104   }
 105   installer::AppCommands& commands() { return commands_; }
 106
 107  protected:
 108   struct ChannelMethodForModifier {
 109     ChannelModifier modifier;
 110     bool (ChannelInfo::*method)(bool value);
 111   };
 112
 113   static base::FilePath GetSetupPath(
 114       BrowserDistribution::Type dist_type,
 115       Level install_level,
 116       int channel_modifiers);
 117
 118   static base::FilePath GetSetupExePath(
 119       BrowserDistribution::Type dist_type,
 120       Level install_level,
 121       const char* version,
 122       int channel_modifiers);
 123
 124   static const ChannelMethodForModifier kChannelMethods[];
 125 };
 126
 127 class FakeInstallationState : public InstallationState {
 128  public:
 129   void SetProductState(BrowserDistribution::Type type,
 130                        Level install_level,
 131                        const ProductState& product) {
 132     GetProducts(install_level)[IndexFromDistType(type)].CopyFrom(product);
 133   }
 134
 135  protected:
 136   ProductState* GetProducts(Level install_level) {
 137     return install_level == USER_LEVEL ? user_products_ : system_products_;
 138   }
 139 };
 140
 141 // static
 142 const FakeProductState::ChannelMethodForModifier
 143     FakeProductState::kChannelMethods[] = {
 144   { CM_MULTI,        &ChannelInfo::SetMultiInstall },
 145   { CM_CHROME,       &ChannelInfo::SetChrome },
 146   { CM_CHROME_FRAME, &ChannelInfo::SetChromeFrame },
 147   { CM_READY_MODE,   &ChannelInfo::SetReadyMode },
 148   { CM_FULL,         &ChannelInfo::SetFullSuffix }
 149 };
 150
 151 // static
 152 base::FilePath FakeProductState::GetSetupPath(
 153     BrowserDistribution::Type dist_type,
 154     Level install_level,
 155     int channel_modifiers) {
 156   const bool is_multi_install = (channel_modifiers & CM_MULTI) != 0;
 157   return installer::GetChromeInstallPath(
 158       install_level == SYSTEM_LEVEL,
 159       BrowserDistribution::GetSpecificDistribution(is_multi_install ?
 160               BrowserDistribution::CHROME_BINARIES : dist_type));
 161 }
 162
 163 // static
 164 base::FilePath FakeProductState::GetSetupExePath(
 165     BrowserDistribution::Type dist_type,
 166     Level install_level,
 167     const char* version,
 168     int channel_modifiers) {
 169   base::FilePath setup_path = GetSetupPath(dist_type, install_level,
 170                                            channel_modifiers);
 171   return setup_path
 172       .AppendASCII(version)
 173       .Append(installer::kInstallerDir)
 174       .Append(installer::kSetupExe);
 175 }
 176
 177 // Sets the channel_ member of this instance according to a base channel value
 178 // and a set of modifiers.
 179 void FakeProductState::SetChannel(const wchar_t* base, int channel_modifiers) {
 180   channel_.set_value(base);
 181   for (size_t i = 0; i < arraysize(kChannelMethods); ++i) {
 182     if ((channel_modifiers & kChannelMethods[i].modifier) != 0)
 183       (channel_.*kChannelMethods[i].method)(true);
 184   }
 185 }
 186
 187 void FakeProductState::SetVersion(const char* version) {
 188   version_.reset(version == NULL ? NULL : new Version(version));
 189 }
 190
 191 // Sets the uninstall command for this object.
 192 void FakeProductState::SetUninstallCommand(BrowserDistribution::Type dist_type,
 193                                            Level install_level,
 194                                            const char* version,
 195                                            int channel_modifiers,
 196                                            Vehicle vehicle) {
 197   DCHECK(version);
 198
 199   const bool is_multi_install = (channel_modifiers & CM_MULTI) != 0;
 200   uninstall_command_ = CommandLine(GetSetupExePath(dist_type, install_level,
 201                                                    version, channel_modifiers));
 202   uninstall_command_.AppendSwitch(installer::switches::kUninstall);
 203   if (install_level == SYSTEM_LEVEL)
 204     uninstall_command_.AppendSwitch(installer::switches::kSystemLevel);
 205   if (is_multi_install) {
 206     uninstall_command_.AppendSwitch(installer::switches::kMultiInstall);
 207     if (dist_type == BrowserDistribution::CHROME_BROWSER) {
 208       uninstall_command_.AppendSwitch(installer::switches::kChrome);
 209       if ((channel_modifiers & CM_READY_MODE) != 0) {
 210         uninstall_command_.AppendSwitch(installer::switches::kChromeFrame);
 211         uninstall_command_.AppendSwitch(
 212             installer::switches::kChromeFrameReadyMode);
 213       }
 214     } else if (dist_type == BrowserDistribution::CHROME_FRAME) {
 215       uninstall_command_.AppendSwitch(installer::switches::kChromeFrame);
 216       if ((channel_modifiers & CM_READY_MODE) != 0) {
 217         uninstall_command_.AppendSwitch(
 218             installer::switches::kChromeFrameReadyMode);
 219       }
 220     }
 221   } else if (dist_type == BrowserDistribution::CHROME_FRAME) {
 222     uninstall_command_.AppendSwitch(installer::switches::kChromeFrame);
 223   }
 224   if (vehicle == MSI)
 225     uninstall_command_.AppendSwitch(installer::switches::kMsi);
 226 }
 227
 228 // Adds the "install-extension" Google Update product command.
 229 void FakeProductState::AddInstallExtensionCommand(
 230     BrowserDistribution::Type dist_type,
 231     Level install_level,
 232     const char* version,
 233     int channel_modifiers) {
 234   // Right now only Chrome browser uses this.
 235   DCHECK_EQ(dist_type, BrowserDistribution::CHROME_BROWSER);
 236
 237   CommandLine cmd_line(GetSetupPath(dist_type, install_level,
 238                                     channel_modifiers).
 239                            Append(installer::kChromeExe));
 240   cmd_line.AppendSwitchASCII(::switches::kLimitedInstallFromWebstore, "%1");
 241   AppCommand app_cmd(cmd_line.GetCommandLineString());
 242   app_cmd.set_sends_pings(true);
 243   app_cmd.set_is_web_accessible(true);
 244   app_cmd.set_is_run_as_user(true);
 245   commands_.Set(installer::kCmdInstallExtension, app_cmd);
 246 }
 247
 248 // Adds the "on-os-upgrade" Google Update product command.
 249 void FakeProductState::AddOsUpgradeCommand(BrowserDistribution::Type dist_type,
 250                                            Level install_level,
 251                                            const char* version,
 252                                            int channel_modifiers) {
 253   // Right now only Chrome browser uses this.
 254   DCHECK_EQ(dist_type, BrowserDistribution::CHROME_BROWSER);
 255
 256   CommandLine cmd_line(GetSetupExePath(dist_type, install_level, version,
 257                                        channel_modifiers));
 258   cmd_line.AppendSwitch(installer::switches::kOnOsUpgrade);
 259   // Imitating ChromeBrowserOperations::AppendProductFlags().
 260   if ((channel_modifiers & CM_MULTI) != 0) {
 261     cmd_line.AppendSwitch(installer::switches::kMultiInstall);
 262     cmd_line.AppendSwitch(installer::switches::kChrome);
 263   }
 264   if (install_level == SYSTEM_LEVEL)
 265     cmd_line.AppendSwitch(installer::switches::kSystemLevel);
 266   cmd_line.AppendSwitch(installer::switches::kVerboseLogging);
 267   AppCommand app_cmd(cmd_line.GetCommandLineString());
 268   app_cmd.set_is_auto_run_on_os_upgrade(true);
 269   commands_.Set(installer::kCmdOnOsUpgrade, app_cmd);
 270 }
 271
 272 // Adds the "query-eula-acceptance" Google Update product command.
 273 void FakeProductState::AddQueryEULAAcceptanceCommand(
 274     BrowserDistribution::Type dist_type,
 275     Level install_level,
 276     const char* version,
 277     int channel_modifiers) {
 278   DCHECK_EQ(dist_type, BrowserDistribution::CHROME_BINARIES);
 279
 280   CommandLine cmd_line(GetSetupExePath(dist_type, install_level, version,
 281                                        channel_modifiers));
 282   cmd_line.AppendSwitch(installer::switches::kQueryEULAAcceptance);
 283   if (install_level == SYSTEM_LEVEL)
 284     cmd_line.AppendSwitch(installer::switches::kSystemLevel);
 285   cmd_line.AppendSwitch(installer::switches::kVerboseLogging);
 286   AppCommand app_cmd(cmd_line.GetCommandLineString());
 287   app_cmd.set_is_web_accessible(true);
 288   app_cmd.set_is_run_as_user(true);
 289   commands_.Set(installer::kCmdQueryEULAAcceptance, app_cmd);
 290 }
 291
 292 // Adds the "quick-enable-application-host" Google Update product command.
 293 void FakeProductState::AddQuickEnableApplicationHostCommand(
 294     BrowserDistribution::Type dist_type,
 295     Level install_level,
 296     const char* version,
 297     int channel_modifiers) {
 298   DCHECK_EQ(dist_type, BrowserDistribution::CHROME_BINARIES);
 299   DCHECK_NE(channel_modifiers & CM_MULTI, 0);
 300
 301   CommandLine cmd_line(GetSetupExePath(dist_type, install_level, version,
 302                                        channel_modifiers));
 303   cmd_line.AppendSwitch(installer::switches::kMultiInstall);
 304   cmd_line.AppendSwitch(installer::switches::kChromeAppLauncher);
 305   cmd_line.AppendSwitch(installer::switches::kEnsureGoogleUpdatePresent);
 306   AppCommand app_cmd(cmd_line.GetCommandLineString());
 307   app_cmd.set_sends_pings(true);
 308   app_cmd.set_is_web_accessible(true);
 309   app_cmd.set_is_run_as_user(true);
 310   commands_.Set(installer::kCmdQuickEnableApplicationHost, app_cmd);
 311 }
 312
 313 // Adds the "quick-enable-cf" Google Update product command.
 314 void FakeProductState::AddQuickEnableCfCommand(
 315     BrowserDistribution::Type dist_type,
 316     Level install_level,
 317     const char* version,
 318     int channel_modifiers) {
 319   DCHECK_EQ(dist_type, BrowserDistribution::CHROME_BINARIES);
 320   DCHECK_NE(channel_modifiers & CM_MULTI, 0);
 321
 322   CommandLine cmd_line(GetSetupExePath(dist_type, install_level, version,
 323                                        channel_modifiers));
 324   cmd_line.AppendSwitch(installer::switches::kMultiInstall);
 325   if (install_level == SYSTEM_LEVEL)
 326     cmd_line.AppendSwitch(installer::switches::kSystemLevel);
 327   cmd_line.AppendSwitch(installer::switches::kChromeFrameQuickEnable);
 328   AppCommand app_cmd(cmd_line.GetCommandLineString());
 329   app_cmd.set_sends_pings(true);
 330   app_cmd.set_is_web_accessible(true);
 331   commands_.Set(installer::kCmdQuickEnableCf, app_cmd);
 332 }
 333
 334 }  // namespace
 335
 336 // Fixture for testing the InstallationValidator.  Errors logged by the
 337 // validator are sent to an optional mock recipient (see
 338 // set_validation_error_recipient) upon which expectations can be placed.
 339 class InstallationValidatorTest
 340     : public testing::TestWithParam<InstallationValidator::InstallationType> {
 341  public:
 342
 343   // These shouldn't need to be public, but there seems to be some interaction
 344   // with parameterized tests that requires it.
 345   static void SetUpTestCase();
 346   static void TearDownTestCase();
 347
 348   // Returns the multi channel modifiers for a given installation type.
 349   static int GetChannelModifiers(InstallationValidator::InstallationType type);
 350
 351  protected:
 352   typedef std::map<InstallationValidator::InstallationType, int>
 353       InstallationTypeToModifiers;
 354
 355   class ValidationErrorRecipient {
 356    public:
 357     virtual ~ValidationErrorRecipient() { }
 358     virtual void ReceiveValidationError(const char* file,
 359                                         int line,
 360                                         const char* message) = 0;
 361   };
 362   class MockValidationErrorRecipient : public ValidationErrorRecipient {
 363    public:
 364     MOCK_METHOD3(ReceiveValidationError, void(const char* file,
 365                                               int line,
 366                                               const char* message));
 367   };
 368
 369  protected:
 370   static bool HandleLogMessage(int severity,
 371                                const char* file,
 372                                int line,
 373                                size_t message_start,
 374                                const std::string& str);
 375   static void set_validation_error_recipient(
 376       ValidationErrorRecipient* recipient);
 377   static void MakeProductState(
 378       BrowserDistribution::Type prod_type,
 379       InstallationValidator::InstallationType inst_type,
 380       Level install_level,
 381       Channel channel,
 382       Vehicle vehicle,
 383       FakeProductState* state);
 384   static void MakeMachineState(
 385       InstallationValidator::InstallationType inst_type,
 386       Level install_level,
 387       Channel channel,
 388       Vehicle vehicle,
 389       FakeInstallationState* state);
 390   virtual void TearDown();
 391
 392   static logging::LogMessageHandlerFunction old_log_message_handler_;
 393   static ValidationErrorRecipient* validation_error_recipient_;
 394   static InstallationTypeToModifiers* type_to_modifiers_;
 395 };
 396
 397 // static
 398 logging::LogMessageHandlerFunction
 399     InstallationValidatorTest::old_log_message_handler_ = NULL;
 400
 401 // static
 402 InstallationValidatorTest::ValidationErrorRecipient*
 403     InstallationValidatorTest::validation_error_recipient_ = NULL;
 404
 405 // static
 406 InstallationValidatorTest::InstallationTypeToModifiers*
 407     InstallationValidatorTest::type_to_modifiers_ = NULL;
 408
 409 // static
 410 int InstallationValidatorTest::GetChannelModifiers(
 411     InstallationValidator::InstallationType type) {
 412   DCHECK(type_to_modifiers_);
 413   DCHECK(type_to_modifiers_->find(type) != type_to_modifiers_->end());
 414
 415   return (*type_to_modifiers_)[type];
 416 }
 417
 418 // static
 419 void InstallationValidatorTest::SetUpTestCase() {
 420   DCHECK(type_to_modifiers_ == NULL);
 421   old_log_message_handler_ = logging::GetLogMessageHandler();
 422   logging::SetLogMessageHandler(&HandleLogMessage);
 423
 424   type_to_modifiers_ = new InstallationTypeToModifiers();
 425   InstallationTypeToModifiers& ttm = *type_to_modifiers_;
 426   ttm[InstallationValidator::NO_PRODUCTS] = 0;
 427   ttm[InstallationValidator::CHROME_SINGLE] = 0;
 428   ttm[InstallationValidator::CHROME_MULTI] = CM_MULTI | CM_CHROME;
 429   ttm[InstallationValidator::CHROME_FRAME_SINGLE] = 0;
 430   ttm[InstallationValidator::CHROME_FRAME_SINGLE_CHROME_SINGLE] = 0;
 431   ttm[InstallationValidator::CHROME_FRAME_SINGLE_CHROME_MULTI] =
 432       CM_MULTI | CM_CHROME;
 433   ttm[InstallationValidator::CHROME_FRAME_MULTI] = CM_MULTI | CM_CHROME_FRAME;
 434   ttm[InstallationValidator::CHROME_FRAME_MULTI_CHROME_MULTI] =
 435       CM_MULTI | CM_CHROME_FRAME | CM_CHROME;
 436   ttm[InstallationValidator::CHROME_FRAME_READY_MODE_CHROME_MULTI] =
 437       CM_MULTI | CM_CHROME_FRAME | CM_CHROME | CM_READY_MODE;
 438 }
 439
 440 // static
 441 void InstallationValidatorTest::TearDownTestCase() {
 442   logging::SetLogMessageHandler(old_log_message_handler_);
 443   old_log_message_handler_ = NULL;
 444
 445   delete type_to_modifiers_;
 446   type_to_modifiers_ = NULL;
 447 }
 448
 449 // static
 450 bool InstallationValidatorTest::HandleLogMessage(int severity,
 451                                                  const char* file,
 452                                                  int line,
 453                                                  size_t message_start,
 454                                                  const std::string& str) {
 455   // All validation failures result in LOG(ERROR)
 456   if (severity == logging::LOG_ERROR && !str.empty()) {
 457     // Remove the trailing newline, if present.
 458     size_t message_length = str.size() - message_start;
 459     if (*str.rbegin() == '\n')
 460       --message_length;
 461     if (validation_error_recipient_ != NULL) {
 462       validation_error_recipient_->ReceiveValidationError(
 463           file, line, str.substr(message_start, message_length).c_str());
 464     } else {
 465       // Fail the test if an error wasn't handled.
 466       ADD_FAILURE_AT(file, line)
 467           << base::StringPiece(str.c_str() + message_start, message_length);
 468     }
 469     return true;
 470   }
 471
 472   if (old_log_message_handler_ != NULL)
 473     return (old_log_message_handler_)(severity, file, line, message_start, str);
 474
 475   return false;
 476 }
 477
 478 // static
 479 void InstallationValidatorTest::set_validation_error_recipient(
 480     ValidationErrorRecipient* recipient) {
 481   validation_error_recipient_ = recipient;
 482 }
 483
 484 // static
 485 // Populates |state| with the state of a valid installation of product
 486 // |prod_type|.  |inst_type| dictates properties of the installation
 487 // (multi-install, ready-mode, etc).
 488 void InstallationValidatorTest::MakeProductState(
 489     BrowserDistribution::Type prod_type,
 490     InstallationValidator::InstallationType inst_type,
 491     Level install_level,
 492     Channel channel,
 493     Vehicle vehicle,
 494     FakeProductState* state) {
 495   DCHECK(state);
 496
 497   const bool is_multi_install =
 498       prod_type == BrowserDistribution::CHROME_BINARIES ||
 499       (prod_type == BrowserDistribution::CHROME_BROWSER &&
 500        (inst_type & InstallationValidator::ProductBits::CHROME_MULTI) != 0) ||
 501       (prod_type == BrowserDistribution::CHROME_FRAME &&
 502        (inst_type &
 503            (InstallationValidator::ProductBits::CHROME_FRAME_MULTI |
 504             InstallationValidator::ProductBits::CHROME_FRAME_READY_MODE)) != 0);
 505
 506   const wchar_t* const* channels = &kChromeChannels[0];
 507   if (prod_type == BrowserDistribution::CHROME_FRAME && !is_multi_install)
 508     channels = &kChromeFrameChannels[0];  // SxS GCF has its own channel names.
 509   const int channel_modifiers =
 510       is_multi_install ? GetChannelModifiers(inst_type) : 0;
 511
 512   state->Clear();
 513   state->SetChannel(channels[channel], channel_modifiers);
 514   state->SetVersion(chrome::kChromeVersion);
 515   state->SetUninstallCommand(prod_type, install_level, chrome::kChromeVersion,
 516                              channel_modifiers, vehicle);
 517   state->set_multi_install(is_multi_install);
 518   if (prod_type == BrowserDistribution::CHROME_BINARIES) {
 519     if (inst_type == InstallationValidator::CHROME_MULTI ||
 520          inst_type ==
 521              InstallationValidator::CHROME_FRAME_READY_MODE_CHROME_MULTI) {
 522       state->AddQuickEnableCfCommand(prod_type, install_level,
 523                                      chrome::kChromeVersion, channel_modifiers);
 524     }
 525     state->AddQueryEULAAcceptanceCommand(prod_type,
 526                                          install_level,
 527                                          chrome::kChromeVersion,
 528                                          channel_modifiers);
 529   }
 530   if (prod_type == BrowserDistribution::CHROME_BINARIES) {
 531     state->AddQuickEnableApplicationHostCommand(prod_type,
 532                                                 install_level,
 533                                                 chrome::kChromeVersion,
 534                                                 channel_modifiers);
 535   }
 536   if (prod_type == BrowserDistribution::CHROME_BROWSER) {
 537     state->AddOsUpgradeCommand(prod_type,
 538                                install_level,
 539                                chrome::kChromeVersion,
 540                                channel_modifiers);
 541     state->AddInstallExtensionCommand(prod_type,
 542                                       install_level,
 543                                       chrome::kChromeVersion,
 544                                       channel_modifiers);
 545   }
 546 }
 547
 548 // static
 549 // Populates |state| with the state of a valid installation of |inst_type|.
 550 void InstallationValidatorTest::MakeMachineState(
 551     InstallationValidator::InstallationType inst_type,
 552     Level install_level,
 553     Channel channel,
 554     Vehicle vehicle,
 555     FakeInstallationState* state) {
 556   DCHECK(state);
 557
 558   static const int kChromeMask =
 559       (InstallationValidator::ProductBits::CHROME_SINGLE |
 560        InstallationValidator::ProductBits::CHROME_MULTI);
 561   static const int kChromeFrameMask =
 562       (InstallationValidator::ProductBits::CHROME_FRAME_SINGLE |
 563        InstallationValidator::ProductBits::CHROME_FRAME_MULTI |
 564        InstallationValidator::ProductBits::CHROME_FRAME_READY_MODE);
 565   static const int kBinariesMask =
 566       (InstallationValidator::ProductBits::CHROME_MULTI |
 567        InstallationValidator::ProductBits::CHROME_FRAME_MULTI |
 568        InstallationValidator::ProductBits::CHROME_FRAME_READY_MODE);
 569
 570   FakeProductState prod_state;
 571
 572   if ((inst_type & kChromeMask) != 0) {
 573     MakeProductState(BrowserDistribution::CHROME_BROWSER, inst_type,
 574                      install_level, channel, vehicle, &prod_state);
 575     state->SetProductState(BrowserDistribution::CHROME_BROWSER, install_level,
 576                            prod_state);
 577   }
 578
 579   if ((inst_type & kChromeFrameMask) != 0) {
 580     MakeProductState(BrowserDistribution::CHROME_FRAME, inst_type,
 581                      install_level, channel, vehicle, &prod_state);
 582     state->SetProductState(BrowserDistribution::CHROME_FRAME, install_level,
 583                            prod_state);
 584   }
 585
 586   if ((inst_type & kBinariesMask) != 0) {
 587     MakeProductState(BrowserDistribution::CHROME_BINARIES, inst_type,
 588                      install_level, channel, vehicle, &prod_state);
 589     state->SetProductState(BrowserDistribution::CHROME_BINARIES, install_level,
 590                            prod_state);
 591   }
 592 }
 593
 594 void InstallationValidatorTest::TearDown() {
 595   validation_error_recipient_ = NULL;
 596 }
 597
 598 // Builds a proper machine state for a given InstallationType, then validates
 599 // it.
 600 TEST_P(InstallationValidatorTest, TestValidInstallation) {
 601   const InstallationValidator::InstallationType inst_type = GetParam();
 602   FakeInstallationState machine_state;
 603   InstallationValidator::InstallationType type;
 604   StrictMock<MockValidationErrorRecipient> recipient;
 605   set_validation_error_recipient(&recipient);
 606
 607   MakeMachineState(inst_type, SYSTEM_LEVEL, STABLE_CHANNEL, GOOGLE_UPDATE,
 608                    &machine_state);
 609   EXPECT_TRUE(InstallationValidator::ValidateInstallationTypeForState(
 610                   machine_state, true, &type));
 611   EXPECT_EQ(inst_type, type);
 612 }
 613
 614 // Run the test for all installation types.
 615 INSTANTIATE_TEST_CASE_P(
 616     AllValidInstallations,
 617     InstallationValidatorTest,
 618     Values(InstallationValidator::NO_PRODUCTS,
 619            InstallationValidator::CHROME_SINGLE,
 620            InstallationValidator::CHROME_MULTI,
 621            InstallationValidator::CHROME_FRAME_SINGLE,
 622            InstallationValidator::CHROME_FRAME_SINGLE_CHROME_SINGLE,
 623            InstallationValidator::CHROME_FRAME_SINGLE_CHROME_MULTI,
 624            InstallationValidator::CHROME_FRAME_MULTI,
 625            InstallationValidator::CHROME_FRAME_MULTI_CHROME_MULTI,
 626            InstallationValidator::CHROME_FRAME_READY_MODE_CHROME_MULTI));