chrome/browser/chrome_elf_init_unittest_win.cc

   1 // Copyright 2014 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/browser/chrome_elf_init_win.h"
   6
   7 #include "base/basictypes.h"
   8 #include "base/memory/scoped_ptr.h"
   9 #include "base/metrics/field_trial.h"
  10 #include "base/strings/string16.h"
  11 #include "base/strings/utf_string_conversions.h"
  12 #include "base/test/test_reg_util_win.h"
  13 #include "chrome/common/chrome_version_info.h"
  14 #include "chrome_elf/chrome_elf_constants.h"
  15 #include "components/variations/entropy_provider.h"
  16 #include "components/variations/variations_associated_data.h"
  17 #include "testing/gtest/include/gtest/gtest.h"
  18 #include "version.h"  // NOLINT
  19
  20 namespace {
  21
  22 const char kBrowserBlacklistTrialEnabledGroupName[] = "Enabled";
  23
  24 class ChromeBlacklistTrialTest : public testing::Test {
  25  protected:
  26   ChromeBlacklistTrialTest() {}
  27   virtual ~ChromeBlacklistTrialTest() {}
  28
  29   virtual void SetUp() OVERRIDE {
  30     testing::Test::SetUp();
  31
  32     override_manager_.OverrideRegistry(HKEY_CURRENT_USER,
  33                                        L"browser_blacklist_test");
  34
  35     blacklist_registry_key_.reset(
  36         new base::win::RegKey(HKEY_CURRENT_USER,
  37                               blacklist::kRegistryBeaconPath,
  38                               KEY_QUERY_VALUE | KEY_SET_VALUE));
  39   }
  40
  41   DWORD GetBlacklistState() {
  42     DWORD blacklist_state = blacklist::BLACKLIST_STATE_MAX;
  43     blacklist_registry_key_->ReadValueDW(blacklist::kBeaconState,
  44                                          &blacklist_state);
  45
  46     return blacklist_state;
  47   }
  48
  49   base::string16 GetBlacklistVersion() {
  50     base::string16 blacklist_version;
  51     blacklist_registry_key_->ReadValue(blacklist::kBeaconVersion,
  52                                        &blacklist_version);
  53
  54     return blacklist_version;
  55   }
  56
  57   scoped_ptr<base::win::RegKey> blacklist_registry_key_;
  58   registry_util::RegistryOverrideManager override_manager_;
  59
  60  private:
  61   DISALLOW_COPY_AND_ASSIGN(ChromeBlacklistTrialTest);
  62 };
  63
  64 // Ensure that the default trial sets up the blacklist beacons.
  65 TEST_F(ChromeBlacklistTrialTest, DefaultRun) {
  66   // Set some dummy values as beacons.
  67   blacklist_registry_key_->WriteValue(blacklist::kBeaconState,
  68                                       blacklist::BLACKLIST_DISABLED);
  69   blacklist_registry_key_->WriteValue(blacklist::kBeaconVersion, L"Data");
  70
  71   // This setup code should result in the default group, which should have
  72   // the blacklist set up.
  73   InitializeChromeElf();
  74
  75   // Ensure the beacon values are now correct, indicating the
  76   // blacklist beacon was setup.
  77   ASSERT_EQ(blacklist::BLACKLIST_ENABLED, GetBlacklistState());
  78   chrome::VersionInfo version_info;
  79   base::string16 version(base::UTF8ToUTF16(version_info.Version()));
  80   ASSERT_EQ(version, GetBlacklistVersion());
  81 }
  82
  83 // Ensure that the blacklist is disabled for any users in the
  84 // "BlacklistDisabled" finch group.
  85 TEST_F(ChromeBlacklistTrialTest, BlacklistDisabledRun) {
  86   // Set the beacons to enabled values.
  87   blacklist_registry_key_->WriteValue(blacklist::kBeaconState,
  88                                       blacklist::BLACKLIST_ENABLED);
  89   blacklist_registry_key_->WriteValue(blacklist::kBeaconVersion, L"Data");
  90
  91   // Create the field trial with the blacklist disabled group.
  92   base::FieldTrialList field_trial_list(
  93     new metrics::SHA1EntropyProvider("test"));
  94
  95   scoped_refptr<base::FieldTrial> trial(
  96     base::FieldTrialList::CreateFieldTrial(
  97       kBrowserBlacklistTrialName, kBrowserBlacklistTrialDisabledGroupName));
  98
  99   // This setup code should now delete any existing blacklist beacons.
 100   InitializeChromeElf();
 101
 102   // Ensure invalid values are returned to indicate that the beacon
 103   // values are indeed gone.
 104   ASSERT_EQ(blacklist::BLACKLIST_STATE_MAX, GetBlacklistState());
 105   ASSERT_EQ(base::string16(), GetBlacklistVersion());
 106 }
 107
 108 TEST_F(ChromeBlacklistTrialTest, VerifyFirstRun) {
 109   BrowserBlacklistBeaconSetup();
 110
 111   // Verify the state is properly set after the first run.
 112   ASSERT_EQ(blacklist::BLACKLIST_ENABLED, GetBlacklistState());
 113
 114   chrome::VersionInfo version_info;
 115   base::string16 version(base::UTF8ToUTF16(version_info.Version()));
 116   ASSERT_EQ(version, GetBlacklistVersion());
 117 }
 118
 119 TEST_F(ChromeBlacklistTrialTest, BlacklistFailed) {
 120   // Ensure when the blacklist set up failed we set the state to disabled for
 121   // future runs.
 122   blacklist_registry_key_->WriteValue(blacklist::kBeaconVersion,
 123                                       TEXT(CHROME_VERSION_STRING));
 124   blacklist_registry_key_->WriteValue(blacklist::kBeaconState,
 125                                       blacklist::BLACKLIST_SETUP_FAILED);
 126
 127   BrowserBlacklistBeaconSetup();
 128
 129   ASSERT_EQ(blacklist::BLACKLIST_DISABLED, GetBlacklistState());
 130 }
 131
 132 TEST_F(ChromeBlacklistTrialTest, VersionChanged) {
 133   // Mark the blacklist as disabled for an older version, it should
 134   // get enabled for this new version.  Also record a non-zero number of
 135   // setup failures, which should be reset to zero.
 136   blacklist_registry_key_->WriteValue(blacklist::kBeaconVersion,
 137                                       L"old_version");
 138   blacklist_registry_key_->WriteValue(blacklist::kBeaconState,
 139                                       blacklist::BLACKLIST_DISABLED);
 140   blacklist_registry_key_->WriteValue(blacklist::kBeaconAttemptCount,
 141                                       blacklist::kBeaconMaxAttempts);
 142
 143   BrowserBlacklistBeaconSetup();
 144
 145   // The beacon should now be marked as enabled for the current version.
 146   ASSERT_EQ(blacklist::BLACKLIST_ENABLED, GetBlacklistState());
 147
 148   chrome::VersionInfo version_info;
 149   base::string16 expected_version(base::UTF8ToUTF16(version_info.Version()));
 150   ASSERT_EQ(expected_version, GetBlacklistVersion());
 151
 152   // The counter should be reset.
 153   DWORD attempt_count = blacklist::kBeaconMaxAttempts;
 154   blacklist_registry_key_->ReadValueDW(blacklist::kBeaconAttemptCount,
 155                                        &attempt_count);
 156   ASSERT_EQ(static_cast<DWORD>(0), attempt_count);
 157 }
 158
 159 TEST_F(ChromeBlacklistTrialTest, AddFinchBlacklistToRegistry) {
 160   // Create the field trial with the blacklist enabled group.
 161   base::FieldTrialList field_trial_list(
 162       new metrics::SHA1EntropyProvider("test"));
 163
 164   scoped_refptr<base::FieldTrial> trial(base::FieldTrialList::CreateFieldTrial(
 165       kBrowserBlacklistTrialName, kBrowserBlacklistTrialEnabledGroupName));
 166
 167   // Set up the trial with the desired parameters.
 168   std::map<std::string, std::string> desired_params;
 169   desired_params["TestDllName1"] = "TestDll1.dll";
 170   desired_params["TestDllName2"] = "TestDll2.dll";
 171
 172   variations::AssociateVariationParams(
 173       kBrowserBlacklistTrialName,
 174       kBrowserBlacklistTrialEnabledGroupName,
 175       desired_params);
 176
 177   // This should add the dlls in those parameters to the registry.
 178   AddFinchBlacklistToRegistry();
 179
 180   // Check that all the values in desired_params were added to the registry.
 181   base::win::RegKey finch_blacklist_registry_key(
 182       HKEY_CURRENT_USER,
 183       blacklist::kRegistryFinchListPath,
 184       KEY_QUERY_VALUE | KEY_SET_VALUE);
 185
 186   ASSERT_EQ(desired_params.size(),
 187             finch_blacklist_registry_key.GetValueCount());
 188
 189   for (std::map<std::string, std::string>::iterator it = desired_params.begin();
 190        it != desired_params.end();
 191        ++it) {
 192     std::wstring name = base::UTF8ToWide(it->first);
 193     ASSERT_TRUE(finch_blacklist_registry_key.HasValue(name.c_str()));
 194   }
 195 }
 196
 197 }  // namespace