| OLD | NEW |
|---|
| (Empty) |
| 1 // Copyright 2013 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 "base/memory/scoped_ptr.h" | |
| 6 #include "base/metrics/histogram.h" | |
| 7 #include "base/metrics/statistics_recorder.h" | |
| 8 #include "base/prefs/scoped_user_pref_update.h" | |
| 9 #include "base/prefs/testing_pref_service.h" | |
| 10 #include "base/values.h" | |
| 11 #include "chrome/browser/prefs/pref_metrics_service.h" | |
| 12 #include "chrome/common/pref_names.h" | |
| 13 #include "chrome/test/base/testing_browser_process.h" | |
| 14 #include "chrome/test/base/testing_pref_service_syncable.h" | |
| 15 #include "chrome/test/base/testing_profile.h" | |
| 16 #include "chrome/test/base/testing_profile_manager.h" | |
| 17 #include "components/user_prefs/pref_registry_syncable.h" | |
| 18 #include "testing/gtest/include/gtest/gtest.h" | |
| 19 | |
| 20 namespace { | |
| 21 | |
| 22 // TestingProfile may register some real preferences; to avoid interference, | |
| 23 // define fake preferences for testing. | |
| 24 const char* kTrackedPrefs[] = { | |
| 25 "pref_metrics_service_test.pref1", | |
| 26 "pref_metrics_service_test.pref2", | |
| 27 }; | |
| 28 | |
| 29 const int kTrackedPrefCount = arraysize(kTrackedPrefs); | |
| 30 | |
| 31 const char kTestDeviceId[] = "test_device_id1"; | |
| 32 const char kOtherTestDeviceId[] = "test_device_id2"; | |
| 33 | |
| 34 } // namespace | |
| 35 | |
| 36 class PrefMetricsServiceTest : public testing::Test { | |
| 37 protected: | |
| 38 virtual void SetUp() { | |
| 39 pref1_changed_ = 0; | |
| 40 pref2_changed_ = 0; | |
| 41 pref1_cleared_ = 0; | |
| 42 pref2_cleared_ = 0; | |
| 43 pref1_initialized_ = 0; | |
| 44 pref2_initialized_ = 0; | |
| 45 pref1_migrated_ = 0; | |
| 46 pref2_migrated_ = 0; | |
| 47 pref1_unchanged_ = 0; | |
| 48 pref2_unchanged_ = 0; | |
| 49 | |
| 50 base::StatisticsRecorder::Initialize(); | |
| 51 | |
| 52 // Reset and set up the profile manager. | |
| 53 profile_manager_.reset(new TestingProfileManager( | |
| 54 TestingBrowserProcess::GetGlobal())); | |
| 55 ASSERT_TRUE(profile_manager_->SetUp()); | |
| 56 | |
| 57 // Check that PrefMetricsService behaves with a '.' in the profile name. | |
| 58 profile_ = profile_manager_->CreateTestingProfile("test@example.com"); | |
| 59 | |
| 60 profile_name_ = profile_->GetPath().AsUTF8Unsafe(); | |
| 61 | |
| 62 prefs_ = profile_->GetTestingPrefService(); | |
| 63 | |
| 64 // Register our test-only tracked prefs as string values. | |
| 65 for (int i = 0; i < kTrackedPrefCount; ++i) { | |
| 66 prefs_->registry()->RegisterStringPref( | |
| 67 kTrackedPrefs[i], | |
| 68 "test_default_value", | |
| 69 user_prefs::PrefRegistrySyncable::SYNCABLE_PREF); | |
| 70 } | |
| 71 | |
| 72 // Initialize pref in local state that holds hashed values. | |
| 73 PrefMetricsService::RegisterPrefs(local_state_.registry()); | |
| 74 | |
| 75 // Update global counts in case another test left stray samples. | |
| 76 UpdateHistogramSamples(); | |
| 77 } | |
| 78 | |
| 79 scoped_ptr<PrefMetricsService> CreatePrefMetricsService( | |
| 80 const std::string& device_id) { | |
| 81 return scoped_ptr<PrefMetricsService>( | |
| 82 new PrefMetricsService(profile_, | |
| 83 &local_state_, | |
| 84 device_id, | |
| 85 kTrackedPrefs, | |
| 86 kTrackedPrefCount)); | |
| 87 } | |
| 88 | |
| 89 std::string GetHashedPrefValue(PrefMetricsService* service, | |
| 90 const char* path, | |
| 91 const base::Value* value) { | |
| 92 return service->GetHashedPrefValue( | |
| 93 path, value, PrefMetricsService::HASHED_PREF_STYLE_NEW); | |
| 94 } | |
| 95 | |
| 96 std::string GetOldStyleHashedPrefValue(PrefMetricsService* service, | |
| 97 const char* path, | |
| 98 const base::Value* value) { | |
| 99 return service->GetHashedPrefValue( | |
| 100 path, value, PrefMetricsService::HASHED_PREF_STYLE_DEPRECATED); | |
| 101 } | |
| 102 | |
| 103 void GetSamples(const char* histogram_name, int* bucket1, int* bucket2) { | |
| 104 base::HistogramBase* histogram = | |
| 105 base::StatisticsRecorder::FindHistogram(histogram_name); | |
| 106 if (!histogram) { | |
| 107 *bucket1 = 0; | |
| 108 *bucket2 = 0; | |
| 109 } else { | |
| 110 scoped_ptr<base::HistogramSamples> samples(histogram->SnapshotSamples()); | |
| 111 *bucket1 = samples->GetCount(0); | |
| 112 *bucket2 = samples->GetCount(1); | |
| 113 } | |
| 114 } | |
| 115 | |
| 116 void UpdateHistogramSamples() { | |
| 117 int changed1, changed2; | |
| 118 GetSamples("Settings.TrackedPreferenceChanged", &changed1, &changed2); | |
| 119 pref1_changed_ = changed1 - pref1_changed_total; | |
| 120 pref2_changed_ = changed2 - pref2_changed_total; | |
| 121 pref1_changed_total = changed1; | |
| 122 pref2_changed_total = changed2; | |
| 123 | |
| 124 int cleared1, cleared2; | |
| 125 GetSamples("Settings.TrackedPreferenceCleared", &cleared1, &cleared2); | |
| 126 pref1_cleared_ = cleared1 - pref1_cleared_total; | |
| 127 pref2_cleared_ = cleared2 - pref2_cleared_total; | |
| 128 pref1_cleared_total = cleared1; | |
| 129 pref2_cleared_total = cleared2; | |
| 130 | |
| 131 int inited1, inited2; | |
| 132 GetSamples("Settings.TrackedPreferenceInitialized", &inited1, &inited2); | |
| 133 pref1_initialized_ = inited1 - pref1_initialized_total; | |
| 134 pref2_initialized_ = inited2 - pref2_initialized_total; | |
| 135 pref1_initialized_total = inited1; | |
| 136 pref2_initialized_total = inited2; | |
| 137 | |
| 138 int migrated1, migrated2; | |
| 139 GetSamples("Settings.TrackedPreferenceMigrated", &migrated1, &migrated2); | |
| 140 pref1_migrated_ = migrated1 - pref1_migrated_total; | |
| 141 pref2_migrated_ = migrated2 - pref2_migrated_total; | |
| 142 pref1_migrated_total = migrated1; | |
| 143 pref2_migrated_total = migrated2; | |
| 144 | |
| 145 int unchanged1, unchanged2; | |
| 146 GetSamples("Settings.TrackedPreferenceUnchanged", &unchanged1, &unchanged2); | |
| 147 pref1_unchanged_ = unchanged1 - pref1_unchanged_total; | |
| 148 pref2_unchanged_ = unchanged2 - pref2_unchanged_total; | |
| 149 pref1_unchanged_total = unchanged1; | |
| 150 pref2_unchanged_total = unchanged2; | |
| 151 } | |
| 152 | |
| 153 TestingProfile* profile_; | |
| 154 std::string profile_name_; | |
| 155 scoped_ptr<TestingProfileManager> profile_manager_; | |
| 156 TestingPrefServiceSyncable* prefs_; | |
| 157 TestingPrefServiceSimple local_state_; | |
| 158 | |
| 159 // Since histogram samples are recorded by a global StatisticsRecorder, we | |
| 160 // need to maintain total counts so we can compute deltas for individual | |
| 161 // tests. | |
| 162 static int pref1_changed_total; | |
| 163 static int pref2_changed_total; | |
| 164 static int pref1_cleared_total; | |
| 165 static int pref2_cleared_total; | |
| 166 static int pref1_initialized_total; | |
| 167 static int pref2_initialized_total; | |
| 168 static int pref1_migrated_total; | |
| 169 static int pref2_migrated_total; | |
| 170 static int pref1_unchanged_total; | |
| 171 static int pref2_unchanged_total; | |
| 172 | |
| 173 // Counts of samples recorded since UpdateHistogramSamples was last called. | |
| 174 int pref1_changed_; | |
| 175 int pref2_changed_; | |
| 176 int pref1_cleared_; | |
| 177 int pref2_cleared_; | |
| 178 int pref1_initialized_; | |
| 179 int pref2_initialized_; | |
| 180 int pref1_migrated_; | |
| 181 int pref2_migrated_; | |
| 182 int pref1_unchanged_; | |
| 183 int pref2_unchanged_; | |
| 184 }; | |
| 185 | |
| 186 int PrefMetricsServiceTest::pref1_changed_total; | |
| 187 int PrefMetricsServiceTest::pref2_changed_total; | |
| 188 int PrefMetricsServiceTest::pref1_cleared_total; | |
| 189 int PrefMetricsServiceTest::pref2_cleared_total; | |
| 190 int PrefMetricsServiceTest::pref1_initialized_total; | |
| 191 int PrefMetricsServiceTest::pref2_initialized_total; | |
| 192 int PrefMetricsServiceTest::pref1_migrated_total; | |
| 193 int PrefMetricsServiceTest::pref2_migrated_total; | |
| 194 int PrefMetricsServiceTest::pref1_unchanged_total; | |
| 195 int PrefMetricsServiceTest::pref2_unchanged_total; | |
| 196 | |
| 197 TEST_F(PrefMetricsServiceTest, StartupNoUserPref) { | |
| 198 // Local state is empty and no user prefs are set. We should still have | |
| 199 // initialized all preferences once. | |
| 200 scoped_ptr<PrefMetricsService> service = | |
| 201 CreatePrefMetricsService(kTestDeviceId); | |
| 202 UpdateHistogramSamples(); | |
| 203 EXPECT_EQ(0, pref1_changed_); | |
| 204 EXPECT_EQ(0, pref2_changed_); | |
| 205 EXPECT_EQ(0, pref1_cleared_); | |
| 206 EXPECT_EQ(0, pref2_cleared_); | |
| 207 EXPECT_EQ(1, pref1_initialized_); | |
| 208 EXPECT_EQ(1, pref2_initialized_); | |
| 209 EXPECT_EQ(0, pref1_migrated_); | |
| 210 EXPECT_EQ(0, pref2_migrated_); | |
| 211 EXPECT_EQ(0, pref1_unchanged_); | |
| 212 EXPECT_EQ(0, pref2_unchanged_); | |
| 213 | |
| 214 // Ensure that each pref got a hash even though their value is NULL (i.e., | |
| 215 // empty). | |
| 216 const DictionaryValue* root_dictionary = | |
| 217 local_state_.GetDictionary(prefs::kProfilePreferenceHashes); | |
| 218 ASSERT_TRUE(root_dictionary != NULL); | |
| 219 | |
| 220 const DictionaryValue* child_dictionary = NULL; | |
| 221 ASSERT_TRUE(root_dictionary->GetDictionaryWithoutPathExpansion( | |
| 222 profile_name_, &child_dictionary)); | |
| 223 | |
| 224 std::string pref1_hash; | |
| 225 std::string pref2_hash; | |
| 226 ASSERT_TRUE(child_dictionary->GetString(kTrackedPrefs[0], &pref1_hash)); | |
| 227 ASSERT_TRUE(child_dictionary->GetString(kTrackedPrefs[1], &pref2_hash)); | |
| 228 | |
| 229 // These two hashes are expected to be different as the paths on which they're | |
| 230 // based differ. | |
| 231 EXPECT_EQ("2A38C5000E1EDC2D5FA3B6A8E1D3B54068E32D329324D0D8C1AADA65BBDB20B3", | |
| 232 pref1_hash); | |
| 233 EXPECT_EQ("C4FEB38BDADD16CC642815B9798FEA70BF92C6CA9250BACD6993701196D72067", | |
| 234 pref2_hash); | |
| 235 } | |
| 236 | |
| 237 TEST_F(PrefMetricsServiceTest, StartupUserPref) { | |
| 238 // Local state is empty. Set a value for one tracked pref. We should record | |
| 239 // that we checked preferences once and initialized a hash for the pref. | |
| 240 prefs_->SetString(kTrackedPrefs[0], "foo"); | |
| 241 { | |
| 242 scoped_ptr<PrefMetricsService> service = | |
| 243 CreatePrefMetricsService(kTestDeviceId); | |
| 244 UpdateHistogramSamples(); | |
| 245 EXPECT_EQ(0, pref1_changed_); | |
| 246 EXPECT_EQ(0, pref2_changed_); | |
| 247 EXPECT_EQ(0, pref1_cleared_); | |
| 248 EXPECT_EQ(0, pref2_cleared_); | |
| 249 EXPECT_EQ(1, pref1_initialized_); | |
| 250 EXPECT_EQ(1, pref2_initialized_); | |
| 251 EXPECT_EQ(0, pref1_migrated_); | |
| 252 EXPECT_EQ(0, pref2_migrated_); | |
| 253 EXPECT_EQ(0, pref1_unchanged_); | |
| 254 EXPECT_EQ(0, pref2_unchanged_); | |
| 255 | |
| 256 // Change the pref. This should be observed by the PrefMetricsService, which | |
| 257 // will update the hash in local_state_ to stay in sync. | |
| 258 prefs_->SetString(kTrackedPrefs[0], "bar"); | |
| 259 } | |
| 260 // The next startup should record no changes. | |
| 261 { | |
| 262 scoped_ptr<PrefMetricsService> service = | |
| 263 CreatePrefMetricsService(kTestDeviceId); | |
| 264 UpdateHistogramSamples(); | |
| 265 EXPECT_EQ(0, pref1_changed_); | |
| 266 EXPECT_EQ(0, pref2_changed_); | |
| 267 EXPECT_EQ(0, pref1_cleared_); | |
| 268 EXPECT_EQ(0, pref2_cleared_); | |
| 269 EXPECT_EQ(0, pref1_initialized_); | |
| 270 EXPECT_EQ(0, pref2_initialized_); | |
| 271 EXPECT_EQ(0, pref1_migrated_); | |
| 272 EXPECT_EQ(0, pref2_migrated_); | |
| 273 EXPECT_EQ(1, pref1_unchanged_); | |
| 274 EXPECT_EQ(1, pref2_unchanged_); | |
| 275 } | |
| 276 } | |
| 277 | |
| 278 TEST_F(PrefMetricsServiceTest, ChangedUserPref) { | |
| 279 // Local state is empty. Set a value for the tracked pref. We should record | |
| 280 // that we checked preferences once and initialized a hash for the pref. | |
| 281 prefs_->SetString(kTrackedPrefs[0], "foo"); | |
| 282 { | |
| 283 scoped_ptr<PrefMetricsService> service = | |
| 284 CreatePrefMetricsService(kTestDeviceId); | |
| 285 UpdateHistogramSamples(); | |
| 286 EXPECT_EQ(0, pref1_changed_); | |
| 287 EXPECT_EQ(0, pref2_changed_); | |
| 288 EXPECT_EQ(0, pref1_cleared_); | |
| 289 EXPECT_EQ(0, pref2_cleared_); | |
| 290 EXPECT_EQ(1, pref1_initialized_); | |
| 291 EXPECT_EQ(1, pref2_initialized_); | |
| 292 EXPECT_EQ(0, pref1_migrated_); | |
| 293 EXPECT_EQ(0, pref2_migrated_); | |
| 294 EXPECT_EQ(0, pref1_unchanged_); | |
| 295 EXPECT_EQ(0, pref2_unchanged_); | |
| 296 // Hashed prefs should now be stored in local state. | |
| 297 } | |
| 298 // Change the value of the tracked pref while there is no PrefMetricsService | |
| 299 // to update the hash. We should observe a pref value change. | |
| 300 prefs_->SetString(kTrackedPrefs[0], "bar"); | |
| 301 { | |
| 302 scoped_ptr<PrefMetricsService> service = | |
| 303 CreatePrefMetricsService(kTestDeviceId); | |
| 304 UpdateHistogramSamples(); | |
| 305 EXPECT_EQ(1, pref1_changed_); | |
| 306 EXPECT_EQ(0, pref2_changed_); | |
| 307 EXPECT_EQ(0, pref1_cleared_); | |
| 308 EXPECT_EQ(0, pref2_cleared_); | |
| 309 EXPECT_EQ(0, pref1_initialized_); | |
| 310 EXPECT_EQ(0, pref2_initialized_); | |
| 311 EXPECT_EQ(0, pref1_migrated_); | |
| 312 EXPECT_EQ(0, pref2_migrated_); | |
| 313 EXPECT_EQ(0, pref1_unchanged_); | |
| 314 EXPECT_EQ(1, pref2_unchanged_); | |
| 315 } | |
| 316 // Clear the value of the tracked pref while there is no PrefMetricsService | |
| 317 // to update the hash. We should observe a pref value removal. | |
| 318 prefs_->ClearPref(kTrackedPrefs[0]); | |
| 319 { | |
| 320 scoped_ptr<PrefMetricsService> service = | |
| 321 CreatePrefMetricsService(kTestDeviceId); | |
| 322 UpdateHistogramSamples(); | |
| 323 EXPECT_EQ(0, pref1_changed_); | |
| 324 EXPECT_EQ(0, pref2_changed_); | |
| 325 EXPECT_EQ(1, pref1_cleared_); | |
| 326 EXPECT_EQ(0, pref2_cleared_); | |
| 327 EXPECT_EQ(0, pref1_initialized_); | |
| 328 EXPECT_EQ(0, pref2_initialized_); | |
| 329 EXPECT_EQ(0, pref1_migrated_); | |
| 330 EXPECT_EQ(0, pref2_migrated_); | |
| 331 EXPECT_EQ(0, pref1_unchanged_); | |
| 332 EXPECT_EQ(1, pref2_unchanged_); | |
| 333 } | |
| 334 } | |
| 335 | |
| 336 TEST_F(PrefMetricsServiceTest, MigratedUserPref) { | |
| 337 // Initialize both preferences and get the old style hash for the first pref | |
| 338 // from the PrefMetricsService before shutting it down. | |
| 339 prefs_->SetString(kTrackedPrefs[0], "foo"); | |
| 340 prefs_->SetString(kTrackedPrefs[1], "bar"); | |
| 341 std::string old_style_hash; | |
| 342 { | |
| 343 scoped_ptr<PrefMetricsService> service = | |
| 344 CreatePrefMetricsService(kTestDeviceId); | |
| 345 UpdateHistogramSamples(); | |
| 346 EXPECT_EQ(0, pref1_changed_); | |
| 347 EXPECT_EQ(0, pref2_changed_); | |
| 348 EXPECT_EQ(0, pref1_cleared_); | |
| 349 EXPECT_EQ(0, pref2_cleared_); | |
| 350 EXPECT_EQ(1, pref1_initialized_); | |
| 351 EXPECT_EQ(1, pref2_initialized_); | |
| 352 EXPECT_EQ(0, pref1_migrated_); | |
| 353 EXPECT_EQ(0, pref2_migrated_); | |
| 354 EXPECT_EQ(0, pref1_unchanged_); | |
| 355 EXPECT_EQ(0, pref2_unchanged_); | |
| 356 | |
| 357 old_style_hash = | |
| 358 GetOldStyleHashedPrefValue(service.get(), kTrackedPrefs[0], | |
| 359 prefs_->GetUserPrefValue(kTrackedPrefs[0])); | |
| 360 } | |
| 361 | |
| 362 // Update the pref's hash to use the old style while the PrefMetricsService | |
| 363 // isn't running. | |
| 364 { | |
| 365 DictionaryPrefUpdate update(&local_state_, prefs::kProfilePreferenceHashes); | |
| 366 DictionaryValue* child_dictionary = NULL; | |
| 367 // Get the dictionary corresponding to the profile name, | |
| 368 // which may have a '.' | |
| 369 ASSERT_TRUE(update->GetDictionaryWithoutPathExpansion(profile_name_, | |
| 370 &child_dictionary)); | |
| 371 child_dictionary->SetString(kTrackedPrefs[0], old_style_hash); | |
| 372 } | |
| 373 | |
| 374 // Relaunch the service and make sure the first preference got migrated. | |
| 375 { | |
| 376 scoped_ptr<PrefMetricsService> service = | |
| 377 CreatePrefMetricsService(kTestDeviceId); | |
| 378 UpdateHistogramSamples(); | |
| 379 EXPECT_EQ(0, pref1_changed_); | |
| 380 EXPECT_EQ(0, pref2_changed_); | |
| 381 EXPECT_EQ(0, pref1_cleared_); | |
| 382 EXPECT_EQ(0, pref2_cleared_); | |
| 383 EXPECT_EQ(0, pref1_initialized_); | |
| 384 EXPECT_EQ(0, pref2_initialized_); | |
| 385 EXPECT_EQ(1, pref1_migrated_); | |
| 386 EXPECT_EQ(0, pref2_migrated_); | |
| 387 EXPECT_EQ(0, pref1_unchanged_); | |
| 388 EXPECT_EQ(1, pref2_unchanged_); | |
| 389 } | |
| 390 // Make sure the migration happens only once. | |
| 391 { | |
| 392 scoped_ptr<PrefMetricsService> service = | |
| 393 CreatePrefMetricsService(kTestDeviceId); | |
| 394 UpdateHistogramSamples(); | |
| 395 EXPECT_EQ(0, pref1_changed_); | |
| 396 EXPECT_EQ(0, pref2_changed_); | |
| 397 EXPECT_EQ(0, pref1_cleared_); | |
| 398 EXPECT_EQ(0, pref2_cleared_); | |
| 399 EXPECT_EQ(0, pref1_initialized_); | |
| 400 EXPECT_EQ(0, pref2_initialized_); | |
| 401 EXPECT_EQ(0, pref1_migrated_); | |
| 402 EXPECT_EQ(0, pref2_migrated_); | |
| 403 EXPECT_EQ(1, pref1_unchanged_); | |
| 404 EXPECT_EQ(1, pref2_unchanged_); | |
| 405 } | |
| 406 } | |
| 407 | |
| 408 // Make sure that the new algorithm is still able to generate old style hashes | |
| 409 // as they were before this change. | |
| 410 TEST_F(PrefMetricsServiceTest, OldStyleHashAsExpected) { | |
| 411 scoped_ptr<PrefMetricsService> service = | |
| 412 CreatePrefMetricsService(kTestDeviceId); | |
| 413 | |
| 414 // Verify the hashes match the values previously used in the | |
| 415 // "PrefHashStability" test below. | |
| 416 DictionaryValue dict; | |
| 417 dict.Set("a", new StringValue("foo")); | |
| 418 dict.Set("d", new StringValue("bad")); | |
| 419 dict.Set("b", new StringValue("bar")); | |
| 420 dict.Set("c", new StringValue("baz")); | |
| 421 EXPECT_EQ("C503FB7C65EEFD5C07185F616A0AA67923C069909933F362022B1F187E73E9A2", | |
| 422 GetOldStyleHashedPrefValue(service.get(), "pref.path1", &dict)); | |
| 423 ListValue list; | |
| 424 list.Set(0, new base::FundamentalValue(true)); | |
| 425 list.Set(1, new base::FundamentalValue(100)); | |
| 426 list.Set(2, new base::FundamentalValue(1.0)); | |
| 427 EXPECT_EQ("3163EC3C96263143AF83EA5C9860DFB960EE2263413C7D7D8A9973FCC00E7692", | |
| 428 GetOldStyleHashedPrefValue(service.get(), "pref.path2", &list)); | |
| 429 } | |
| 430 | |
| 431 // Tests that serialization of dictionary values is stable. If the order of | |
| 432 // the entries or any whitespace changes, it would cause a spike in pref change | |
| 433 // UMA events as every hash would change. | |
| 434 TEST_F(PrefMetricsServiceTest, PrefHashStability) { | |
| 435 scoped_ptr<PrefMetricsService> service = | |
| 436 CreatePrefMetricsService(kTestDeviceId); | |
| 437 | |
| 438 DictionaryValue dict; | |
| 439 dict.Set("a", new StringValue("foo")); | |
| 440 dict.Set("d", new StringValue("bad")); | |
| 441 dict.Set("b", new StringValue("bar")); | |
| 442 dict.Set("c", new StringValue("baz")); | |
| 443 EXPECT_EQ("A50FE7EB31BFBC32B8A27E71730AF15421178A9B5815644ACE174B18966735B9", | |
| 444 GetHashedPrefValue(service.get(), "pref.path1", &dict)); | |
| 445 | |
| 446 ListValue list; | |
| 447 list.Set(0, new base::FundamentalValue(true)); | |
| 448 list.Set(1, new base::FundamentalValue(100)); | |
| 449 list.Set(2, new base::FundamentalValue(1.0)); | |
| 450 EXPECT_EQ("5CE37D7EBCBC9BE510F0F5E7C326CA92C1673713C3717839610AEA1A217D8BB8", | |
| 451 GetHashedPrefValue(service.get(), "pref.path2", &list)); | |
| 452 } | |
| 453 | |
| 454 // Tests that different hashes are generated for different device IDs. | |
| 455 TEST_F(PrefMetricsServiceTest, HashIsBasedOnDeviceId) { | |
| 456 scoped_ptr<PrefMetricsService> service = | |
| 457 CreatePrefMetricsService(kTestDeviceId); | |
| 458 scoped_ptr<PrefMetricsService> other_service = | |
| 459 CreatePrefMetricsService(kOtherTestDeviceId); | |
| 460 | |
| 461 StringValue test_value("test value"); | |
| 462 EXPECT_EQ("49CA276F9F2AEDCF6BFA1CD9FC4747476E1315BBBBC27DD33548B23CD36E2EEE", | |
| 463 GetHashedPrefValue(service.get(), "pref.path", &test_value)); | |
| 464 EXPECT_EQ("13EEDA99C38777ADA8B87C23A3C5CD1FD31ADE1491823E255D3520E5B56C4BC7", | |
| 465 GetHashedPrefValue(other_service.get(), "pref.path", &test_value)); | |
| 466 } | |
| 467 | |
| 468 // Tests that different hashes are generated for different paths. | |
| 469 TEST_F(PrefMetricsServiceTest, HashIsBasedOnPath) { | |
| 470 scoped_ptr<PrefMetricsService> service = | |
| 471 CreatePrefMetricsService(kTestDeviceId); | |
| 472 | |
| 473 StringValue test_value("test value"); | |
| 474 EXPECT_EQ("2A5DCB1294F212DB26DF9C08C46F11C272D80136AAD3B4AAE5B7D008DF5F3F22", | |
| 475 GetHashedPrefValue(service.get(), "pref.path1", &test_value)); | |
| 476 EXPECT_EQ("455EC2A7E192E9F1C06294BBB3B66BBD81B8D1A8550D518EA5D5C8F70FCF6EF3", | |
| 477 GetHashedPrefValue(service.get(), "pref.path2", &test_value)); | |
| 478 } | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 90563003:
Fix a race condition in preference metric reporting. (Closed)
Base URL: svn://svn.chromium.org/chrome/trunk/src