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