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_elf/chrome_elf_constants.h"
  14 #include "components/variations/entropy_provider.h"
  15 #include "components/variations/variations_associated_data.h"
  16 #include "components/version_info/version_info.h"
  17 #include "content/public/test/test_browser_thread_bundle.h"
  18 #include "testing/gtest/include/gtest/gtest.h"
  19 #include "version.h"  // NOLINT
  20
  21 namespace {
  22
  23 const char kBrowserBlacklistTrialEnabledGroupName[] = "Enabled";
  24
  25 class ChromeBlacklistTrialTest : public testing::Test {
  26  protected:
  27   ChromeBlacklistTrialTest() {}
  28   ~ChromeBlacklistTrialTest() override {}
  29
  30   void SetUp() override {
  31     testing::Test::SetUp();
  32
  33     override_manager_.OverrideRegistry(HKEY_CURRENT_USER);
  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   content::TestBrowserThreadBundle test_browser_thread_bundle_;
  60
  61  private:
  62   DISALLOW_COPY_AND_ASSIGN(ChromeBlacklistTrialTest);
  63 };
  64
  65 // Ensure that the default trial sets up the blacklist beacons.
  66 TEST_F(ChromeBlacklistTrialTest, DefaultRun) {
  67   // Set some dummy values as beacons.
  68   blacklist_registry_key_->WriteValue(blacklist::kBeaconState,
  69                                       blacklist::BLACKLIST_DISABLED);
  70   blacklist_registry_key_->WriteValue(blacklist::kBeaconVersion, L"Data");
  71
  72   // This setup code should result in the default group, which should have
  73   // the blacklist set up.
  74   InitializeChromeElf();
  75
  76   // Ensure the beacon values are now correct, indicating the
  77   // blacklist beacon was setup.
  78   ASSERT_EQ(blacklist::BLACKLIST_ENABLED, GetBlacklistState());
  79   base::string16 version(base::UTF8ToUTF16(version_info::GetVersionNumber()));
  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   base::string16 version(base::UTF8ToUTF16(version_info::GetVersionNumber()));
 115   ASSERT_EQ(version, GetBlacklistVersion());
 116 }
 117
 118 TEST_F(ChromeBlacklistTrialTest, BlacklistFailed) {
 119   // Ensure when the blacklist set up failed we set the state to disabled for
 120   // future runs.
 121   blacklist_registry_key_->WriteValue(blacklist::kBeaconVersion,
 122                                       TEXT(CHROME_VERSION_STRING));
 123   blacklist_registry_key_->WriteValue(blacklist::kBeaconState,
 124                                       blacklist::BLACKLIST_SETUP_FAILED);
 125
 126   BrowserBlacklistBeaconSetup();
 127
 128   ASSERT_EQ(blacklist::BLACKLIST_DISABLED, GetBlacklistState());
 129 }
 130
 131 TEST_F(ChromeBlacklistTrialTest, VersionChanged) {
 132   // Mark the blacklist as disabled for an older version, it should
 133   // get enabled for this new version.  Also record a non-zero number of
 134   // setup failures, which should be reset to zero.
 135   blacklist_registry_key_->WriteValue(blacklist::kBeaconVersion,
 136                                       L"old_version");
 137   blacklist_registry_key_->WriteValue(blacklist::kBeaconState,
 138                                       blacklist::BLACKLIST_DISABLED);
 139   blacklist_registry_key_->WriteValue(blacklist::kBeaconAttemptCount,
 140                                       blacklist::kBeaconMaxAttempts);
 141
 142   BrowserBlacklistBeaconSetup();
 143
 144   // The beacon should now be marked as enabled for the current version.
 145   ASSERT_EQ(blacklist::BLACKLIST_ENABLED, GetBlacklistState());
 146
 147   base::string16 expected_version(
 148       base::UTF8ToUTF16(version_info::GetVersionNumber()));
 149   ASSERT_EQ(expected_version, GetBlacklistVersion());
 150
 151   // The counter should be reset.
 152   DWORD attempt_count = blacklist::kBeaconMaxAttempts;
 153   blacklist_registry_key_->ReadValueDW(blacklist::kBeaconAttemptCount,
 154                                        &attempt_count);
 155   ASSERT_EQ(static_cast<DWORD>(0), attempt_count);
 156 }
 157
 158 TEST_F(ChromeBlacklistTrialTest, AddFinchBlacklistToRegistry) {
 159   // Create the field trial with the blacklist enabled group.
 160   base::FieldTrialList field_trial_list(
 161       new metrics::SHA1EntropyProvider("test"));
 162
 163   scoped_refptr<base::FieldTrial> trial(base::FieldTrialList::CreateFieldTrial(
 164       kBrowserBlacklistTrialName, kBrowserBlacklistTrialEnabledGroupName));
 165
 166   // Set up the trial with the desired parameters.
 167   std::map<std::string, std::string> desired_params;
 168   desired_params["TestDllName1"] = "TestDll1.dll";
 169   desired_params["TestDllName2"] = "TestDll2.dll";
 170
 171   variations::AssociateVariationParams(
 172       kBrowserBlacklistTrialName,
 173       kBrowserBlacklistTrialEnabledGroupName,
 174       desired_params);
 175
 176   // This should add the dlls in those parameters to the registry.
 177   AddFinchBlacklistToRegistry();
 178
 179   // Check that all the values in desired_params were added to the registry.
 180   base::win::RegKey finch_blacklist_registry_key(
 181       HKEY_CURRENT_USER,
 182       blacklist::kRegistryFinchListPath,
 183       KEY_QUERY_VALUE | KEY_SET_VALUE);
 184
 185   ASSERT_EQ(desired_params.size(),
 186             finch_blacklist_registry_key.GetValueCount());
 187
 188   for (std::map<std::string, std::string>::iterator it = desired_params.begin();
 189        it != desired_params.end();
 190        ++it) {
 191     std::wstring name = base::UTF8ToWide(it->first);
 192     ASSERT_TRUE(finch_blacklist_registry_key.HasValue(name.c_str()));
 193   }
 194 }
 195
 196 }  // namespace