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