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 |