OLD | NEW |
1 // Copyright (c) 2012 The Chromium Authors. All rights reserved. | 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 | 2 // Use of this source code is governed by a BSD-style license that can be |
3 // found in the LICENSE file. | 3 // found in the LICENSE file. |
4 | 4 |
5 #include "components/prefs/overlay_user_pref_store.h" | 5 #include "components/prefs/overlay_user_pref_store.h" |
6 | 6 |
7 #include "base/memory/ptr_util.h" | 7 #include "base/memory/ptr_util.h" |
8 #include "base/values.h" | 8 #include "base/values.h" |
9 #include "components/prefs/pref_store_observer_mock.h" | 9 #include "components/prefs/pref_store_observer_mock.h" |
10 #include "components/prefs/testing_pref_store.h" | 10 #include "components/prefs/testing_pref_store.h" |
(...skipping 31 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
42 | 42 |
43 scoped_refptr<TestingPrefStore> underlay_; | 43 scoped_refptr<TestingPrefStore> underlay_; |
44 scoped_refptr<OverlayUserPrefStore> overlay_; | 44 scoped_refptr<OverlayUserPrefStore> overlay_; |
45 }; | 45 }; |
46 | 46 |
47 TEST_F(OverlayUserPrefStoreTest, Observer) { | 47 TEST_F(OverlayUserPrefStoreTest, Observer) { |
48 PrefStoreObserverMock obs; | 48 PrefStoreObserverMock obs; |
49 overlay_->AddObserver(&obs); | 49 overlay_->AddObserver(&obs); |
50 | 50 |
51 // Check that underlay first value is reported. | 51 // Check that underlay first value is reported. |
52 underlay_->SetValue(overlay_key, base::MakeUnique<FundamentalValue>(42), | 52 underlay_->SetValue(overlay_key, base::MakeUnique<Value>(42), |
53 WriteablePrefStore::DEFAULT_PREF_WRITE_FLAGS); | 53 WriteablePrefStore::DEFAULT_PREF_WRITE_FLAGS); |
54 obs.VerifyAndResetChangedKey(overlay_key); | 54 obs.VerifyAndResetChangedKey(overlay_key); |
55 | 55 |
56 // Check that underlay overwriting is reported. | 56 // Check that underlay overwriting is reported. |
57 underlay_->SetValue(overlay_key, base::MakeUnique<FundamentalValue>(43), | 57 underlay_->SetValue(overlay_key, base::MakeUnique<Value>(43), |
58 WriteablePrefStore::DEFAULT_PREF_WRITE_FLAGS); | 58 WriteablePrefStore::DEFAULT_PREF_WRITE_FLAGS); |
59 obs.VerifyAndResetChangedKey(overlay_key); | 59 obs.VerifyAndResetChangedKey(overlay_key); |
60 | 60 |
61 // Check that overwriting change in overlay is reported. | 61 // Check that overwriting change in overlay is reported. |
62 overlay_->SetValue(overlay_key, base::MakeUnique<FundamentalValue>(44), | 62 overlay_->SetValue(overlay_key, base::MakeUnique<Value>(44), |
63 WriteablePrefStore::DEFAULT_PREF_WRITE_FLAGS); | 63 WriteablePrefStore::DEFAULT_PREF_WRITE_FLAGS); |
64 obs.VerifyAndResetChangedKey(overlay_key); | 64 obs.VerifyAndResetChangedKey(overlay_key); |
65 | 65 |
66 // Check that hidden underlay change is not reported. | 66 // Check that hidden underlay change is not reported. |
67 underlay_->SetValue(overlay_key, base::MakeUnique<FundamentalValue>(45), | 67 underlay_->SetValue(overlay_key, base::MakeUnique<Value>(45), |
68 WriteablePrefStore::DEFAULT_PREF_WRITE_FLAGS); | 68 WriteablePrefStore::DEFAULT_PREF_WRITE_FLAGS); |
69 EXPECT_TRUE(obs.changed_keys.empty()); | 69 EXPECT_TRUE(obs.changed_keys.empty()); |
70 | 70 |
71 // Check that overlay remove is reported. | 71 // Check that overlay remove is reported. |
72 overlay_->RemoveValue(overlay_key, | 72 overlay_->RemoveValue(overlay_key, |
73 WriteablePrefStore::DEFAULT_PREF_WRITE_FLAGS); | 73 WriteablePrefStore::DEFAULT_PREF_WRITE_FLAGS); |
74 obs.VerifyAndResetChangedKey(overlay_key); | 74 obs.VerifyAndResetChangedKey(overlay_key); |
75 | 75 |
76 // Check that underlay remove is reported. | 76 // Check that underlay remove is reported. |
77 underlay_->RemoveValue(overlay_key, | 77 underlay_->RemoveValue(overlay_key, |
78 WriteablePrefStore::DEFAULT_PREF_WRITE_FLAGS); | 78 WriteablePrefStore::DEFAULT_PREF_WRITE_FLAGS); |
79 obs.VerifyAndResetChangedKey(overlay_key); | 79 obs.VerifyAndResetChangedKey(overlay_key); |
80 | 80 |
81 // Check respecting of silence. | 81 // Check respecting of silence. |
82 overlay_->SetValueSilently(overlay_key, | 82 overlay_->SetValueSilently(overlay_key, |
83 base::MakeUnique<FundamentalValue>(46), | 83 base::MakeUnique<Value>(46), |
84 WriteablePrefStore::DEFAULT_PREF_WRITE_FLAGS); | 84 WriteablePrefStore::DEFAULT_PREF_WRITE_FLAGS); |
85 EXPECT_TRUE(obs.changed_keys.empty()); | 85 EXPECT_TRUE(obs.changed_keys.empty()); |
86 | 86 |
87 overlay_->RemoveObserver(&obs); | 87 overlay_->RemoveObserver(&obs); |
88 | 88 |
89 // Check successful unsubscription. | 89 // Check successful unsubscription. |
90 underlay_->SetValue(overlay_key, base::MakeUnique<FundamentalValue>(47), | 90 underlay_->SetValue(overlay_key, base::MakeUnique<Value>(47), |
91 WriteablePrefStore::DEFAULT_PREF_WRITE_FLAGS); | 91 WriteablePrefStore::DEFAULT_PREF_WRITE_FLAGS); |
92 overlay_->SetValue(overlay_key, base::MakeUnique<FundamentalValue>(48), | 92 overlay_->SetValue(overlay_key, base::MakeUnique<Value>(48), |
93 WriteablePrefStore::DEFAULT_PREF_WRITE_FLAGS); | 93 WriteablePrefStore::DEFAULT_PREF_WRITE_FLAGS); |
94 EXPECT_TRUE(obs.changed_keys.empty()); | 94 EXPECT_TRUE(obs.changed_keys.empty()); |
95 } | 95 } |
96 | 96 |
97 TEST_F(OverlayUserPrefStoreTest, GetAndSet) { | 97 TEST_F(OverlayUserPrefStoreTest, GetAndSet) { |
98 const Value* value = NULL; | 98 const Value* value = NULL; |
99 EXPECT_FALSE(overlay_->GetValue(overlay_key, &value)); | 99 EXPECT_FALSE(overlay_->GetValue(overlay_key, &value)); |
100 EXPECT_FALSE(underlay_->GetValue(overlay_key, &value)); | 100 EXPECT_FALSE(underlay_->GetValue(overlay_key, &value)); |
101 | 101 |
102 underlay_->SetValue(overlay_key, base::MakeUnique<FundamentalValue>(42), | 102 underlay_->SetValue(overlay_key, base::MakeUnique<Value>(42), |
103 WriteablePrefStore::DEFAULT_PREF_WRITE_FLAGS); | 103 WriteablePrefStore::DEFAULT_PREF_WRITE_FLAGS); |
104 | 104 |
105 // Value shines through: | 105 // Value shines through: |
106 EXPECT_TRUE(overlay_->GetValue(overlay_key, &value)); | 106 EXPECT_TRUE(overlay_->GetValue(overlay_key, &value)); |
107 EXPECT_TRUE(base::FundamentalValue(42).Equals(value)); | 107 EXPECT_TRUE(base::Value(42).Equals(value)); |
108 | 108 |
109 EXPECT_TRUE(underlay_->GetValue(overlay_key, &value)); | 109 EXPECT_TRUE(underlay_->GetValue(overlay_key, &value)); |
110 EXPECT_TRUE(base::FundamentalValue(42).Equals(value)); | 110 EXPECT_TRUE(base::Value(42).Equals(value)); |
111 | 111 |
112 overlay_->SetValue(overlay_key, base::MakeUnique<FundamentalValue>(43), | 112 overlay_->SetValue(overlay_key, base::MakeUnique<Value>(43), |
113 WriteablePrefStore::DEFAULT_PREF_WRITE_FLAGS); | 113 WriteablePrefStore::DEFAULT_PREF_WRITE_FLAGS); |
114 | 114 |
115 EXPECT_TRUE(overlay_->GetValue(overlay_key, &value)); | 115 EXPECT_TRUE(overlay_->GetValue(overlay_key, &value)); |
116 EXPECT_TRUE(base::FundamentalValue(43).Equals(value)); | 116 EXPECT_TRUE(base::Value(43).Equals(value)); |
117 | 117 |
118 EXPECT_TRUE(underlay_->GetValue(overlay_key, &value)); | 118 EXPECT_TRUE(underlay_->GetValue(overlay_key, &value)); |
119 EXPECT_TRUE(base::FundamentalValue(42).Equals(value)); | 119 EXPECT_TRUE(base::Value(42).Equals(value)); |
120 | 120 |
121 overlay_->RemoveValue(overlay_key, | 121 overlay_->RemoveValue(overlay_key, |
122 WriteablePrefStore::DEFAULT_PREF_WRITE_FLAGS); | 122 WriteablePrefStore::DEFAULT_PREF_WRITE_FLAGS); |
123 | 123 |
124 // Value shines through: | 124 // Value shines through: |
125 EXPECT_TRUE(overlay_->GetValue(overlay_key, &value)); | 125 EXPECT_TRUE(overlay_->GetValue(overlay_key, &value)); |
126 EXPECT_TRUE(base::FundamentalValue(42).Equals(value)); | 126 EXPECT_TRUE(base::Value(42).Equals(value)); |
127 | 127 |
128 EXPECT_TRUE(underlay_->GetValue(overlay_key, &value)); | 128 EXPECT_TRUE(underlay_->GetValue(overlay_key, &value)); |
129 EXPECT_TRUE(base::FundamentalValue(42).Equals(value)); | 129 EXPECT_TRUE(base::Value(42).Equals(value)); |
130 } | 130 } |
131 | 131 |
132 // Check that GetMutableValue does not return the dictionary of the underlay. | 132 // Check that GetMutableValue does not return the dictionary of the underlay. |
133 TEST_F(OverlayUserPrefStoreTest, ModifyDictionaries) { | 133 TEST_F(OverlayUserPrefStoreTest, ModifyDictionaries) { |
134 underlay_->SetValue(overlay_key, base::WrapUnique(new DictionaryValue), | 134 underlay_->SetValue(overlay_key, base::WrapUnique(new DictionaryValue), |
135 WriteablePrefStore::DEFAULT_PREF_WRITE_FLAGS); | 135 WriteablePrefStore::DEFAULT_PREF_WRITE_FLAGS); |
136 | 136 |
137 Value* modify = NULL; | 137 Value* modify = NULL; |
138 EXPECT_TRUE(overlay_->GetMutableValue(overlay_key, &modify)); | 138 EXPECT_TRUE(overlay_->GetMutableValue(overlay_key, &modify)); |
139 ASSERT_TRUE(modify); | 139 ASSERT_TRUE(modify); |
(...skipping 14 matching lines...) Expand all Loading... |
154 } | 154 } |
155 | 155 |
156 // Here we consider a global preference that is not overlayed. | 156 // Here we consider a global preference that is not overlayed. |
157 TEST_F(OverlayUserPrefStoreTest, GlobalPref) { | 157 TEST_F(OverlayUserPrefStoreTest, GlobalPref) { |
158 PrefStoreObserverMock obs; | 158 PrefStoreObserverMock obs; |
159 overlay_->AddObserver(&obs); | 159 overlay_->AddObserver(&obs); |
160 | 160 |
161 const Value* value = NULL; | 161 const Value* value = NULL; |
162 | 162 |
163 // Check that underlay first value is reported. | 163 // Check that underlay first value is reported. |
164 underlay_->SetValue(regular_key, base::WrapUnique(new FundamentalValue(42)), | 164 underlay_->SetValue(regular_key, base::WrapUnique(new Value(42)), |
165 WriteablePrefStore::DEFAULT_PREF_WRITE_FLAGS); | 165 WriteablePrefStore::DEFAULT_PREF_WRITE_FLAGS); |
166 obs.VerifyAndResetChangedKey(regular_key); | 166 obs.VerifyAndResetChangedKey(regular_key); |
167 | 167 |
168 // Check that underlay overwriting is reported. | 168 // Check that underlay overwriting is reported. |
169 underlay_->SetValue(regular_key, base::WrapUnique(new FundamentalValue(43)), | 169 underlay_->SetValue(regular_key, base::WrapUnique(new Value(43)), |
170 WriteablePrefStore::DEFAULT_PREF_WRITE_FLAGS); | 170 WriteablePrefStore::DEFAULT_PREF_WRITE_FLAGS); |
171 obs.VerifyAndResetChangedKey(regular_key); | 171 obs.VerifyAndResetChangedKey(regular_key); |
172 | 172 |
173 // Check that we get this value from the overlay | 173 // Check that we get this value from the overlay |
174 EXPECT_TRUE(overlay_->GetValue(regular_key, &value)); | 174 EXPECT_TRUE(overlay_->GetValue(regular_key, &value)); |
175 EXPECT_TRUE(base::FundamentalValue(43).Equals(value)); | 175 EXPECT_TRUE(base::Value(43).Equals(value)); |
176 | 176 |
177 // Check that overwriting change in overlay is reported. | 177 // Check that overwriting change in overlay is reported. |
178 overlay_->SetValue(regular_key, base::WrapUnique(new FundamentalValue(44)), | 178 overlay_->SetValue(regular_key, base::WrapUnique(new Value(44)), |
179 WriteablePrefStore::DEFAULT_PREF_WRITE_FLAGS); | 179 WriteablePrefStore::DEFAULT_PREF_WRITE_FLAGS); |
180 obs.VerifyAndResetChangedKey(regular_key); | 180 obs.VerifyAndResetChangedKey(regular_key); |
181 | 181 |
182 // Check that we get this value from the overlay and the underlay. | 182 // Check that we get this value from the overlay and the underlay. |
183 EXPECT_TRUE(overlay_->GetValue(regular_key, &value)); | 183 EXPECT_TRUE(overlay_->GetValue(regular_key, &value)); |
184 EXPECT_TRUE(base::FundamentalValue(44).Equals(value)); | 184 EXPECT_TRUE(base::Value(44).Equals(value)); |
185 EXPECT_TRUE(underlay_->GetValue(regular_key, &value)); | 185 EXPECT_TRUE(underlay_->GetValue(regular_key, &value)); |
186 EXPECT_TRUE(base::FundamentalValue(44).Equals(value)); | 186 EXPECT_TRUE(base::Value(44).Equals(value)); |
187 | 187 |
188 // Check that overlay remove is reported. | 188 // Check that overlay remove is reported. |
189 overlay_->RemoveValue(regular_key, | 189 overlay_->RemoveValue(regular_key, |
190 WriteablePrefStore::DEFAULT_PREF_WRITE_FLAGS); | 190 WriteablePrefStore::DEFAULT_PREF_WRITE_FLAGS); |
191 obs.VerifyAndResetChangedKey(regular_key); | 191 obs.VerifyAndResetChangedKey(regular_key); |
192 | 192 |
193 // Check that value was removed from overlay and underlay | 193 // Check that value was removed from overlay and underlay |
194 EXPECT_FALSE(overlay_->GetValue(regular_key, &value)); | 194 EXPECT_FALSE(overlay_->GetValue(regular_key, &value)); |
195 EXPECT_FALSE(underlay_->GetValue(regular_key, &value)); | 195 EXPECT_FALSE(underlay_->GetValue(regular_key, &value)); |
196 | 196 |
197 // Check respecting of silence. | 197 // Check respecting of silence. |
198 overlay_->SetValueSilently(regular_key, | 198 overlay_->SetValueSilently(regular_key, |
199 base::WrapUnique(new FundamentalValue(46)), | 199 base::WrapUnique(new Value(46)), |
200 WriteablePrefStore::DEFAULT_PREF_WRITE_FLAGS); | 200 WriteablePrefStore::DEFAULT_PREF_WRITE_FLAGS); |
201 EXPECT_TRUE(obs.changed_keys.empty()); | 201 EXPECT_TRUE(obs.changed_keys.empty()); |
202 | 202 |
203 overlay_->RemoveObserver(&obs); | 203 overlay_->RemoveObserver(&obs); |
204 | 204 |
205 // Check successful unsubscription. | 205 // Check successful unsubscription. |
206 underlay_->SetValue(regular_key, base::WrapUnique(new FundamentalValue(47)), | 206 underlay_->SetValue(regular_key, base::WrapUnique(new Value(47)), |
207 WriteablePrefStore::DEFAULT_PREF_WRITE_FLAGS); | 207 WriteablePrefStore::DEFAULT_PREF_WRITE_FLAGS); |
208 overlay_->SetValue(regular_key, base::WrapUnique(new FundamentalValue(48)), | 208 overlay_->SetValue(regular_key, base::WrapUnique(new Value(48)), |
209 WriteablePrefStore::DEFAULT_PREF_WRITE_FLAGS); | 209 WriteablePrefStore::DEFAULT_PREF_WRITE_FLAGS); |
210 EXPECT_TRUE(obs.changed_keys.empty()); | 210 EXPECT_TRUE(obs.changed_keys.empty()); |
211 } | 211 } |
212 | 212 |
213 // Check that names mapping works correctly. | 213 // Check that names mapping works correctly. |
214 TEST_F(OverlayUserPrefStoreTest, NamesMapping) { | 214 TEST_F(OverlayUserPrefStoreTest, NamesMapping) { |
215 PrefStoreObserverMock obs; | 215 PrefStoreObserverMock obs; |
216 overlay_->AddObserver(&obs); | 216 overlay_->AddObserver(&obs); |
217 | 217 |
218 const Value* value = NULL; | 218 const Value* value = NULL; |
219 | 219 |
220 // Check that if there is no override in the overlay, changing underlay value | 220 // Check that if there is no override in the overlay, changing underlay value |
221 // is reported as changing an overlay value. | 221 // is reported as changing an overlay value. |
222 underlay_->SetValue(mapped_underlay_key, | 222 underlay_->SetValue(mapped_underlay_key, |
223 base::WrapUnique(new FundamentalValue(42)), | 223 base::WrapUnique(new Value(42)), |
224 WriteablePrefStore::DEFAULT_PREF_WRITE_FLAGS); | 224 WriteablePrefStore::DEFAULT_PREF_WRITE_FLAGS); |
225 obs.VerifyAndResetChangedKey(mapped_overlay_key); | 225 obs.VerifyAndResetChangedKey(mapped_overlay_key); |
226 | 226 |
227 // Check that underlay overwriting is reported. | 227 // Check that underlay overwriting is reported. |
228 underlay_->SetValue(mapped_underlay_key, | 228 underlay_->SetValue(mapped_underlay_key, |
229 base::WrapUnique(new FundamentalValue(43)), | 229 base::WrapUnique(new Value(43)), |
230 WriteablePrefStore::DEFAULT_PREF_WRITE_FLAGS); | 230 WriteablePrefStore::DEFAULT_PREF_WRITE_FLAGS); |
231 obs.VerifyAndResetChangedKey(mapped_overlay_key); | 231 obs.VerifyAndResetChangedKey(mapped_overlay_key); |
232 | 232 |
233 // Check that we get this value from the overlay with both keys | 233 // Check that we get this value from the overlay with both keys |
234 EXPECT_TRUE(overlay_->GetValue(mapped_overlay_key, &value)); | 234 EXPECT_TRUE(overlay_->GetValue(mapped_overlay_key, &value)); |
235 EXPECT_TRUE(base::FundamentalValue(43).Equals(value)); | 235 EXPECT_TRUE(base::Value(43).Equals(value)); |
236 // In this case, overlay reads directly from the underlay. | 236 // In this case, overlay reads directly from the underlay. |
237 EXPECT_TRUE(overlay_->GetValue(mapped_underlay_key, &value)); | 237 EXPECT_TRUE(overlay_->GetValue(mapped_underlay_key, &value)); |
238 EXPECT_TRUE(base::FundamentalValue(43).Equals(value)); | 238 EXPECT_TRUE(base::Value(43).Equals(value)); |
239 | 239 |
240 // Check that overwriting change in overlay is reported. | 240 // Check that overwriting change in overlay is reported. |
241 overlay_->SetValue(mapped_overlay_key, | 241 overlay_->SetValue(mapped_overlay_key, |
242 base::WrapUnique(new FundamentalValue(44)), | 242 base::WrapUnique(new Value(44)), |
243 WriteablePrefStore::DEFAULT_PREF_WRITE_FLAGS); | 243 WriteablePrefStore::DEFAULT_PREF_WRITE_FLAGS); |
244 obs.VerifyAndResetChangedKey(mapped_overlay_key); | 244 obs.VerifyAndResetChangedKey(mapped_overlay_key); |
245 | 245 |
246 // Check that we get an overriden value from overlay, while reading the | 246 // Check that we get an overriden value from overlay, while reading the |
247 // value from underlay still holds an old value. | 247 // value from underlay still holds an old value. |
248 EXPECT_TRUE(overlay_->GetValue(mapped_overlay_key, &value)); | 248 EXPECT_TRUE(overlay_->GetValue(mapped_overlay_key, &value)); |
249 EXPECT_TRUE(base::FundamentalValue(44).Equals(value)); | 249 EXPECT_TRUE(base::Value(44).Equals(value)); |
250 EXPECT_TRUE(overlay_->GetValue(mapped_underlay_key, &value)); | 250 EXPECT_TRUE(overlay_->GetValue(mapped_underlay_key, &value)); |
251 EXPECT_TRUE(base::FundamentalValue(43).Equals(value)); | 251 EXPECT_TRUE(base::Value(43).Equals(value)); |
252 EXPECT_TRUE(underlay_->GetValue(mapped_underlay_key, &value)); | 252 EXPECT_TRUE(underlay_->GetValue(mapped_underlay_key, &value)); |
253 EXPECT_TRUE(base::FundamentalValue(43).Equals(value)); | 253 EXPECT_TRUE(base::Value(43).Equals(value)); |
254 | 254 |
255 // Check that hidden underlay change is not reported. | 255 // Check that hidden underlay change is not reported. |
256 underlay_->SetValue(mapped_underlay_key, | 256 underlay_->SetValue(mapped_underlay_key, |
257 base::WrapUnique(new FundamentalValue(45)), | 257 base::WrapUnique(new Value(45)), |
258 WriteablePrefStore::DEFAULT_PREF_WRITE_FLAGS); | 258 WriteablePrefStore::DEFAULT_PREF_WRITE_FLAGS); |
259 EXPECT_TRUE(obs.changed_keys.empty()); | 259 EXPECT_TRUE(obs.changed_keys.empty()); |
260 | 260 |
261 // Check that overlay remove is reported. | 261 // Check that overlay remove is reported. |
262 overlay_->RemoveValue(mapped_overlay_key, | 262 overlay_->RemoveValue(mapped_overlay_key, |
263 WriteablePrefStore::DEFAULT_PREF_WRITE_FLAGS); | 263 WriteablePrefStore::DEFAULT_PREF_WRITE_FLAGS); |
264 obs.VerifyAndResetChangedKey(mapped_overlay_key); | 264 obs.VerifyAndResetChangedKey(mapped_overlay_key); |
265 | 265 |
266 // Check that underlay remove is reported. | 266 // Check that underlay remove is reported. |
267 underlay_->RemoveValue(mapped_underlay_key, | 267 underlay_->RemoveValue(mapped_underlay_key, |
268 WriteablePrefStore::DEFAULT_PREF_WRITE_FLAGS); | 268 WriteablePrefStore::DEFAULT_PREF_WRITE_FLAGS); |
269 obs.VerifyAndResetChangedKey(mapped_overlay_key); | 269 obs.VerifyAndResetChangedKey(mapped_overlay_key); |
270 | 270 |
271 // Check that value was removed. | 271 // Check that value was removed. |
272 EXPECT_FALSE(overlay_->GetValue(mapped_overlay_key, &value)); | 272 EXPECT_FALSE(overlay_->GetValue(mapped_overlay_key, &value)); |
273 EXPECT_FALSE(overlay_->GetValue(mapped_underlay_key, &value)); | 273 EXPECT_FALSE(overlay_->GetValue(mapped_underlay_key, &value)); |
274 | 274 |
275 // Check respecting of silence. | 275 // Check respecting of silence. |
276 overlay_->SetValueSilently(mapped_overlay_key, | 276 overlay_->SetValueSilently(mapped_overlay_key, |
277 base::WrapUnique(new FundamentalValue(46)), | 277 base::WrapUnique(new Value(46)), |
278 WriteablePrefStore::DEFAULT_PREF_WRITE_FLAGS); | 278 WriteablePrefStore::DEFAULT_PREF_WRITE_FLAGS); |
279 EXPECT_TRUE(obs.changed_keys.empty()); | 279 EXPECT_TRUE(obs.changed_keys.empty()); |
280 | 280 |
281 overlay_->RemoveObserver(&obs); | 281 overlay_->RemoveObserver(&obs); |
282 | 282 |
283 // Check successful unsubscription. | 283 // Check successful unsubscription. |
284 underlay_->SetValue(mapped_underlay_key, | 284 underlay_->SetValue(mapped_underlay_key, |
285 base::WrapUnique(new FundamentalValue(47)), | 285 base::WrapUnique(new Value(47)), |
286 WriteablePrefStore::DEFAULT_PREF_WRITE_FLAGS); | 286 WriteablePrefStore::DEFAULT_PREF_WRITE_FLAGS); |
287 overlay_->SetValue(mapped_overlay_key, | 287 overlay_->SetValue(mapped_overlay_key, |
288 base::WrapUnique(new FundamentalValue(48)), | 288 base::WrapUnique(new Value(48)), |
289 WriteablePrefStore::DEFAULT_PREF_WRITE_FLAGS); | 289 WriteablePrefStore::DEFAULT_PREF_WRITE_FLAGS); |
290 EXPECT_TRUE(obs.changed_keys.empty()); | 290 EXPECT_TRUE(obs.changed_keys.empty()); |
291 } | 291 } |
292 | 292 |
293 // Check that mutable values are removed correctly. | 293 // Check that mutable values are removed correctly. |
294 TEST_F(OverlayUserPrefStoreTest, ClearMutableValues) { | 294 TEST_F(OverlayUserPrefStoreTest, ClearMutableValues) { |
295 // Set in overlay and underlay the same preference. | 295 // Set in overlay and underlay the same preference. |
296 underlay_->SetValue(overlay_key, base::WrapUnique(new FundamentalValue(42)), | 296 underlay_->SetValue(overlay_key, base::WrapUnique(new Value(42)), |
297 WriteablePrefStore::DEFAULT_PREF_WRITE_FLAGS); | 297 WriteablePrefStore::DEFAULT_PREF_WRITE_FLAGS); |
298 overlay_->SetValue(overlay_key, base::WrapUnique(new FundamentalValue(43)), | 298 overlay_->SetValue(overlay_key, base::WrapUnique(new Value(43)), |
299 WriteablePrefStore::DEFAULT_PREF_WRITE_FLAGS); | 299 WriteablePrefStore::DEFAULT_PREF_WRITE_FLAGS); |
300 | 300 |
301 const Value* value = nullptr; | 301 const Value* value = nullptr; |
302 // Check that an overlay preference is returned. | 302 // Check that an overlay preference is returned. |
303 EXPECT_TRUE(overlay_->GetValue(overlay_key, &value)); | 303 EXPECT_TRUE(overlay_->GetValue(overlay_key, &value)); |
304 EXPECT_TRUE(base::FundamentalValue(43).Equals(value)); | 304 EXPECT_TRUE(base::Value(43).Equals(value)); |
305 overlay_->ClearMutableValues(); | 305 overlay_->ClearMutableValues(); |
306 | 306 |
307 // Check that an underlay preference is returned. | 307 // Check that an underlay preference is returned. |
308 EXPECT_TRUE(overlay_->GetValue(overlay_key, &value)); | 308 EXPECT_TRUE(overlay_->GetValue(overlay_key, &value)); |
309 EXPECT_TRUE(base::FundamentalValue(42).Equals(value)); | 309 EXPECT_TRUE(base::Value(42).Equals(value)); |
310 } | 310 } |
311 | 311 |
312 } // namespace base | 312 } // namespace base |
OLD | NEW |