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 "chrome/installer/setup/install_worker.h" 6 7 #include "base/win/registry.h" 8 #include "base/version.h" 9 #include "chrome/common/chrome_constants.h" 10 #include "chrome/installer/setup/setup_util.h" 11 #include "chrome/installer/util/delete_reg_key_work_item.h" 12 #include "chrome/installer/util/create_reg_key_work_item.h" 13 #include "chrome/installer/util/helper.h" 14 #include "chrome/installer/util/google_update_constants.h" 15 #include "chrome/installer/util/installation_state.h" 16 #include "chrome/installer/util/installer_state.h" 17 #include "chrome/installer/util/set_reg_value_work_item.h" 18 #include "chrome/installer/util/util_constants.h" 19 #include "chrome/installer/util/work_item_list.h" 20 21 #include "testing/gtest/include/gtest/gtest.h" 22 #include "testing/gmock/include/gmock/gmock.h" 23 24 using base::win::RegKey; 25 using installer::InstallationState; 26 using installer::InstallerState; 27 using installer::Product; 28 using installer::ProductState; 29 30 using ::testing::_; 31 using ::testing::AtLeast; 32 using ::testing::AtMost; 33 using ::testing::Bool; 34 using ::testing::Combine; 35 using ::testing::HasSubstr; 36 using ::testing::Eq; 37 using ::testing::Return; 38 using ::testing::StrCaseEq; 39 using ::testing::StrEq; 40 using ::testing::StrictMock; 41 using ::testing::Values; 42 43 // Mock classes to help with testing 44 //------------------------------------------------------------------------------ 45 46 class MockWorkItemList : public WorkItemList { 47 public: 48 MockWorkItemList() {} 49 50 MOCK_METHOD4(AddCopyRegKeyWorkItem, WorkItem* (HKEY, 51 const std::wstring&, 52 const std::wstring&, 53 CopyOverWriteOption)); 54 MOCK_METHOD5(AddCopyTreeWorkItem, WorkItem*(const std::wstring&, 55 const std::wstring&, 56 const std::wstring&, 57 CopyOverWriteOption, 58 const std::wstring&)); 59 MOCK_METHOD1(AddCreateDirWorkItem, WorkItem* (const base::FilePath&)); 60 MOCK_METHOD2(AddCreateRegKeyWorkItem, WorkItem* (HKEY, const std::wstring&)); 61 MOCK_METHOD2(AddDeleteRegKeyWorkItem, WorkItem* (HKEY, const std::wstring&)); 62 MOCK_METHOD3(AddDeleteRegValueWorkItem, WorkItem* (HKEY, 63 const std::wstring&, 64 const std::wstring&)); 65 MOCK_METHOD2(AddDeleteTreeWorkItem, WorkItem* ( 66 const base::FilePath&, 67 const std::vector<base::FilePath>&)); 68 MOCK_METHOD1(AddDeleteTreeWorkItem, WorkItem* (const base::FilePath&)); 69 MOCK_METHOD3(AddMoveTreeWorkItem, WorkItem* (const std::wstring&, 70 const std::wstring&, 71 const std::wstring&)); 72 // Workaround for gmock problems with disambiguating between string pointers 73 // and DWORD. 74 virtual WorkItem* AddSetRegValueWorkItem(HKEY a1, const std::wstring& a2, 75 const std::wstring& a3, const std::wstring& a4, bool a5) { 76 return AddSetRegStringValueWorkItem(a1, a2, a3, a4, a5); 77 } 78 79 virtual WorkItem* AddSetRegValueWorkItem(HKEY a1, const std::wstring& a2, 80 const std::wstring& a3, 81 DWORD a4, bool a5) { 82 return AddSetRegDwordValueWorkItem(a1, a2, a3, a4, a5); 83 } 84 85 MOCK_METHOD5(AddSetRegStringValueWorkItem, WorkItem*(HKEY, 86 const std::wstring&, 87 const std::wstring&, 88 const std::wstring&, 89 bool)); 90 MOCK_METHOD5(AddSetRegDwordValueWorkItem, WorkItem* (HKEY, 91 const std::wstring&, 92 const std::wstring&, 93 DWORD, 94 bool)); 95 MOCK_METHOD3(AddSelfRegWorkItem, WorkItem* (const std::wstring&, 96 bool, 97 bool)); 98 }; 99 100 class MockProductState : public ProductState { 101 public: 102 // Takes ownership of |version|. 103 void set_version(Version* version) { version_.reset(version); } 104 void set_multi_install(bool multi) { multi_install_ = multi; } 105 void set_brand(const std::wstring& brand) { brand_ = brand; } 106 void set_eula_accepted(DWORD eula_accepted) { 107 has_eula_accepted_ = true; 108 eula_accepted_ = eula_accepted; 109 } 110 void clear_eula_accepted() { has_eula_accepted_ = false; } 111 void set_usagestats(DWORD usagestats) { 112 has_usagestats_ = true; 113 usagestats_ = usagestats; 114 } 115 void clear_usagestats() { has_usagestats_ = false; } 116 void set_oem_install(const std::wstring& oem_install) { 117 has_oem_install_ = true; 118 oem_install_ = oem_install; 119 } 120 void clear_oem_install() { has_oem_install_ = false; } 121 void SetUninstallProgram(const base::FilePath& setup_exe) { 122 uninstall_command_ = CommandLine(setup_exe); 123 } 124 void AddUninstallSwitch(const std::string& option) { 125 uninstall_command_.AppendSwitch(option); 126 } 127 }; 128 129 // Okay, so this isn't really a mock as such, but it does add setter methods 130 // to make it easier to build custom InstallationStates. 131 class MockInstallationState : public InstallationState { 132 public: 133 // Included for testing. 134 void SetProductState(bool system_install, 135 BrowserDistribution::Type type, 136 const ProductState& product_state) { 137 ProductState& target = (system_install ? system_products_ : 138 user_products_)[IndexFromDistType(type)]; 139 target.CopyFrom(product_state); 140 } 141 }; 142 143 class MockInstallerState : public InstallerState { 144 public: 145 void set_level(Level level) { 146 InstallerState::set_level(level); 147 } 148 149 void set_operation(Operation operation) { operation_ = operation; } 150 151 void set_state_key(const std::wstring& state_key) { 152 state_key_ = state_key; 153 } 154 155 void set_state_type(BrowserDistribution::Type state_type) { 156 state_type_ = state_type; 157 } 158 159 void set_package_type(PackageType type) { 160 InstallerState::set_package_type(type); 161 } 162 }; 163 164 // The test fixture 165 //------------------------------------------------------------------------------ 166 167 class InstallWorkerTest : public testing::Test { 168 public: 169 virtual void SetUp() { 170 current_version_.reset(new Version("1.0.0.0")); 171 new_version_.reset(new Version("42.0.0.0")); 172 173 // Don't bother ensuring that these paths exist. Since we're just 174 // building the work item lists and not running them, they shouldn't 175 // actually be touched. 176 archive_path_ = 177 base::FilePath(L"C:\\UnlikelyPath\\Temp\\chrome_123\\chrome.7z"); 178 // TODO(robertshield): Take this from the BrowserDistribution once that 179 // no longer depends on MasterPreferences. 180 installation_path_ = 181 base::FilePath(L"C:\\Program Files\\Google\\Chrome\\"); 182 src_path_ = base::FilePath( 183 L"C:\\UnlikelyPath\\Temp\\chrome_123\\source\\Chrome-bin"); 184 setup_path_ = base::FilePath( 185 L"C:\\UnlikelyPath\\Temp\\CR_123.tmp\\setup.exe"); 186 temp_dir_ = base::FilePath(L"C:\\UnlikelyPath\\Temp\\chrome_123"); 187 } 188 189 virtual void TearDown() { 190 } 191 192 void MaybeAddBinariesToInstallationState( 193 bool system_level, 194 MockInstallationState* installation_state) { 195 if (installation_state->GetProductState( 196 system_level, BrowserDistribution::CHROME_BINARIES) == NULL) { 197 MockProductState product_state; 198 product_state.set_version(new Version(*current_version_)); 199 product_state.set_brand(L"TEST"); 200 product_state.set_multi_install(true); 201 BrowserDistribution* dist = 202 BrowserDistribution::GetSpecificDistribution( 203 BrowserDistribution::CHROME_BINARIES); 204 base::FilePath install_path = 205 installer::GetChromeInstallPath(system_level, dist); 206 product_state.SetUninstallProgram( 207 install_path.AppendASCII(current_version_->GetString()) 208 .Append(installer::kInstallerDir) 209 .Append(installer::kSetupExe)); 210 product_state.AddUninstallSwitch(installer::switches::kUninstall); 211 product_state.AddUninstallSwitch(installer::switches::kMultiInstall); 212 if (system_level) 213 product_state.AddUninstallSwitch(installer::switches::kSystemLevel); 214 installation_state->SetProductState(system_level, 215 BrowserDistribution::CHROME_BINARIES, 216 product_state); 217 } 218 } 219 220 void AddChromeToInstallationState( 221 bool system_level, 222 bool multi_install, 223 bool with_chrome_frame_ready_mode, 224 MockInstallationState* installation_state) { 225 if (multi_install) 226 MaybeAddBinariesToInstallationState(system_level, installation_state); 227 MockProductState product_state; 228 product_state.set_version(new Version(*current_version_)); 229 product_state.set_multi_install(multi_install); 230 product_state.set_brand(L"TEST"); 231 product_state.set_eula_accepted(1); 232 BrowserDistribution* dist = 233 BrowserDistribution::GetSpecificDistribution( 234 BrowserDistribution::CHROME_BROWSER); 235 base::FilePath install_path = 236 installer::GetChromeInstallPath(system_level, dist); 237 product_state.SetUninstallProgram( 238 install_path.AppendASCII(current_version_->GetString()) 239 .Append(installer::kInstallerDir) 240 .Append(installer::kSetupExe)); 241 product_state.AddUninstallSwitch(installer::switches::kUninstall); 242 if (system_level) 243 product_state.AddUninstallSwitch(installer::switches::kSystemLevel); 244 if (multi_install) { 245 product_state.AddUninstallSwitch(installer::switches::kMultiInstall); 246 product_state.AddUninstallSwitch(installer::switches::kChrome); 247 if (with_chrome_frame_ready_mode) { 248 product_state.AddUninstallSwitch(installer::switches::kChromeFrame); 249 product_state.AddUninstallSwitch( 250 installer::switches::kChromeFrameReadyMode); 251 } 252 } 253 254 installation_state->SetProductState(system_level, 255 BrowserDistribution::CHROME_BROWSER, 256 product_state); 257 } 258 259 void AddChromeFrameToInstallationState( 260 bool system_level, 261 bool multi_install, 262 bool ready_mode, 263 MockInstallationState* installation_state) { 264 if (multi_install) 265 MaybeAddBinariesToInstallationState(system_level, installation_state); 266 MockProductState product_state; 267 product_state.set_version(new Version(*current_version_)); 268 product_state.set_multi_install(multi_install); 269 BrowserDistribution* dist = 270 BrowserDistribution::GetSpecificDistribution( 271 multi_install ? BrowserDistribution::CHROME_BINARIES : 272 BrowserDistribution::CHROME_FRAME); 273 base::FilePath install_path = 274 installer::GetChromeInstallPath(system_level, dist); 275 product_state.SetUninstallProgram( 276 install_path.AppendASCII(current_version_->GetString()) 277 .Append(installer::kInstallerDir) 278 .Append(installer::kSetupExe)); 279 product_state.AddUninstallSwitch(installer::switches::kUninstall); 280 product_state.AddUninstallSwitch(installer::switches::kChromeFrame); 281 if (system_level) 282 product_state.AddUninstallSwitch(installer::switches::kSystemLevel); 283 if (multi_install) { 284 product_state.AddUninstallSwitch(installer::switches::kMultiInstall); 285 if (ready_mode) { 286 product_state.AddUninstallSwitch( 287 installer::switches::kChromeFrameReadyMode); 288 } 289 } 290 291 installation_state->SetProductState(system_level, 292 BrowserDistribution::CHROME_FRAME, 293 product_state); 294 } 295 296 MockInstallationState* BuildChromeInstallationState(bool system_level, 297 bool multi_install) { 298 scoped_ptr<MockInstallationState> installation_state( 299 new MockInstallationState()); 300 AddChromeToInstallationState(system_level, multi_install, false, 301 installation_state.get()); 302 return installation_state.release(); 303 } 304 305 static MockInstallerState* BuildBasicInstallerState( 306 bool system_install, 307 bool multi_install, 308 const InstallationState& machine_state, 309 InstallerState::Operation operation) { 310 scoped_ptr<MockInstallerState> installer_state(new MockInstallerState()); 311 312 InstallerState::Level level = system_install ? 313 InstallerState::SYSTEM_LEVEL : InstallerState::USER_LEVEL; 314 installer_state->set_level(level); 315 installer_state->set_operation(operation); 316 // Hope this next one isn't checked for now. 317 installer_state->set_state_key(L"PROBABLY_INVALID_REG_PATH"); 318 installer_state->set_state_type(BrowserDistribution::CHROME_BROWSER); 319 installer_state->set_package_type(multi_install ? 320 InstallerState::MULTI_PACKAGE : 321 InstallerState::SINGLE_PACKAGE); 322 return installer_state.release(); 323 } 324 325 static void AddChromeBinariesToInstallerState( 326 const InstallationState& machine_state, 327 MockInstallerState* installer_state) { 328 if (!installer_state->is_multi_install()) { 329 NOTREACHED(); 330 return; 331 } 332 if (installer_state->FindProduct(BrowserDistribution::CHROME_BINARIES)) 333 return; 334 335 // Fresh install or upgrade? 336 const ProductState* chrome_binaries = 337 machine_state.GetProductState(installer_state->system_install(), 338 BrowserDistribution::CHROME_BINARIES); 339 if (chrome_binaries != NULL) { 340 installer_state->AddProductFromState(BrowserDistribution::CHROME_BINARIES, 341 *chrome_binaries); 342 } else { 343 BrowserDistribution* dist = 344 BrowserDistribution::GetSpecificDistribution( 345 BrowserDistribution::CHROME_BINARIES); 346 scoped_ptr<Product> product(new Product(dist)); 347 product->SetOption(installer::kOptionMultiInstall, true); 348 installer_state->AddProduct(&product); 349 } 350 } 351 352 static void AddChromeToInstallerState( 353 const InstallationState& machine_state, 354 MockInstallerState* installer_state) { 355 // Fresh install or upgrade? 356 const ProductState* chrome = 357 machine_state.GetProductState(installer_state->system_install(), 358 BrowserDistribution::CHROME_BROWSER); 359 if (chrome != NULL && 360 chrome->is_multi_install() == installer_state->is_multi_install()) { 361 installer_state->AddProductFromState(BrowserDistribution::CHROME_BROWSER, 362 *chrome); 363 } else { 364 BrowserDistribution* dist = 365 BrowserDistribution::GetSpecificDistribution( 366 BrowserDistribution::CHROME_BROWSER); 367 scoped_ptr<Product> product(new Product(dist)); 368 if (installer_state->is_multi_install()) 369 product->SetOption(installer::kOptionMultiInstall, true); 370 installer_state->AddProduct(&product); 371 } 372 } 373 374 static void AddChromeFrameToInstallerState( 375 const InstallationState& machine_state, 376 bool ready_mode, 377 MockInstallerState* installer_state) { 378 // Fresh install or upgrade? 379 const ProductState* cf = 380 machine_state.GetProductState(installer_state->system_install(), 381 BrowserDistribution::CHROME_FRAME); 382 if (cf != NULL) { 383 installer_state->AddProductFromState(BrowserDistribution::CHROME_FRAME, 384 *cf); 385 } else { 386 BrowserDistribution* dist = 387 BrowserDistribution::GetSpecificDistribution( 388 BrowserDistribution::CHROME_FRAME); 389 scoped_ptr<Product> product(new Product(dist)); 390 if (installer_state->is_multi_install()) { 391 product->SetOption(installer::kOptionMultiInstall, true); 392 if (ready_mode) 393 product->SetOption(installer::kOptionReadyMode, true); 394 } 395 installer_state->AddProduct(&product); 396 } 397 } 398 399 static MockInstallerState* BuildChromeInstallerState( 400 bool system_install, 401 bool multi_install, 402 const InstallationState& machine_state, 403 InstallerState::Operation operation) { 404 scoped_ptr<MockInstallerState> installer_state( 405 BuildBasicInstallerState(system_install, multi_install, machine_state, 406 operation)); 407 if (multi_install) { 408 // We don't want to include Chrome Binaries for uninstall if the machine 409 // has other products. For simplicity, we check Chrome Frame only. 410 bool machine_has_other_products = 411 machine_state.GetProductState(system_install, 412 BrowserDistribution::CHROME_FRAME) != NULL; 413 if (operation != InstallerState::UNINSTALL || !machine_has_other_products) 414 AddChromeBinariesToInstallerState(machine_state, installer_state.get()); 415 } 416 AddChromeToInstallerState(machine_state, installer_state.get()); 417 return installer_state.release(); 418 } 419 420 static MockInstallerState* BuildChromeFrameInstallerState( 421 bool system_install, 422 bool multi_install, 423 bool ready_mode, 424 const InstallationState& machine_state, 425 InstallerState::Operation operation) { 426 // This method only works for installation/upgrade. 427 DCHECK(operation != InstallerState::UNINSTALL); 428 scoped_ptr<MockInstallerState> installer_state( 429 BuildBasicInstallerState(system_install, multi_install, machine_state, 430 operation)); 431 if (multi_install) 432 AddChromeBinariesToInstallerState(machine_state, installer_state.get()); 433 AddChromeFrameToInstallerState(machine_state, ready_mode, 434 installer_state.get()); 435 return installer_state.release(); 436 } 437 438 protected: 439 scoped_ptr<Version> current_version_; 440 scoped_ptr<Version> new_version_; 441 base::FilePath archive_path_; 442 base::FilePath installation_path_; 443 base::FilePath setup_path_; 444 base::FilePath src_path_; 445 base::FilePath temp_dir_; 446 }; 447 448 // Tests 449 //------------------------------------------------------------------------------ 450 451 TEST_F(InstallWorkerTest, TestInstallChromeSingleSystem) { 452 const bool system_level = true; 453 const bool multi_install = false; 454 MockWorkItemList work_item_list; 455 456 scoped_ptr<InstallationState> installation_state( 457 BuildChromeInstallationState(system_level, multi_install)); 458 459 scoped_ptr<InstallerState> installer_state( 460 BuildChromeInstallerState(system_level, multi_install, 461 *installation_state, 462 InstallerState::SINGLE_INSTALL_OR_UPDATE)); 463 464 // Set up some expectations. 465 // TODO(robertshield): Set up some real expectations. 466 EXPECT_CALL(work_item_list, AddCopyTreeWorkItem(_, _, _, _, _)) 467 .Times(AtLeast(1)); 468 469 AddInstallWorkItems(*installation_state.get(), 470 *installer_state.get(), 471 setup_path_, 472 archive_path_, 473 src_path_, 474 temp_dir_, 475 current_version_.get(), 476 *new_version_.get(), 477 &work_item_list); 478 } 479 480 namespace { 481 482 const wchar_t elevation_key[] = 483 L"SOFTWARE\\Microsoft\\Internet Explorer\\Low Rights\\ElevationPolicy\\" 484 L"{E0A900DF-9611-4446-86BD-4B1D47E7DB2A}"; 485 const wchar_t old_elevation_key[] = 486 L"SOFTWARE\\Microsoft\\Internet Explorer\\Low Rights\\ElevationPolicy\\" 487 L"{6C288DD7-76FB-4721-B628-56FAC252E199}"; 488 489 } // namespace 490 491 // A test class for worker functions that manipulate the old IE low rights 492 // policies. 493 // Parameters: 494 // bool : system_level_ 495 // bool : multi_install_ 496 class OldIELowRightsTests : public InstallWorkerTest, 497 public ::testing::WithParamInterface<std::tr1::tuple<bool, bool> > { 498 protected: 499 virtual void SetUp() OVERRIDE { 500 InstallWorkerTest::SetUp(); 501 502 const ParamType& param = GetParam(); 503 system_level_ = std::tr1::get<0>(param); 504 multi_install_ = std::tr1::get<1>(param); 505 root_key_ = system_level_ ? HKEY_LOCAL_MACHINE : HKEY_CURRENT_USER; 506 507 installation_state_.reset(new MockInstallationState()); 508 AddChromeFrameToInstallationState(system_level_, multi_install_, false, 509 installation_state_.get()); 510 installer_state_.reset(BuildBasicInstallerState( 511 system_level_, multi_install_, *installation_state_, 512 multi_install_ ? InstallerState::MULTI_UPDATE : 513 InstallerState::SINGLE_INSTALL_OR_UPDATE)); 514 if (multi_install_) 515 AddChromeBinariesToInstallerState(*installation_state_, 516 installer_state_.get()); 517 AddChromeFrameToInstallerState(*installation_state_, false, 518 installer_state_.get()); 519 } 520 521 scoped_ptr<MockInstallationState> installation_state_; 522 scoped_ptr<MockInstallerState> installer_state_; 523 bool system_level_; 524 bool multi_install_; 525 HKEY root_key_; 526 }; 527 528 TEST_P(OldIELowRightsTests, AddDeleteOldIELowRightsPolicyWorkItems) { 529 StrictMock<MockWorkItemList> work_item_list; 530 531 EXPECT_CALL(work_item_list, 532 AddDeleteRegKeyWorkItem(root_key_, StrEq(old_elevation_key))) 533 .Times(1); 534 535 AddDeleteOldIELowRightsPolicyWorkItems(*installer_state_.get(), 536 &work_item_list); 537 } 538 539 TEST_P(OldIELowRightsTests, AddCopyIELowRightsPolicyWorkItems) { 540 StrictMock<MockWorkItemList> work_item_list; 541 542 // The old elevation policy key should only be copied when there's no old 543 // value. 544 EXPECT_CALL(work_item_list, 545 AddCopyRegKeyWorkItem(root_key_, StrEq(elevation_key), 546 StrEq(old_elevation_key), 547 Eq(WorkItem::IF_NOT_PRESENT))).Times(1); 548 549 AddCopyIELowRightsPolicyWorkItems(*installer_state_.get(), &work_item_list); 550 } 551 552 INSTANTIATE_TEST_CASE_P(Variations, OldIELowRightsTests, 553 Combine(Bool(), Bool())); 554 555 TEST_F(InstallWorkerTest, GoogleUpdateWorkItemsTest) { 556 const bool system_level = true; 557 const bool multi_install = true; 558 MockWorkItemList work_item_list; 559 560 scoped_ptr<MockInstallationState> installation_state( 561 BuildChromeInstallationState(system_level, false)); 562 563 MockProductState cf_state; 564 cf_state.set_version(new Version(*current_version_)); 565 cf_state.set_multi_install(false); 566 567 installation_state->SetProductState(system_level, 568 BrowserDistribution::CHROME_FRAME, cf_state); 569 570 scoped_ptr<MockInstallerState> installer_state( 571 BuildChromeInstallerState(system_level, multi_install, 572 *installation_state, 573 InstallerState::MULTI_INSTALL)); 574 575 // Expect the multi Client State key to be created. 576 BrowserDistribution* multi_dist = 577 BrowserDistribution::GetSpecificDistribution( 578 BrowserDistribution::CHROME_BINARIES); 579 std::wstring multi_app_guid(multi_dist->GetAppGuid()); 580 std::wstring multi_client_state_suffix(L"ClientState\\" + multi_app_guid); 581 EXPECT_CALL(work_item_list, 582 AddCreateRegKeyWorkItem(_, HasSubstr(multi_client_state_suffix))) 583 .Times(testing::AnyNumber()); 584 585 // Expect ClientStateMedium to be created for system-level installs. 586 EXPECT_CALL(work_item_list, 587 AddCreateRegKeyWorkItem(_, HasSubstr(L"ClientStateMedium\\" + 588 multi_app_guid))) 589 .Times(system_level ? 1 : 0); 590 591 // Expect to see a set value for the "TEST" brand code in the multi Client 592 // State key. 593 EXPECT_CALL(work_item_list, 594 AddSetRegStringValueWorkItem(_, 595 HasSubstr(multi_client_state_suffix), 596 StrEq(google_update::kRegBrandField), 597 StrEq(L"TEST"), 598 _)).Times(1); 599 600 // There may also be some calls to set 'ap' values. 601 EXPECT_CALL(work_item_list, 602 AddSetRegStringValueWorkItem(_, _, 603 StrEq(google_update::kRegApField), 604 _, _)).Times(testing::AnyNumber()); 605 606 // Expect "oeminstall" to be cleared. 607 EXPECT_CALL(work_item_list, 608 AddDeleteRegValueWorkItem( 609 _, 610 HasSubstr(multi_client_state_suffix), 611 StrEq(google_update::kRegOemInstallField))).Times(1); 612 613 // Expect "eulaaccepted" to set. 614 EXPECT_CALL(work_item_list, 615 AddSetRegDwordValueWorkItem( 616 _, 617 HasSubstr(multi_client_state_suffix), 618 StrEq(google_update::kRegEULAAceptedField), 619 Eq(static_cast<DWORD>(1)), 620 _)).Times(1); 621 622 AddGoogleUpdateWorkItems(*installation_state.get(), 623 *installer_state.get(), 624 &work_item_list); 625 } 626 627 // Test that usagestats values are migrated properly. 628 TEST_F(InstallWorkerTest, AddUsageStatsWorkItems) { 629 const bool system_level = true; 630 const bool multi_install = true; 631 MockWorkItemList work_item_list; 632 633 scoped_ptr<MockInstallationState> installation_state( 634 BuildChromeInstallationState(system_level, multi_install)); 635 636 MockProductState chrome_state; 637 chrome_state.set_version(new Version(*current_version_)); 638 chrome_state.set_multi_install(false); 639 chrome_state.set_usagestats(1); 640 641 installation_state->SetProductState(system_level, 642 BrowserDistribution::CHROME_BROWSER, chrome_state); 643 644 scoped_ptr<MockInstallerState> installer_state( 645 BuildChromeInstallerState(system_level, multi_install, 646 *installation_state, 647 InstallerState::MULTI_INSTALL)); 648 649 // Expect the multi Client State key to be created. 650 BrowserDistribution* multi_dist = 651 BrowserDistribution::GetSpecificDistribution( 652 BrowserDistribution::CHROME_BINARIES); 653 std::wstring multi_app_guid(multi_dist->GetAppGuid()); 654 EXPECT_CALL(work_item_list, 655 AddCreateRegKeyWorkItem(_, HasSubstr(multi_app_guid))).Times(1); 656 657 // Expect to see a set value for the usagestats in the multi Client State key. 658 EXPECT_CALL(work_item_list, 659 AddSetRegDwordValueWorkItem( 660 _, 661 HasSubstr(multi_app_guid), 662 StrEq(google_update::kRegUsageStatsField), 663 Eq(static_cast<DWORD>(1)), 664 Eq(true))).Times(1); 665 666 // Expect to see some values cleaned up from Chrome's keys. 667 BrowserDistribution* chrome_dist = 668 BrowserDistribution::GetSpecificDistribution( 669 BrowserDistribution::CHROME_BROWSER); 670 if (system_level) { 671 EXPECT_CALL(work_item_list, 672 AddDeleteRegValueWorkItem( 673 _, 674 StrEq(chrome_dist->GetStateMediumKey()), 675 StrEq(google_update::kRegUsageStatsField))).Times(1); 676 EXPECT_CALL(work_item_list, 677 AddDeleteRegValueWorkItem( 678 Eq(HKEY_CURRENT_USER), 679 StrEq(chrome_dist->GetStateKey()), 680 StrEq(google_update::kRegUsageStatsField))).Times(1); 681 } 682 EXPECT_CALL(work_item_list, 683 AddDeleteRegValueWorkItem( 684 Eq(installer_state->root_key()), 685 StrEq(chrome_dist->GetStateKey()), 686 StrEq(google_update::kRegUsageStatsField))).Times(1); 687 688 AddUsageStatsWorkItems(*installation_state.get(), 689 *installer_state.get(), 690 &work_item_list); 691 } 692 693 // The Quick Enable tests only make sense for the Google Chrome build as it 694 // interacts with registry values that are specific to Google Update. 695 #if defined(GOOGLE_CHROME_BUILD) 696 697 // Test scenarios under which the quick-enable-cf command should not exist after 698 // the run. We're permissive in that we allow the DeleteRegKeyWorkItem even if 699 // it isn't strictly needed. 700 class QuickEnableAbsentTest : public InstallWorkerTest { 701 public: 702 virtual void SetUp() { 703 InstallWorkerTest::SetUp(); 704 root_key_ = system_level_ ? HKEY_LOCAL_MACHINE : HKEY_CURRENT_USER; 705 delete_reg_key_item_.reset( 706 WorkItem::CreateDeleteRegKeyWorkItem(root_key_, kRegKeyPath)); 707 machine_state_.reset(new MockInstallationState()); 708 EXPECT_CALL(work_item_list_, 709 AddDeleteRegKeyWorkItem(Eq(root_key_), StrCaseEq(kRegKeyPath))) 710 .Times(AtMost(1)) 711 .WillRepeatedly(Return(delete_reg_key_item_.get())); 712 } 713 virtual void TearDown() { 714 machine_state_.reset(); 715 delete_reg_key_item_.reset(); 716 root_key_ = NULL; 717 InstallWorkerTest::TearDown(); 718 } 719 protected: 720 static const bool system_level_ = false; 721 static const wchar_t kRegKeyPath[]; 722 HKEY root_key_; 723 scoped_ptr<DeleteRegKeyWorkItem> delete_reg_key_item_; 724 scoped_ptr<MockInstallationState> machine_state_; 725 StrictMock<MockWorkItemList> work_item_list_; 726 }; 727 728 const wchar_t QuickEnableAbsentTest::kRegKeyPath[] = 729 L"Software\\Google\\Update\\Clients\\" 730 L"{4DC8B4CA-1BDA-483e-B5FA-D3C12E15B62D}\\Commands\\quick-enable-cf"; 731 732 TEST_F(QuickEnableAbsentTest, CleanInstallSingleChrome) { 733 // Install single Chrome on a clean system. 734 scoped_ptr<MockInstallerState> installer_state( 735 BuildChromeInstallerState(system_level_, false, *machine_state_, 736 InstallerState::SINGLE_INSTALL_OR_UPDATE)); 737 AddQuickEnableChromeFrameWorkItems(*installer_state, 738 *machine_state_, 739 setup_path_, 740 *new_version_.get(), 741 &work_item_list_); 742 } 743 744 TEST_F(QuickEnableAbsentTest, CleanInstallSingleChromeFrame) { 745 // Install single Chrome Frame on a clean system. 746 scoped_ptr<MockInstallerState> installer_state( 747 BuildChromeFrameInstallerState(system_level_, false, false, 748 *machine_state_, 749 InstallerState::SINGLE_INSTALL_OR_UPDATE)); 750 AddQuickEnableChromeFrameWorkItems(*installer_state, 751 *machine_state_, 752 setup_path_, 753 *new_version_.get(), 754 &work_item_list_); 755 } 756 757 TEST_F(QuickEnableAbsentTest, CleanInstallMultiChromeFrame) { 758 // Install multi Chrome Frame on a clean system. 759 scoped_ptr<MockInstallerState> installer_state( 760 BuildChromeFrameInstallerState(system_level_, true, false, 761 *machine_state_, 762 InstallerState::MULTI_INSTALL)); 763 AddQuickEnableChromeFrameWorkItems(*installer_state, 764 *machine_state_, 765 setup_path_, 766 *new_version_.get(), 767 &work_item_list_); 768 } 769 770 TEST_F(QuickEnableAbsentTest, CleanInstallMultiChromeChromeFrame) { 771 // Install multi Chrome and Chrome Frame on a clean system. 772 scoped_ptr<MockInstallerState> installer_state( 773 BuildBasicInstallerState(system_level_, true, *machine_state_, 774 InstallerState::MULTI_INSTALL)); 775 AddChromeBinariesToInstallerState(*machine_state_, installer_state.get()); 776 AddChromeToInstallerState(*machine_state_, installer_state.get()); 777 AddChromeFrameToInstallerState(*machine_state_, false, 778 installer_state.get()); 779 AddQuickEnableChromeFrameWorkItems(*installer_state, 780 *machine_state_, 781 setup_path_, 782 *new_version_.get(), 783 &work_item_list_); 784 } 785 786 TEST_F(QuickEnableAbsentTest, UninstallMultiChromeLeaveMultiChromeFrame) { 787 // Uninstall multi Chrome on a machine with multi Chrome Frame. 788 AddChromeToInstallationState(system_level_, true, false, 789 machine_state_.get()); 790 AddChromeFrameToInstallationState(system_level_, true, false, 791 machine_state_.get()); 792 scoped_ptr<MockInstallerState> installer_state( 793 BuildBasicInstallerState(system_level_, true, *machine_state_, 794 InstallerState::UNINSTALL)); 795 AddChromeToInstallerState(*machine_state_, installer_state.get()); 796 AddQuickEnableChromeFrameWorkItems(*installer_state, 797 *machine_state_, 798 setup_path_, 799 *new_version_.get(), 800 &work_item_list_); 801 } 802 803 TEST_F(QuickEnableAbsentTest, UninstallMultiChromeLeaveSingleChromeFrame) { 804 // Uninstall multi Chrome on a machine with single Chrome Frame. 805 AddChromeToInstallationState(system_level_, true, false, 806 machine_state_.get()); 807 AddChromeFrameToInstallationState(system_level_, false, false, 808 machine_state_.get()); 809 scoped_ptr<MockInstallerState> installer_state( 810 BuildBasicInstallerState(system_level_, true, *machine_state_, 811 InstallerState::UNINSTALL)); 812 AddChromeToInstallerState(*machine_state_, installer_state.get()); 813 AddChromeBinariesToInstallerState(*machine_state_, installer_state.get()); 814 AddQuickEnableChromeFrameWorkItems(*installer_state, 815 *machine_state_, 816 setup_path_, 817 *new_version_.get(), 818 &work_item_list_); 819 } 820 821 TEST_F(QuickEnableAbsentTest, AcceptReadyMode) { 822 // Accept ready-mode. 823 AddChromeToInstallationState(system_level_, true, true, 824 machine_state_.get()); 825 AddChromeFrameToInstallationState(system_level_, true, true, 826 machine_state_.get()); 827 scoped_ptr<MockInstallerState> installer_state( 828 BuildBasicInstallerState(system_level_, true, *machine_state_, 829 InstallerState::UNINSTALL)); 830 AddChromeToInstallerState(*machine_state_, installer_state.get()); 831 AddChromeFrameToInstallerState(*machine_state_, false, installer_state.get()); 832 AddChromeBinariesToInstallerState(*machine_state_, installer_state.get()); 833 AddQuickEnableChromeFrameWorkItems(*installer_state, 834 *machine_state_, 835 setup_path_, 836 *new_version_.get(), 837 &work_item_list_); 838 } 839 840 // Test scenarios under which the quick-enable-cf command should exist after the 841 // run. 842 class QuickEnablePresentTest : public InstallWorkerTest { 843 public: 844 virtual void SetUp() { 845 InstallWorkerTest::SetUp(); 846 root_key_ = system_level_ ? HKEY_LOCAL_MACHINE : HKEY_CURRENT_USER; 847 create_reg_key_work_item_.reset( 848 WorkItem::CreateCreateRegKeyWorkItem(root_key_, kRegKeyPath)); 849 set_reg_value_work_item_.reset( 850 WorkItem::CreateSetRegValueWorkItem(root_key_, kRegKeyPath, L"", L"", 851 false)); 852 machine_state_.reset(new MockInstallationState()); 853 EXPECT_CALL(work_item_list_, 854 AddCreateRegKeyWorkItem(Eq(root_key_), StrCaseEq(kRegKeyPath))) 855 .Times(1) 856 .WillOnce(Return(create_reg_key_work_item_.get())); 857 EXPECT_CALL(work_item_list_, 858 AddSetRegStringValueWorkItem(Eq(root_key_), 859 StrCaseEq(kRegKeyPath), 860 StrEq(L"CommandLine"), _, 861 Eq(true))) 862 .Times(1) 863 .WillOnce(Return(set_reg_value_work_item_.get())); 864 EXPECT_CALL(work_item_list_, 865 AddSetRegDwordValueWorkItem(Eq(root_key_), 866 StrCaseEq(kRegKeyPath), _, 867 Eq(static_cast<DWORD>(1)), 868 Eq(true))) 869 .Times(2) 870 .WillRepeatedly(Return(set_reg_value_work_item_.get())); 871 } 872 virtual void TearDown() { 873 machine_state_.reset(); 874 set_reg_value_work_item_.reset(); 875 create_reg_key_work_item_.reset(); 876 root_key_ = NULL; 877 InstallWorkerTest::TearDown(); 878 } 879 protected: 880 static const bool system_level_ = false; 881 static const wchar_t kRegKeyPath[]; 882 HKEY root_key_; 883 scoped_ptr<CreateRegKeyWorkItem> create_reg_key_work_item_; 884 scoped_ptr<SetRegValueWorkItem> set_reg_value_work_item_; 885 scoped_ptr<MockInstallationState> machine_state_; 886 StrictMock<MockWorkItemList> work_item_list_; 887 }; 888 889 const wchar_t QuickEnablePresentTest::kRegKeyPath[] = 890 L"Software\\Google\\Update\\Clients\\" 891 L"{4DC8B4CA-1BDA-483e-B5FA-D3C12E15B62D}\\Commands\\quick-enable-cf"; 892 893 TEST_F(QuickEnablePresentTest, CleanInstallMultiChrome) { 894 // Install multi Chrome on a clean system. 895 scoped_ptr<MockInstallerState> installer_state( 896 BuildChromeInstallerState(system_level_, true, *machine_state_, 897 InstallerState::MULTI_INSTALL)); 898 AddQuickEnableChromeFrameWorkItems(*installer_state, 899 *machine_state_, 900 setup_path_, 901 *new_version_.get(), 902 &work_item_list_); 903 } 904 905 TEST_F(QuickEnablePresentTest, CleanInstallMultiChromeReadyMode) { 906 // Install multi Chrome with Chrome Frame ready-mode on a clean system. 907 scoped_ptr<MockInstallerState> installer_state( 908 BuildBasicInstallerState(system_level_, true, *machine_state_, 909 InstallerState::MULTI_INSTALL)); 910 AddChromeBinariesToInstallerState(*machine_state_, installer_state.get()); 911 AddChromeToInstallerState(*machine_state_, installer_state.get()); 912 AddChromeFrameToInstallerState(*machine_state_, true, 913 installer_state.get()); 914 AddQuickEnableChromeFrameWorkItems(*installer_state, 915 *machine_state_, 916 setup_path_, 917 *new_version_.get(), 918 &work_item_list_); 919 } 920 921 TEST_F(QuickEnablePresentTest, UninstallSingleChromeFrame) { 922 // Uninstall single Chrome Frame on a machine with multi Chrome. 923 AddChromeToInstallationState(system_level_, true, false, 924 machine_state_.get()); 925 AddChromeFrameToInstallationState(system_level_, false, false, 926 machine_state_.get()); 927 scoped_ptr<MockInstallerState> installer_state( 928 BuildBasicInstallerState(system_level_, false, *machine_state_, 929 InstallerState::UNINSTALL)); 930 AddChromeFrameToInstallerState(*machine_state_, false, installer_state.get()); 931 AddQuickEnableChromeFrameWorkItems(*installer_state, 932 *machine_state_, 933 setup_path_, 934 *new_version_.get(), 935 &work_item_list_); 936 } 937 938 TEST_F(QuickEnablePresentTest, UninstallMultiChromeFrame) { 939 // Uninstall multi Chrome Frame on a machine with multi Chrome. 940 AddChromeToInstallationState(system_level_, true, false, 941 machine_state_.get()); 942 AddChromeFrameToInstallationState(system_level_, true, false, 943 machine_state_.get()); 944 scoped_ptr<MockInstallerState> installer_state( 945 BuildBasicInstallerState(system_level_, true, *machine_state_, 946 InstallerState::UNINSTALL)); 947 AddChromeFrameToInstallerState(*machine_state_, false, installer_state.get()); 948 AddQuickEnableChromeFrameWorkItems(*installer_state, 949 *machine_state_, 950 setup_path_, 951 *new_version_.get(), 952 &work_item_list_); 953 } 954 955 TEST_F(InstallWorkerTest, WillProductBePresentAfterSetup) { 956 BrowserDistribution::Type prod_type_list[] = { 957 BrowserDistribution::CHROME_BROWSER, 958 BrowserDistribution::CHROME_FRAME, 959 // Excluding BrowserDistribution::CHROME_BINARIES, since it is installed 960 // along with other products. 961 }; 962 enum { // Index into prod_type_list[]. 963 TYPE_BROWSER = 0, 964 TYPE_CF, 965 NUM_TYPE // This must appear last. 966 }; 967 DCHECK(arraysize(prod_type_list) == NUM_TYPE); 968 InstallerState::Operation op_list[] = { 969 InstallerState::UNINSTALL, 970 InstallerState::SINGLE_INSTALL_OR_UPDATE 971 }; 972 973 const bool system_level = false; 974 const bool multi_install = true; 975 976 // Loop over machine states: {No product, Chrome, CF, Chrome + CF}. 977 for (int i_mach = 0; i_mach < (1 << NUM_TYPE); ++i_mach) { 978 // i_mach is the machine state before operation, as bit mask. 979 scoped_ptr<MockInstallationState> machine_state( 980 new MockInstallationState()); 981 if ((i_mach & (1 << TYPE_BROWSER)) != 0) { // Add Chrome. 982 AddChromeToInstallationState(system_level, multi_install, false, 983 machine_state.get()); 984 } 985 if ((i_mach & (1 << TYPE_CF)) != 0) { // Add Chrome Frame. 986 AddChromeFrameToInstallationState(system_level, multi_install, false, 987 machine_state.get()); 988 } 989 990 // Loop over operations: {uninstall, install/update}. 991 for (int i_op = 0; i_op < arraysize(op_list); ++i_op) { 992 993 // Loop over product types to operate on: {TYPE_BROWSER, TYPE_CF}. 994 for (int i_type_op = 0; i_type_op < NUM_TYPE; ++i_type_op) { 995 scoped_ptr<InstallerState> installer_state; 996 if (i_type_op == TYPE_BROWSER) { 997 installer_state.reset(BuildChromeInstallerState( 998 system_level, multi_install, *machine_state, op_list[i_op])); 999 } else if (i_type_op == TYPE_CF) { 1000 // Skip the CF uninstall case due to limitations in 1001 // BuildChromeFrameInstallerState(). 1002 if (op_list[i_op] == InstallerState::UNINSTALL) 1003 continue; 1004 1005 installer_state.reset(BuildChromeFrameInstallerState( 1006 system_level, multi_install, false, *machine_state, 1007 op_list[i_op])); 1008 } else { 1009 NOTREACHED(); 1010 } 1011 1012 // Calculate the machine state after operation, as bit mask. 1013 // If uninstall, remove product with bitwise AND; else add with OR. 1014 int mach_after = (op_list[i_op] == InstallerState::UNINSTALL) ? 1015 i_mach & ~(1 << i_type_op) : i_mach | (1 << i_type_op); 1016 1017 // Verify predicted presence of Chrome Binaries. 1018 bool bin_res = installer::WillProductBePresentAfterSetup( 1019 *installer_state, 1020 *machine_state, 1021 BrowserDistribution::CHROME_BINARIES); 1022 // Binaries are expected to be present iff any product is installed. 1023 bool bin_expect = mach_after != 0; 1024 EXPECT_EQ(bin_expect, bin_res); 1025 1026 // Loop over product types to check: {TYPE_BROWSER, TYPE_CF}. 1027 for (int i_type_check = 0; i_type_check < NUM_TYPE; ++i_type_check) { 1028 // Verify predicted presence of product. 1029 bool prod_res = installer::WillProductBePresentAfterSetup( 1030 *installer_state, 1031 *machine_state, 1032 prod_type_list[i_type_check]); 1033 bool prod_expect = (mach_after & (1 << i_type_check)) != 0; 1034 EXPECT_EQ(prod_expect, prod_res); 1035 } 1036 } 1037 } 1038 } 1039 } 1040 1041 #endif // defined(GOOGLE_CHROME_BUILD) 1042
