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