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