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