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 <windows.h> 6 #include <shlwapi.h> // For SHDeleteKey. 7 8 #include "base/memory/scoped_ptr.h" 9 #include "base/strings/utf_string_conversions.h" 10 #include "base/test/test_reg_util_win.h" 11 #include "base/win/registry.h" 12 #include "chrome/common/chrome_constants.h" 13 #include "chrome/installer/util/browser_distribution.h" 14 #include "chrome/installer/util/channel_info.h" 15 #include "chrome/installer/util/fake_installation_state.h" 16 #include "chrome/installer/util/google_update_constants.h" 17 #include "chrome/installer/util/google_update_settings.h" 18 #include "chrome/installer/util/util_constants.h" 19 #include "chrome/installer/util/work_item_list.h" 20 #include "testing/gtest/include/gtest/gtest.h" 21 22 using base::win::RegKey; 23 using installer::ChannelInfo; 24 25 namespace { 26 27 const wchar_t kGoogleUpdatePoliciesKey[] = 28 L"SOFTWARE\\Policies\\Google\\Update"; 29 const wchar_t kGoogleUpdateUpdateDefault[] = L"UpdateDefault"; 30 const wchar_t kGoogleUpdateUpdatePrefix[] = L"Update"; 31 const GoogleUpdateSettings::UpdatePolicy kDefaultUpdatePolicy = 32 #if defined(GOOGLE_CHROME_BUILD) 33 GoogleUpdateSettings::AUTOMATIC_UPDATES; 34 #else 35 GoogleUpdateSettings::UPDATES_DISABLED; 36 #endif 37 38 const wchar_t kTestProductGuid[] = L"{89F1B351-B15D-48D4-8F10-1298721CF13D}"; 39 const wchar_t kTestExperimentLabel[] = L"test_label_value"; 40 41 // This test fixture redirects the HKLM and HKCU registry hives for 42 // the duration of the test to make it independent of the machine 43 // and user settings. 44 class GoogleUpdateSettingsTest : public testing::Test { 45 protected: 46 virtual void SetUp() OVERRIDE { 47 registry_overrides_.OverrideRegistry(HKEY_LOCAL_MACHINE, L"HKLM_pit"); 48 registry_overrides_.OverrideRegistry(HKEY_CURRENT_USER, L"HKCU_pit"); 49 } 50 51 enum SystemUserInstall { 52 SYSTEM_INSTALL, 53 USER_INSTALL, 54 }; 55 56 void SetApField(SystemUserInstall is_system, const wchar_t* value) { 57 HKEY root = is_system == SYSTEM_INSTALL ? 58 HKEY_LOCAL_MACHINE : HKEY_CURRENT_USER; 59 60 RegKey update_key; 61 BrowserDistribution* dist = BrowserDistribution::GetDistribution(); 62 std::wstring path = dist->GetStateKey(); 63 ASSERT_EQ(ERROR_SUCCESS, update_key.Create(root, path.c_str(), KEY_WRITE)); 64 ASSERT_EQ(ERROR_SUCCESS, update_key.WriteValue(L"ap", value)); 65 } 66 67 // Tests setting the ap= value to various combinations of values with 68 // prefixes and suffixes, while asserting on the correct channel value. 69 // Note that any non-empty ap= value that doesn't match ".*-{dev|beta}.*" 70 // will return the "unknown" channel. 71 void TestCurrentChromeChannelWithVariousApValues(SystemUserInstall install) { 72 static struct Expectations { 73 const wchar_t* ap_value; 74 const wchar_t* channel; 75 } expectations[] = { 76 { L"dev", installer::kChromeChannelDev }, 77 { L"-dev", installer::kChromeChannelDev }, 78 { L"-developer", installer::kChromeChannelDev }, 79 { L"beta", installer::kChromeChannelBeta }, 80 { L"-beta", installer::kChromeChannelBeta }, 81 { L"-betamax", installer::kChromeChannelBeta }, 82 }; 83 bool is_system = install == SYSTEM_INSTALL; 84 const wchar_t* prefixes[] = { 85 L"", 86 L"prefix", 87 L"prefix-with-dash", 88 }; 89 const wchar_t* suffixes[] = { 90 L"", 91 L"suffix", 92 L"suffix-with-dash", 93 }; 94 95 for (size_t i = 0; i < arraysize(prefixes); ++i) { 96 for (size_t j = 0; j < arraysize(expectations); ++j) { 97 for (size_t k = 0; k < arraysize(suffixes); ++k) { 98 std::wstring ap = prefixes[i]; 99 ap += expectations[j].ap_value; 100 ap += suffixes[k]; 101 const wchar_t* channel = expectations[j].channel; 102 103 SetApField(install, ap.c_str()); 104 string16 ret_channel; 105 106 EXPECT_TRUE(GoogleUpdateSettings::GetChromeChannelAndModifiers( 107 is_system, &ret_channel)); 108 EXPECT_STREQ(channel, ret_channel.c_str()) 109 << "Expecting channel \"" << channel 110 << "\" for ap=\"" << ap << "\""; 111 } 112 } 113 } 114 } 115 116 // Test the writing and deleting functionality of the experiments label 117 // helper. 118 void TestExperimentsLabelHelper(SystemUserInstall install) { 119 BrowserDistribution* chrome = 120 BrowserDistribution::GetSpecificDistribution( 121 BrowserDistribution::CHROME_BROWSER); 122 std::wstring value; 123 #if defined(GOOGLE_CHROME_BUILD) 124 EXPECT_TRUE(chrome->ShouldSetExperimentLabels()); 125 126 // Before anything is set, ReadExperimentLabels should succeed but return 127 // an empty string. 128 EXPECT_TRUE(GoogleUpdateSettings::ReadExperimentLabels( 129 install == SYSTEM_INSTALL, &value)); 130 EXPECT_EQ(string16(), value); 131 132 EXPECT_TRUE(GoogleUpdateSettings::SetExperimentLabels( 133 install == SYSTEM_INSTALL, kTestExperimentLabel)); 134 135 // Validate that something is written. Only worry about the label itself. 136 RegKey key; 137 HKEY root = install == SYSTEM_INSTALL ? 138 HKEY_LOCAL_MACHINE : HKEY_CURRENT_USER; 139 string16 state_key = install == SYSTEM_INSTALL ? 140 chrome->GetStateMediumKey() : chrome->GetStateKey(); 141 142 EXPECT_EQ(ERROR_SUCCESS, 143 key.Open(root, state_key.c_str(), KEY_QUERY_VALUE)); 144 EXPECT_EQ(ERROR_SUCCESS, 145 key.ReadValue(google_update::kExperimentLabels, &value)); 146 EXPECT_EQ(kTestExperimentLabel, value); 147 EXPECT_TRUE(GoogleUpdateSettings::ReadExperimentLabels( 148 install == SYSTEM_INSTALL, &value)); 149 EXPECT_EQ(kTestExperimentLabel, value); 150 key.Close(); 151 152 // Now that the label is set, test the delete functionality. An empty label 153 // should result in deleting the value. 154 EXPECT_TRUE(GoogleUpdateSettings::SetExperimentLabels( 155 install == SYSTEM_INSTALL, string16())); 156 EXPECT_EQ(ERROR_SUCCESS, 157 key.Open(root, state_key.c_str(), KEY_QUERY_VALUE)); 158 EXPECT_EQ(ERROR_FILE_NOT_FOUND, 159 key.ReadValue(google_update::kExperimentLabels, &value)); 160 EXPECT_TRUE(GoogleUpdateSettings::ReadExperimentLabels( 161 install == SYSTEM_INSTALL, &value)); 162 EXPECT_EQ(string16(), value); 163 key.Close(); 164 #else 165 EXPECT_FALSE(chrome->ShouldSetExperimentLabels()); 166 EXPECT_FALSE(GoogleUpdateSettings::ReadExperimentLabels( 167 install == SYSTEM_INSTALL, &value)); 168 #endif // GOOGLE_CHROME_BUILD 169 } 170 171 // Creates "ap" key with the value given as parameter. Also adds work 172 // items to work_item_list given so that they can be rolled back later. 173 bool CreateApKey(WorkItemList* work_item_list, const std::wstring& value) { 174 HKEY reg_root = HKEY_CURRENT_USER; 175 std::wstring reg_key = GetApKeyPath(); 176 work_item_list->AddCreateRegKeyWorkItem(reg_root, reg_key); 177 work_item_list->AddSetRegValueWorkItem(reg_root, reg_key, 178 google_update::kRegApField, value.c_str(), true); 179 if (!work_item_list->Do()) { 180 work_item_list->Rollback(); 181 return false; 182 } 183 return true; 184 } 185 186 // Returns the key path of "ap" key, e.g.: 187 // Google\Update\ClientState\<kTestProductGuid> 188 std::wstring GetApKeyPath() { 189 std::wstring reg_key(google_update::kRegPathClientState); 190 reg_key.append(L"\\"); 191 reg_key.append(kTestProductGuid); 192 return reg_key; 193 } 194 195 // Utility method to read "ap" key value 196 std::wstring ReadApKeyValue() { 197 RegKey key; 198 std::wstring ap_key_value; 199 std::wstring reg_key = GetApKeyPath(); 200 if (key.Open(HKEY_CURRENT_USER, reg_key.c_str(), KEY_ALL_ACCESS) == 201 ERROR_SUCCESS) { 202 key.ReadValue(google_update::kRegApField, &ap_key_value); 203 } 204 205 return ap_key_value; 206 } 207 208 registry_util::RegistryOverrideManager registry_overrides_; 209 }; 210 211 } // namespace 212 213 // Verify that we return success on no registration (which means stable), 214 // whether per-system or per-user install. 215 TEST_F(GoogleUpdateSettingsTest, CurrentChromeChannelAbsent) { 216 // Per-system first. 217 string16 channel; 218 EXPECT_TRUE(GoogleUpdateSettings::GetChromeChannelAndModifiers(true, 219 &channel)); 220 EXPECT_STREQ(L"", channel.c_str()); 221 222 // Then per-user. 223 EXPECT_TRUE(GoogleUpdateSettings::GetChromeChannelAndModifiers(false, 224 &channel)); 225 EXPECT_STREQ(L"", channel.c_str()); 226 } 227 228 // Test an empty Ap key for system and user. 229 TEST_F(GoogleUpdateSettingsTest, CurrentChromeChannelEmptySystem) { 230 SetApField(SYSTEM_INSTALL, L""); 231 string16 channel; 232 EXPECT_TRUE(GoogleUpdateSettings::GetChromeChannelAndModifiers(true, 233 &channel)); 234 EXPECT_STREQ(L"", channel.c_str()); 235 236 // Per-user lookups still succeed and return empty string. 237 EXPECT_TRUE(GoogleUpdateSettings::GetChromeChannelAndModifiers(false, 238 &channel)); 239 EXPECT_STREQ(L"", channel.c_str()); 240 } 241 242 TEST_F(GoogleUpdateSettingsTest, CurrentChromeChannelEmptyUser) { 243 SetApField(USER_INSTALL, L""); 244 // Per-system lookups still succeed and return empty string. 245 string16 channel; 246 EXPECT_TRUE(GoogleUpdateSettings::GetChromeChannelAndModifiers(true, 247 &channel)); 248 EXPECT_STREQ(L"", channel.c_str()); 249 250 // Per-user lookup should succeed. 251 EXPECT_TRUE(GoogleUpdateSettings::GetChromeChannelAndModifiers(false, 252 &channel)); 253 EXPECT_STREQ(L"", channel.c_str()); 254 } 255 256 TEST_F(GoogleUpdateSettingsTest, CurrentChromeChannelVariousApValuesSystem) { 257 TestCurrentChromeChannelWithVariousApValues(SYSTEM_INSTALL); 258 } 259 260 TEST_F(GoogleUpdateSettingsTest, CurrentChromeChannelVariousApValuesUser) { 261 TestCurrentChromeChannelWithVariousApValues(USER_INSTALL); 262 } 263 264 // Run through all combinations of diff vs. full install, single vs. multi 265 // install, success and failure results, and a fistful of initial "ap" values 266 // checking that the expected final "ap" value is generated by 267 // GoogleUpdateSettings::UpdateGoogleUpdateApKey. 268 TEST_F(GoogleUpdateSettingsTest, UpdateGoogleUpdateApKey) { 269 const installer::ArchiveType archive_types[] = { 270 installer::UNKNOWN_ARCHIVE_TYPE, 271 installer::FULL_ARCHIVE_TYPE, 272 installer::INCREMENTAL_ARCHIVE_TYPE 273 }; 274 const int results[] = { 275 installer::FIRST_INSTALL_SUCCESS, 276 installer::INSTALL_FAILED 277 }; 278 const wchar_t* const plain[] = { 279 L"", 280 L"1.1", 281 L"1.1-dev" 282 }; 283 const wchar_t* const full[] = { 284 L"-full", 285 L"1.1-full", 286 L"1.1-dev-full" 287 }; 288 COMPILE_ASSERT(arraysize(full) == arraysize(plain), bad_full_array_size); 289 const wchar_t* const multifail[] = { 290 L"-multifail", 291 L"1.1-multifail", 292 L"1.1-dev-multifail" 293 }; 294 COMPILE_ASSERT(arraysize(multifail) == arraysize(plain), 295 bad_multifail_array_size); 296 const wchar_t* const multifail_full[] = { 297 L"-multifail-full", 298 L"1.1-multifail-full", 299 L"1.1-dev-multifail-full" 300 }; 301 COMPILE_ASSERT(arraysize(multifail_full) == arraysize(plain), 302 bad_multifail_full_array_size); 303 const wchar_t* const* input_arrays[] = { 304 plain, 305 full, 306 multifail, 307 multifail_full 308 }; 309 ChannelInfo v; 310 for (int type_idx = 0; type_idx < arraysize(archive_types); ++type_idx) { 311 const installer::ArchiveType archive_type = archive_types[type_idx]; 312 for (int result_idx = 0; result_idx < arraysize(results); ++result_idx) { 313 const int result = results[result_idx]; 314 // The archive type will/must always be known on install success. 315 if (archive_type == installer::UNKNOWN_ARCHIVE_TYPE && 316 result == installer::FIRST_INSTALL_SUCCESS) { 317 continue; 318 } 319 const wchar_t* const* outputs = NULL; 320 if (result == installer::FIRST_INSTALL_SUCCESS || 321 archive_type == installer::FULL_ARCHIVE_TYPE) { 322 outputs = plain; 323 } else if (archive_type == installer::INCREMENTAL_ARCHIVE_TYPE) { 324 outputs = full; 325 } // else if (archive_type == UNKNOWN) see below 326 327 for (int inputs_idx = 0; inputs_idx < arraysize(input_arrays); 328 ++inputs_idx) { 329 const wchar_t* const* inputs = input_arrays[inputs_idx]; 330 if (archive_type == installer::UNKNOWN_ARCHIVE_TYPE) { 331 // "-full" is untouched if the archive type is unknown. 332 // "-multifail" is unconditionally removed. 333 if (inputs == full || inputs == multifail_full) 334 outputs = full; 335 else 336 outputs = plain; 337 } 338 for (int input_idx = 0; input_idx < arraysize(plain); ++input_idx) { 339 const wchar_t* input = inputs[input_idx]; 340 const wchar_t* output = outputs[input_idx]; 341 342 v.set_value(input); 343 if (output == v.value()) { 344 EXPECT_FALSE(GoogleUpdateSettings::UpdateGoogleUpdateApKey( 345 archive_type, result, &v)) 346 << "archive_type: " << archive_type 347 << ", result: " << result 348 << ", input ap value: " << input; 349 } else { 350 EXPECT_TRUE(GoogleUpdateSettings::UpdateGoogleUpdateApKey( 351 archive_type, result, &v)) 352 << "archive_type: " << archive_type 353 << ", result: " << result 354 << ", input ap value: " << input; 355 } 356 EXPECT_EQ(output, v.value()) 357 << "archive_type: " << archive_type 358 << ", result: " << result 359 << ", input ap value: " << input; 360 } 361 } 362 } 363 } 364 } 365 366 TEST_F(GoogleUpdateSettingsTest, UpdateInstallStatusTest) { 367 scoped_ptr<WorkItemList> work_item_list(WorkItem::CreateWorkItemList()); 368 // Test incremental install failure 369 ASSERT_TRUE(CreateApKey(work_item_list.get(), L"")) 370 << "Failed to create ap key."; 371 GoogleUpdateSettings::UpdateInstallStatus(false, 372 installer::INCREMENTAL_ARCHIVE_TYPE, 373 installer::INSTALL_FAILED, 374 kTestProductGuid); 375 EXPECT_STREQ(ReadApKeyValue().c_str(), L"-full"); 376 work_item_list->Rollback(); 377 378 work_item_list.reset(WorkItem::CreateWorkItemList()); 379 // Test incremental install success 380 ASSERT_TRUE(CreateApKey(work_item_list.get(), L"")) 381 << "Failed to create ap key."; 382 GoogleUpdateSettings::UpdateInstallStatus(false, 383 installer::INCREMENTAL_ARCHIVE_TYPE, 384 installer::FIRST_INSTALL_SUCCESS, 385 kTestProductGuid); 386 EXPECT_STREQ(ReadApKeyValue().c_str(), L""); 387 work_item_list->Rollback(); 388 389 work_item_list.reset(WorkItem::CreateWorkItemList()); 390 // Test full install failure 391 ASSERT_TRUE(CreateApKey(work_item_list.get(), L"-full")) 392 << "Failed to create ap key."; 393 GoogleUpdateSettings::UpdateInstallStatus(false, installer::FULL_ARCHIVE_TYPE, 394 installer::INSTALL_FAILED, 395 kTestProductGuid); 396 EXPECT_STREQ(ReadApKeyValue().c_str(), L""); 397 work_item_list->Rollback(); 398 399 work_item_list.reset(WorkItem::CreateWorkItemList()); 400 // Test full install success 401 ASSERT_TRUE(CreateApKey(work_item_list.get(), L"-full")) 402 << "Failed to create ap key."; 403 GoogleUpdateSettings::UpdateInstallStatus(false, installer::FULL_ARCHIVE_TYPE, 404 installer::FIRST_INSTALL_SUCCESS, 405 kTestProductGuid); 406 EXPECT_STREQ(ReadApKeyValue().c_str(), L""); 407 work_item_list->Rollback(); 408 409 work_item_list.reset(WorkItem::CreateWorkItemList()); 410 // Test the case of when "ap" key doesnt exist at all 411 std::wstring ap_key_value = ReadApKeyValue(); 412 std::wstring reg_key = GetApKeyPath(); 413 HKEY reg_root = HKEY_CURRENT_USER; 414 bool ap_key_deleted = false; 415 RegKey key; 416 if (key.Open(HKEY_CURRENT_USER, reg_key.c_str(), KEY_ALL_ACCESS) != 417 ERROR_SUCCESS) { 418 work_item_list->AddCreateRegKeyWorkItem(reg_root, reg_key); 419 ASSERT_TRUE(work_item_list->Do()) << "Failed to create ClientState key."; 420 } else if (key.DeleteValue(google_update::kRegApField) == ERROR_SUCCESS) { 421 ap_key_deleted = true; 422 } 423 // try differential installer 424 GoogleUpdateSettings::UpdateInstallStatus(false, 425 installer::INCREMENTAL_ARCHIVE_TYPE, 426 installer::INSTALL_FAILED, 427 kTestProductGuid); 428 EXPECT_STREQ(ReadApKeyValue().c_str(), L"-full"); 429 // try full installer now 430 GoogleUpdateSettings::UpdateInstallStatus(false, installer::FULL_ARCHIVE_TYPE, 431 installer::INSTALL_FAILED, 432 kTestProductGuid); 433 EXPECT_STREQ(ReadApKeyValue().c_str(), L""); 434 // Now cleanup to leave the system in unchanged state. 435 // - Diff installer creates an ap key if it didnt exist, so delete this ap key 436 // - If we created any reg key path for ap, roll it back 437 // - Finally restore the original value of ap key. 438 key.Open(HKEY_CURRENT_USER, reg_key.c_str(), KEY_ALL_ACCESS); 439 key.DeleteValue(google_update::kRegApField); 440 work_item_list->Rollback(); 441 if (ap_key_deleted) { 442 work_item_list.reset(WorkItem::CreateWorkItemList()); 443 ASSERT_TRUE(CreateApKey(work_item_list.get(), ap_key_value)) 444 << "Failed to restore ap key."; 445 } 446 } 447 448 TEST_F(GoogleUpdateSettingsTest, SetEULAConsent) { 449 using installer::FakeInstallationState; 450 451 const bool multi_install = true; 452 const bool system_level = true; 453 FakeInstallationState machine_state; 454 455 // Chrome is installed. 456 machine_state.AddChrome(system_level, multi_install, 457 new Version(chrome::kChromeVersion)); 458 459 RegKey key; 460 DWORD value; 461 BrowserDistribution* binaries = 462 BrowserDistribution::GetSpecificDistribution( 463 BrowserDistribution::CHROME_BINARIES); 464 BrowserDistribution* chrome = 465 BrowserDistribution::GetSpecificDistribution( 466 BrowserDistribution::CHROME_BROWSER); 467 468 // eulaconsent is set on both the product and the binaries. 469 EXPECT_TRUE(GoogleUpdateSettings::SetEULAConsent(machine_state, chrome, 470 true)); 471 EXPECT_EQ(ERROR_SUCCESS, 472 key.Open(HKEY_LOCAL_MACHINE, binaries->GetStateMediumKey().c_str(), 473 KEY_QUERY_VALUE)); 474 EXPECT_EQ(ERROR_SUCCESS, 475 key.ReadValueDW(google_update::kRegEULAAceptedField, &value)); 476 EXPECT_EQ(1U, value); 477 EXPECT_EQ(ERROR_SUCCESS, 478 key.Open(HKEY_LOCAL_MACHINE, chrome->GetStateMediumKey().c_str(), 479 KEY_QUERY_VALUE)); 480 EXPECT_EQ(ERROR_SUCCESS, 481 key.ReadValueDW(google_update::kRegEULAAceptedField, &value)); 482 EXPECT_EQ(1U, value); 483 } 484 485 // Test that the appropriate default is returned if no update override is 486 // present. 487 TEST_F(GoogleUpdateSettingsTest, GetAppUpdatePolicyNoOverride) { 488 // There are no policies at all. 489 EXPECT_EQ(ERROR_FILE_NOT_FOUND, 490 RegKey().Open(HKEY_LOCAL_MACHINE, kGoogleUpdatePoliciesKey, 491 KEY_QUERY_VALUE)); 492 bool is_overridden = true; 493 EXPECT_EQ(kDefaultUpdatePolicy, 494 GoogleUpdateSettings::GetAppUpdatePolicy(kTestProductGuid, 495 &is_overridden)); 496 EXPECT_FALSE(is_overridden); 497 498 // The policy key exists, but there are no values of interest present. 499 EXPECT_EQ(ERROR_SUCCESS, 500 RegKey().Create(HKEY_LOCAL_MACHINE, kGoogleUpdatePoliciesKey, 501 KEY_SET_VALUE)); 502 EXPECT_EQ(ERROR_SUCCESS, 503 RegKey().Open(HKEY_LOCAL_MACHINE, kGoogleUpdatePoliciesKey, 504 KEY_QUERY_VALUE)); 505 is_overridden = true; 506 EXPECT_EQ(kDefaultUpdatePolicy, 507 GoogleUpdateSettings::GetAppUpdatePolicy(kTestProductGuid, 508 &is_overridden)); 509 EXPECT_FALSE(is_overridden); 510 } 511 512 #if defined(GOOGLE_CHROME_BUILD) 513 514 // Test that the default override is returned if no app-specific override is 515 // present. 516 TEST_F(GoogleUpdateSettingsTest, GetAppUpdatePolicyDefaultOverride) { 517 EXPECT_EQ(ERROR_SUCCESS, 518 RegKey(HKEY_LOCAL_MACHINE, kGoogleUpdatePoliciesKey, 519 KEY_SET_VALUE).WriteValue(kGoogleUpdateUpdateDefault, 520 static_cast<DWORD>(0))); 521 bool is_overridden = true; 522 EXPECT_EQ(GoogleUpdateSettings::UPDATES_DISABLED, 523 GoogleUpdateSettings::GetAppUpdatePolicy(kTestProductGuid, 524 &is_overridden)); 525 EXPECT_FALSE(is_overridden); 526 527 EXPECT_EQ(ERROR_SUCCESS, 528 RegKey(HKEY_LOCAL_MACHINE, kGoogleUpdatePoliciesKey, 529 KEY_SET_VALUE).WriteValue(kGoogleUpdateUpdateDefault, 530 static_cast<DWORD>(1))); 531 is_overridden = true; 532 EXPECT_EQ(GoogleUpdateSettings::AUTOMATIC_UPDATES, 533 GoogleUpdateSettings::GetAppUpdatePolicy(kTestProductGuid, 534 &is_overridden)); 535 EXPECT_FALSE(is_overridden); 536 537 EXPECT_EQ(ERROR_SUCCESS, 538 RegKey(HKEY_LOCAL_MACHINE, kGoogleUpdatePoliciesKey, 539 KEY_SET_VALUE).WriteValue(kGoogleUpdateUpdateDefault, 540 static_cast<DWORD>(2))); 541 is_overridden = true; 542 EXPECT_EQ(GoogleUpdateSettings::MANUAL_UPDATES_ONLY, 543 GoogleUpdateSettings::GetAppUpdatePolicy(kTestProductGuid, 544 &is_overridden)); 545 EXPECT_FALSE(is_overridden); 546 547 EXPECT_EQ(ERROR_SUCCESS, 548 RegKey(HKEY_LOCAL_MACHINE, kGoogleUpdatePoliciesKey, 549 KEY_SET_VALUE).WriteValue(kGoogleUpdateUpdateDefault, 550 static_cast<DWORD>(3))); 551 is_overridden = true; 552 EXPECT_EQ(GoogleUpdateSettings::AUTO_UPDATES_ONLY, 553 GoogleUpdateSettings::GetAppUpdatePolicy(kTestProductGuid, 554 &is_overridden)); 555 EXPECT_FALSE(is_overridden); 556 557 // The default policy should be in force for bogus values. 558 EXPECT_EQ(ERROR_SUCCESS, 559 RegKey(HKEY_LOCAL_MACHINE, kGoogleUpdatePoliciesKey, 560 KEY_SET_VALUE).WriteValue(kGoogleUpdateUpdateDefault, 561 static_cast<DWORD>(4))); 562 is_overridden = true; 563 EXPECT_EQ(kDefaultUpdatePolicy, 564 GoogleUpdateSettings::GetAppUpdatePolicy(kTestProductGuid, 565 &is_overridden)); 566 EXPECT_FALSE(is_overridden); 567 } 568 569 // Test that an app-specific override is used if present. 570 TEST_F(GoogleUpdateSettingsTest, GetAppUpdatePolicyAppOverride) { 571 std::wstring app_policy_value(kGoogleUpdateUpdatePrefix); 572 app_policy_value.append(kTestProductGuid); 573 574 EXPECT_EQ(ERROR_SUCCESS, 575 RegKey(HKEY_LOCAL_MACHINE, kGoogleUpdatePoliciesKey, 576 KEY_SET_VALUE).WriteValue(kGoogleUpdateUpdateDefault, 577 static_cast<DWORD>(1))); 578 EXPECT_EQ(ERROR_SUCCESS, 579 RegKey(HKEY_LOCAL_MACHINE, kGoogleUpdatePoliciesKey, 580 KEY_SET_VALUE).WriteValue(app_policy_value.c_str(), 581 static_cast<DWORD>(0))); 582 bool is_overridden = false; 583 EXPECT_EQ(GoogleUpdateSettings::UPDATES_DISABLED, 584 GoogleUpdateSettings::GetAppUpdatePolicy(kTestProductGuid, 585 &is_overridden)); 586 EXPECT_TRUE(is_overridden); 587 588 EXPECT_EQ(ERROR_SUCCESS, 589 RegKey(HKEY_LOCAL_MACHINE, kGoogleUpdatePoliciesKey, 590 KEY_SET_VALUE).WriteValue(kGoogleUpdateUpdateDefault, 591 static_cast<DWORD>(0))); 592 EXPECT_EQ(ERROR_SUCCESS, 593 RegKey(HKEY_LOCAL_MACHINE, kGoogleUpdatePoliciesKey, 594 KEY_SET_VALUE).WriteValue(app_policy_value.c_str(), 595 static_cast<DWORD>(1))); 596 is_overridden = false; 597 EXPECT_EQ(GoogleUpdateSettings::AUTOMATIC_UPDATES, 598 GoogleUpdateSettings::GetAppUpdatePolicy(kTestProductGuid, 599 &is_overridden)); 600 EXPECT_TRUE(is_overridden); 601 602 EXPECT_EQ(ERROR_SUCCESS, 603 RegKey(HKEY_LOCAL_MACHINE, kGoogleUpdatePoliciesKey, 604 KEY_SET_VALUE).WriteValue(app_policy_value.c_str(), 605 static_cast<DWORD>(2))); 606 is_overridden = false; 607 EXPECT_EQ(GoogleUpdateSettings::MANUAL_UPDATES_ONLY, 608 GoogleUpdateSettings::GetAppUpdatePolicy(kTestProductGuid, 609 &is_overridden)); 610 EXPECT_TRUE(is_overridden); 611 612 EXPECT_EQ(ERROR_SUCCESS, 613 RegKey(HKEY_LOCAL_MACHINE, kGoogleUpdatePoliciesKey, 614 KEY_SET_VALUE).WriteValue(app_policy_value.c_str(), 615 static_cast<DWORD>(3))); 616 is_overridden = false; 617 EXPECT_EQ(GoogleUpdateSettings::AUTO_UPDATES_ONLY, 618 GoogleUpdateSettings::GetAppUpdatePolicy(kTestProductGuid, 619 &is_overridden)); 620 EXPECT_TRUE(is_overridden); 621 622 // The default policy should be in force for bogus values. 623 EXPECT_EQ(ERROR_SUCCESS, 624 RegKey(HKEY_LOCAL_MACHINE, kGoogleUpdatePoliciesKey, 625 KEY_SET_VALUE).WriteValue(app_policy_value.c_str(), 626 static_cast<DWORD>(4))); 627 is_overridden = true; 628 EXPECT_EQ(GoogleUpdateSettings::UPDATES_DISABLED, 629 GoogleUpdateSettings::GetAppUpdatePolicy(kTestProductGuid, 630 &is_overridden)); 631 EXPECT_FALSE(is_overridden); 632 } 633 634 TEST_F(GoogleUpdateSettingsTest, ExperimentsLabelHelperSystem) { 635 TestExperimentsLabelHelper(SYSTEM_INSTALL); 636 } 637 638 TEST_F(GoogleUpdateSettingsTest, ExperimentsLabelHelperUser) { 639 TestExperimentsLabelHelper(USER_INSTALL); 640 } 641 642 #endif // defined(GOOGLE_CHROME_BUILD) 643 644 // Test GoogleUpdateSettings::GetUninstallCommandLine at system- or user-level, 645 // according to the param. 646 class GetUninstallCommandLine : public GoogleUpdateSettingsTest, 647 public testing::WithParamInterface<bool> { 648 protected: 649 static const wchar_t kDummyCommand[]; 650 651 virtual void SetUp() OVERRIDE { 652 GoogleUpdateSettingsTest::SetUp(); 653 system_install_ = GetParam(); 654 root_key_ = system_install_ ? HKEY_LOCAL_MACHINE : HKEY_CURRENT_USER; 655 } 656 657 HKEY root_key_; 658 bool system_install_; 659 }; 660 661 const wchar_t GetUninstallCommandLine::kDummyCommand[] = 662 L"\"goopdate.exe\" /spam"; 663 664 // Tests that GetUninstallCommandLine returns an empty string if there's no 665 // Software\Google\Update key. 666 TEST_P(GetUninstallCommandLine, TestNoKey) { 667 EXPECT_EQ(string16(), 668 GoogleUpdateSettings::GetUninstallCommandLine(system_install_)); 669 } 670 671 // Tests that GetUninstallCommandLine returns an empty string if there's no 672 // UninstallCmdLine value in the Software\Google\Update key. 673 TEST_P(GetUninstallCommandLine, TestNoValue) { 674 RegKey(root_key_, google_update::kRegPathGoogleUpdate, KEY_SET_VALUE); 675 EXPECT_EQ(string16(), 676 GoogleUpdateSettings::GetUninstallCommandLine(system_install_)); 677 } 678 679 // Tests that GetUninstallCommandLine returns an empty string if there's an 680 // empty UninstallCmdLine value in the Software\Google\Update key. 681 TEST_P(GetUninstallCommandLine, TestEmptyValue) { 682 RegKey(root_key_, google_update::kRegPathGoogleUpdate, KEY_SET_VALUE) 683 .WriteValue(google_update::kRegUninstallCmdLine, L""); 684 EXPECT_EQ(string16(), 685 GoogleUpdateSettings::GetUninstallCommandLine(system_install_)); 686 } 687 688 // Tests that GetUninstallCommandLine returns the correct string if there's an 689 // UninstallCmdLine value in the Software\Google\Update key. 690 TEST_P(GetUninstallCommandLine, TestRealValue) { 691 RegKey(root_key_, google_update::kRegPathGoogleUpdate, KEY_SET_VALUE) 692 .WriteValue(google_update::kRegUninstallCmdLine, kDummyCommand); 693 EXPECT_EQ(string16(kDummyCommand), 694 GoogleUpdateSettings::GetUninstallCommandLine(system_install_)); 695 // Make sure that there's no value in the other level (user or system). 696 EXPECT_EQ(string16(), 697 GoogleUpdateSettings::GetUninstallCommandLine(!system_install_)); 698 } 699 700 INSTANTIATE_TEST_CASE_P(GetUninstallCommandLineAtLevel, GetUninstallCommandLine, 701 testing::Bool()); 702 703 // Test GoogleUpdateSettings::GetGoogleUpdateVersion at system- or user-level, 704 // according to the param. 705 class GetGoogleUpdateVersion : public GoogleUpdateSettingsTest, 706 public testing::WithParamInterface<bool> { 707 protected: 708 static const wchar_t kDummyVersion[]; 709 710 virtual void SetUp() OVERRIDE { 711 GoogleUpdateSettingsTest::SetUp(); 712 system_install_ = GetParam(); 713 root_key_ = system_install_ ? HKEY_LOCAL_MACHINE : HKEY_CURRENT_USER; 714 } 715 716 HKEY root_key_; 717 bool system_install_; 718 }; 719 720 const wchar_t GetGoogleUpdateVersion::kDummyVersion[] = L"1.2.3.4"; 721 722 // Tests that GetGoogleUpdateVersion returns an empty string if there's no 723 // Software\Google\Update key. 724 TEST_P(GetGoogleUpdateVersion, TestNoKey) { 725 EXPECT_FALSE( 726 GoogleUpdateSettings::GetGoogleUpdateVersion(system_install_).IsValid()); 727 } 728 729 // Tests that GetGoogleUpdateVersion returns an empty string if there's no 730 // version value in the Software\Google\Update key. 731 TEST_P(GetGoogleUpdateVersion, TestNoValue) { 732 RegKey(root_key_, google_update::kRegPathGoogleUpdate, KEY_SET_VALUE); 733 EXPECT_FALSE( 734 GoogleUpdateSettings::GetGoogleUpdateVersion(system_install_).IsValid()); 735 } 736 737 // Tests that GetGoogleUpdateVersion returns an empty string if there's an 738 // empty version value in the Software\Google\Update key. 739 TEST_P(GetGoogleUpdateVersion, TestEmptyValue) { 740 RegKey(root_key_, google_update::kRegPathGoogleUpdate, KEY_SET_VALUE) 741 .WriteValue(google_update::kRegGoogleUpdateVersion, L""); 742 EXPECT_FALSE( 743 GoogleUpdateSettings::GetGoogleUpdateVersion(system_install_).IsValid()); 744 } 745 746 // Tests that GetGoogleUpdateVersion returns the correct string if there's a 747 // version value in the Software\Google\Update key. 748 TEST_P(GetGoogleUpdateVersion, TestRealValue) { 749 RegKey(root_key_, google_update::kRegPathGoogleUpdate, KEY_SET_VALUE) 750 .WriteValue(google_update::kRegGoogleUpdateVersion, kDummyVersion); 751 Version expected(UTF16ToUTF8(kDummyVersion)); 752 EXPECT_TRUE(expected.Equals( 753 GoogleUpdateSettings::GetGoogleUpdateVersion(system_install_))); 754 // Make sure that there's no value in the other level (user or system). 755 EXPECT_FALSE( 756 GoogleUpdateSettings::GetGoogleUpdateVersion(!system_install_) 757 .IsValid()); 758 } 759 760 INSTANTIATE_TEST_CASE_P(GetGoogleUpdateVersionAtLevel, GetGoogleUpdateVersion, 761 testing::Bool()); 762 763 // Test values for use by the CollectStatsConsent test fixture. 764 class StatsState { 765 public: 766 enum InstallType { 767 SINGLE_INSTALL, 768 MULTI_INSTALL, 769 }; 770 enum StateSetting { 771 NO_SETTING, 772 FALSE_SETTING, 773 TRUE_SETTING, 774 }; 775 struct UserLevelState {}; 776 struct SystemLevelState {}; 777 static const UserLevelState kUserLevel; 778 static const SystemLevelState kSystemLevel; 779 780 StatsState(const UserLevelState&, 781 InstallType install_type, 782 StateSetting state_value) 783 : system_level_(false), 784 multi_install_(install_type == MULTI_INSTALL), 785 state_value_(state_value), 786 state_medium_value_(NO_SETTING) { 787 } 788 StatsState(const SystemLevelState&, 789 InstallType install_type, 790 StateSetting state_value, 791 StateSetting state_medium_value) 792 : system_level_(true), 793 multi_install_(install_type == MULTI_INSTALL), 794 state_value_(state_value), 795 state_medium_value_(state_medium_value) { 796 } 797 bool system_level() const { return system_level_; } 798 bool multi_install() const { return multi_install_; } 799 HKEY root_key() const { 800 return system_level_ ? HKEY_LOCAL_MACHINE : HKEY_CURRENT_USER; 801 } 802 StateSetting state_value() const { return state_value_; } 803 StateSetting state_medium_value() const { 804 return state_medium_value_; 805 } 806 bool is_consent_granted() const { 807 return (system_level_ && state_medium_value_ != NO_SETTING) ? 808 (state_medium_value_ == TRUE_SETTING) : 809 (state_value_ == TRUE_SETTING); 810 } 811 private: 812 bool system_level_; 813 bool multi_install_; 814 StateSetting state_value_; 815 StateSetting state_medium_value_; 816 }; 817 818 const StatsState::UserLevelState StatsState::kUserLevel; 819 const StatsState::SystemLevelState StatsState::kSystemLevel; 820 821 // A value parameterized test for testing the stats collection consent setting. 822 class CollectStatsConsent : public ::testing::TestWithParam<StatsState> { 823 public: 824 static void SetUpTestCase(); 825 static void TearDownTestCase(); 826 protected: 827 virtual void SetUp() OVERRIDE; 828 static void MakeChromeMultiInstall(HKEY root_key); 829 static void ApplySetting(StatsState::StateSetting setting, 830 HKEY root_key, 831 const std::wstring& reg_key); 832 833 static std::wstring* chrome_version_key_; 834 static std::wstring* chrome_state_key_; 835 static std::wstring* chrome_state_medium_key_; 836 static std::wstring* binaries_state_key_; 837 static std::wstring* binaries_state_medium_key_; 838 registry_util::RegistryOverrideManager override_manager_; 839 }; 840 841 std::wstring* CollectStatsConsent::chrome_version_key_; 842 std::wstring* CollectStatsConsent::chrome_state_key_; 843 std::wstring* CollectStatsConsent::chrome_state_medium_key_; 844 std::wstring* CollectStatsConsent::binaries_state_key_; 845 std::wstring* CollectStatsConsent::binaries_state_medium_key_; 846 847 void CollectStatsConsent::SetUpTestCase() { 848 BrowserDistribution* dist = 849 BrowserDistribution::GetSpecificDistribution( 850 BrowserDistribution::CHROME_BROWSER); 851 chrome_version_key_ = new std::wstring(dist->GetVersionKey()); 852 chrome_state_key_ = new std::wstring(dist->GetStateKey()); 853 chrome_state_medium_key_ = new std::wstring(dist->GetStateMediumKey()); 854 855 dist = BrowserDistribution::GetSpecificDistribution( 856 BrowserDistribution::CHROME_BINARIES); 857 binaries_state_key_ = new std::wstring(dist->GetStateKey()); 858 binaries_state_medium_key_ = new std::wstring(dist->GetStateMediumKey()); 859 } 860 861 void CollectStatsConsent::TearDownTestCase() { 862 delete chrome_version_key_; 863 delete chrome_state_key_; 864 delete chrome_state_medium_key_; 865 delete binaries_state_key_; 866 delete binaries_state_medium_key_; 867 } 868 869 // Install the registry override and apply the settings to the registry. 870 void CollectStatsConsent::SetUp() { 871 const StatsState& stats_state = GetParam(); 872 const HKEY root_key = stats_state.root_key(); 873 std::wstring reg_temp_name(stats_state.system_level() ? L"HKLM_" : L"HKCU_"); 874 reg_temp_name += L"CollectStatsConsent"; 875 override_manager_.OverrideRegistry(root_key, reg_temp_name); 876 877 if (stats_state.multi_install()) { 878 MakeChromeMultiInstall(root_key); 879 ApplySetting(stats_state.state_value(), root_key, *binaries_state_key_); 880 ApplySetting(stats_state.state_medium_value(), root_key, 881 *binaries_state_medium_key_); 882 } else { 883 ApplySetting(stats_state.state_value(), root_key, *chrome_state_key_); 884 ApplySetting(stats_state.state_medium_value(), root_key, 885 *chrome_state_medium_key_); 886 } 887 } 888 889 // Write values into the registry so that Chrome is considered to be installed 890 // as multi-install. 891 void CollectStatsConsent::MakeChromeMultiInstall(HKEY root_key) { 892 ASSERT_EQ( 893 ERROR_SUCCESS, 894 RegKey(root_key, chrome_version_key_->c_str(), 895 KEY_SET_VALUE).WriteValue(google_update::kRegVersionField, 896 L"1.2.3.4")); 897 ASSERT_EQ( 898 ERROR_SUCCESS, 899 RegKey(root_key, chrome_state_key_->c_str(), 900 KEY_SET_VALUE).WriteValue(installer::kUninstallArgumentsField, 901 L"--multi-install")); 902 } 903 904 // Write the correct value to represent |setting| in the registry. 905 void CollectStatsConsent::ApplySetting(StatsState::StateSetting setting, 906 HKEY root_key, 907 const std::wstring& reg_key) { 908 if (setting != StatsState::NO_SETTING) { 909 DWORD value = setting != StatsState::FALSE_SETTING ? 1 : 0; 910 ASSERT_EQ( 911 ERROR_SUCCESS, 912 RegKey(root_key, reg_key.c_str(), 913 KEY_SET_VALUE).WriteValue(google_update::kRegUsageStatsField, 914 value)); 915 } 916 } 917 918 // Test that stats consent can be read. 919 TEST_P(CollectStatsConsent, GetCollectStatsConsentAtLevel) { 920 if (GetParam().is_consent_granted()) { 921 EXPECT_TRUE(GoogleUpdateSettings::GetCollectStatsConsentAtLevel( 922 GetParam().system_level())); 923 } else { 924 EXPECT_FALSE(GoogleUpdateSettings::GetCollectStatsConsentAtLevel( 925 GetParam().system_level())); 926 } 927 } 928 929 // Test that stats consent can be flipped to the opposite setting, that the new 930 // setting takes affect, and that the correct registry location is modified. 931 TEST_P(CollectStatsConsent, SetCollectStatsConsentAtLevel) { 932 EXPECT_TRUE(GoogleUpdateSettings::SetCollectStatsConsentAtLevel( 933 GetParam().system_level(), 934 !GetParam().is_consent_granted())); 935 const std::wstring* const reg_keys[] = { 936 chrome_state_key_, 937 chrome_state_medium_key_, 938 binaries_state_key_, 939 binaries_state_medium_key_, 940 }; 941 int key_index = ((GetParam().system_level() ? 1 : 0) + 942 (GetParam().multi_install() ? 2 : 0)); 943 const std::wstring& reg_key = *reg_keys[key_index]; 944 DWORD value = 0; 945 EXPECT_EQ( 946 ERROR_SUCCESS, 947 RegKey(GetParam().root_key(), reg_key.c_str(), 948 KEY_QUERY_VALUE).ReadValueDW(google_update::kRegUsageStatsField, 949 &value)); 950 if (GetParam().is_consent_granted()) { 951 EXPECT_FALSE(GoogleUpdateSettings::GetCollectStatsConsentAtLevel( 952 GetParam().system_level())); 953 EXPECT_EQ(0UL, value); 954 } else { 955 EXPECT_TRUE(GoogleUpdateSettings::GetCollectStatsConsentAtLevel( 956 GetParam().system_level())); 957 EXPECT_EQ(1UL, value); 958 } 959 } 960 961 INSTANTIATE_TEST_CASE_P( 962 UserLevelSingleInstall, 963 CollectStatsConsent, 964 ::testing::Values( 965 StatsState(StatsState::kUserLevel, StatsState::SINGLE_INSTALL, 966 StatsState::NO_SETTING), 967 StatsState(StatsState::kUserLevel, StatsState::SINGLE_INSTALL, 968 StatsState::FALSE_SETTING), 969 StatsState(StatsState::kUserLevel, StatsState::SINGLE_INSTALL, 970 StatsState::TRUE_SETTING))); 971 INSTANTIATE_TEST_CASE_P( 972 UserLevelMultiInstall, 973 CollectStatsConsent, 974 ::testing::Values( 975 StatsState(StatsState::kUserLevel, StatsState::MULTI_INSTALL, 976 StatsState::NO_SETTING), 977 StatsState(StatsState::kUserLevel, StatsState::MULTI_INSTALL, 978 StatsState::FALSE_SETTING), 979 StatsState(StatsState::kUserLevel, StatsState::MULTI_INSTALL, 980 StatsState::TRUE_SETTING))); 981 INSTANTIATE_TEST_CASE_P( 982 SystemLevelSingleInstall, 983 CollectStatsConsent, 984 ::testing::Values( 985 StatsState(StatsState::kSystemLevel, StatsState::SINGLE_INSTALL, 986 StatsState::NO_SETTING, StatsState::NO_SETTING), 987 StatsState(StatsState::kSystemLevel, StatsState::SINGLE_INSTALL, 988 StatsState::NO_SETTING, StatsState::FALSE_SETTING), 989 StatsState(StatsState::kSystemLevel, StatsState::SINGLE_INSTALL, 990 StatsState::NO_SETTING, StatsState::TRUE_SETTING), 991 StatsState(StatsState::kSystemLevel, StatsState::SINGLE_INSTALL, 992 StatsState::FALSE_SETTING, StatsState::NO_SETTING), 993 StatsState(StatsState::kSystemLevel, StatsState::SINGLE_INSTALL, 994 StatsState::FALSE_SETTING, StatsState::FALSE_SETTING), 995 StatsState(StatsState::kSystemLevel, StatsState::SINGLE_INSTALL, 996 StatsState::FALSE_SETTING, StatsState::TRUE_SETTING), 997 StatsState(StatsState::kSystemLevel, StatsState::SINGLE_INSTALL, 998 StatsState::TRUE_SETTING, StatsState::NO_SETTING), 999 StatsState(StatsState::kSystemLevel, StatsState::SINGLE_INSTALL, 1000 StatsState::TRUE_SETTING, StatsState::FALSE_SETTING), 1001 StatsState(StatsState::kSystemLevel, StatsState::SINGLE_INSTALL, 1002 StatsState::TRUE_SETTING, StatsState::TRUE_SETTING))); 1003 INSTANTIATE_TEST_CASE_P( 1004 SystemLevelMultiInstall, 1005 CollectStatsConsent, 1006 ::testing::Values( 1007 StatsState(StatsState::kSystemLevel, StatsState::MULTI_INSTALL, 1008 StatsState::NO_SETTING, StatsState::NO_SETTING), 1009 StatsState(StatsState::kSystemLevel, StatsState::MULTI_INSTALL, 1010 StatsState::NO_SETTING, StatsState::FALSE_SETTING), 1011 StatsState(StatsState::kSystemLevel, StatsState::MULTI_INSTALL, 1012 StatsState::NO_SETTING, StatsState::TRUE_SETTING), 1013 StatsState(StatsState::kSystemLevel, StatsState::MULTI_INSTALL, 1014 StatsState::FALSE_SETTING, StatsState::NO_SETTING), 1015 StatsState(StatsState::kSystemLevel, StatsState::MULTI_INSTALL, 1016 StatsState::FALSE_SETTING, StatsState::FALSE_SETTING), 1017 StatsState(StatsState::kSystemLevel, StatsState::MULTI_INSTALL, 1018 StatsState::FALSE_SETTING, StatsState::TRUE_SETTING), 1019 StatsState(StatsState::kSystemLevel, StatsState::MULTI_INSTALL, 1020 StatsState::TRUE_SETTING, StatsState::NO_SETTING), 1021 StatsState(StatsState::kSystemLevel, StatsState::MULTI_INSTALL, 1022 StatsState::TRUE_SETTING, StatsState::FALSE_SETTING), 1023 StatsState(StatsState::kSystemLevel, StatsState::MULTI_INSTALL, 1024 StatsState::TRUE_SETTING, StatsState::TRUE_SETTING))); 1025
