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