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