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 "sync/util/cryptographer.h" | 5 #include "sync/util/cryptographer.h" |
6 | 6 |
7 #include <string> | 7 #include <string> |
8 | 8 |
9 #include "base/memory/scoped_ptr.h" | 9 #include "base/memory/scoped_ptr.h" |
10 #include "base/string_util.h" | 10 #include "base/string_util.h" |
(...skipping 12 matching lines...) Expand all Loading... |
23 using ::testing::Mock; | 23 using ::testing::Mock; |
24 using ::testing::StrictMock; | 24 using ::testing::StrictMock; |
25 | 25 |
26 class MockObserver : public Cryptographer::Observer { | 26 class MockObserver : public Cryptographer::Observer { |
27 public: | 27 public: |
28 MOCK_METHOD2(OnEncryptedTypesChanged, void(ModelTypeSet, bool)); | 28 MOCK_METHOD2(OnEncryptedTypesChanged, void(ModelTypeSet, bool)); |
29 }; | 29 }; |
30 | 30 |
31 } // namespace | 31 } // namespace |
32 | 32 |
33 class SyncCryptographerTest : public ::testing::Test { | 33 class CryptographerTest : public ::testing::Test { |
34 protected: | 34 protected: |
35 SyncCryptographerTest() : cryptographer_(&encryptor_) {} | 35 CryptographerTest() : cryptographer_(&encryptor_) {} |
36 | 36 |
37 FakeEncryptor encryptor_; | 37 FakeEncryptor encryptor_; |
38 Cryptographer cryptographer_; | 38 Cryptographer cryptographer_; |
39 }; | 39 }; |
40 | 40 |
41 TEST_F(SyncCryptographerTest, EmptyCantDecrypt) { | 41 TEST_F(CryptographerTest, EmptyCantDecrypt) { |
42 EXPECT_FALSE(cryptographer_.is_ready()); | 42 EXPECT_FALSE(cryptographer_.is_ready()); |
43 | 43 |
44 sync_pb::EncryptedData encrypted; | 44 sync_pb::EncryptedData encrypted; |
45 encrypted.set_key_name("foo"); | 45 encrypted.set_key_name("foo"); |
46 encrypted.set_blob("bar"); | 46 encrypted.set_blob("bar"); |
47 | 47 |
48 EXPECT_FALSE(cryptographer_.CanDecrypt(encrypted)); | 48 EXPECT_FALSE(cryptographer_.CanDecrypt(encrypted)); |
49 } | 49 } |
50 | 50 |
51 TEST_F(SyncCryptographerTest, EmptyCantEncrypt) { | 51 TEST_F(CryptographerTest, EmptyCantEncrypt) { |
52 EXPECT_FALSE(cryptographer_.is_ready()); | 52 EXPECT_FALSE(cryptographer_.is_ready()); |
53 | 53 |
54 sync_pb::EncryptedData encrypted; | 54 sync_pb::EncryptedData encrypted; |
55 sync_pb::PasswordSpecificsData original; | 55 sync_pb::PasswordSpecificsData original; |
56 EXPECT_FALSE(cryptographer_.Encrypt(original, &encrypted)); | 56 EXPECT_FALSE(cryptographer_.Encrypt(original, &encrypted)); |
57 } | 57 } |
58 | 58 |
59 TEST_F(SyncCryptographerTest, MissingCantDecrypt) { | 59 TEST_F(CryptographerTest, MissingCantDecrypt) { |
60 KeyParams params = {"localhost", "dummy", "dummy"}; | 60 KeyParams params = {"localhost", "dummy", "dummy"}; |
61 cryptographer_.AddKey(params); | 61 cryptographer_.AddKey(params); |
62 EXPECT_TRUE(cryptographer_.is_ready()); | 62 EXPECT_TRUE(cryptographer_.is_ready()); |
63 | 63 |
64 sync_pb::EncryptedData encrypted; | 64 sync_pb::EncryptedData encrypted; |
65 encrypted.set_key_name("foo"); | 65 encrypted.set_key_name("foo"); |
66 encrypted.set_blob("bar"); | 66 encrypted.set_blob("bar"); |
67 | 67 |
68 EXPECT_FALSE(cryptographer_.CanDecrypt(encrypted)); | 68 EXPECT_FALSE(cryptographer_.CanDecrypt(encrypted)); |
69 } | 69 } |
70 | 70 |
71 TEST_F(SyncCryptographerTest, CanEncryptAndDecrypt) { | 71 TEST_F(CryptographerTest, CanEncryptAndDecrypt) { |
72 KeyParams params = {"localhost", "dummy", "dummy"}; | 72 KeyParams params = {"localhost", "dummy", "dummy"}; |
73 EXPECT_TRUE(cryptographer_.AddKey(params)); | 73 EXPECT_TRUE(cryptographer_.AddKey(params)); |
74 EXPECT_TRUE(cryptographer_.is_ready()); | 74 EXPECT_TRUE(cryptographer_.is_ready()); |
75 | 75 |
76 sync_pb::PasswordSpecificsData original; | 76 sync_pb::PasswordSpecificsData original; |
77 original.set_origin("http://example.com"); | 77 original.set_origin("http://example.com"); |
78 original.set_username_value("azure"); | 78 original.set_username_value("azure"); |
79 original.set_password_value("hunter2"); | 79 original.set_password_value("hunter2"); |
80 | 80 |
81 sync_pb::EncryptedData encrypted; | 81 sync_pb::EncryptedData encrypted; |
82 EXPECT_TRUE(cryptographer_.Encrypt(original, &encrypted)); | 82 EXPECT_TRUE(cryptographer_.Encrypt(original, &encrypted)); |
83 | 83 |
84 sync_pb::PasswordSpecificsData decrypted; | 84 sync_pb::PasswordSpecificsData decrypted; |
85 EXPECT_TRUE(cryptographer_.Decrypt(encrypted, &decrypted)); | 85 EXPECT_TRUE(cryptographer_.Decrypt(encrypted, &decrypted)); |
86 | 86 |
87 EXPECT_EQ(original.SerializeAsString(), decrypted.SerializeAsString()); | 87 EXPECT_EQ(original.SerializeAsString(), decrypted.SerializeAsString()); |
88 } | 88 } |
89 | 89 |
90 TEST_F(SyncCryptographerTest, EncryptOnlyIfDifferent) { | 90 TEST_F(CryptographerTest, EncryptOnlyIfDifferent) { |
91 KeyParams params = {"localhost", "dummy", "dummy"}; | 91 KeyParams params = {"localhost", "dummy", "dummy"}; |
92 EXPECT_TRUE(cryptographer_.AddKey(params)); | 92 EXPECT_TRUE(cryptographer_.AddKey(params)); |
93 EXPECT_TRUE(cryptographer_.is_ready()); | 93 EXPECT_TRUE(cryptographer_.is_ready()); |
94 | 94 |
95 sync_pb::PasswordSpecificsData original; | 95 sync_pb::PasswordSpecificsData original; |
96 original.set_origin("http://example.com"); | 96 original.set_origin("http://example.com"); |
97 original.set_username_value("azure"); | 97 original.set_username_value("azure"); |
98 original.set_password_value("hunter2"); | 98 original.set_password_value("hunter2"); |
99 | 99 |
100 sync_pb::EncryptedData encrypted; | 100 sync_pb::EncryptedData encrypted; |
(...skipping 10 matching lines...) Expand all Loading... |
111 EXPECT_TRUE(cryptographer_.Encrypt(original, &encrypted3)); | 111 EXPECT_TRUE(cryptographer_.Encrypt(original, &encrypted3)); |
112 | 112 |
113 sync_pb::PasswordSpecificsData decrypted; | 113 sync_pb::PasswordSpecificsData decrypted; |
114 EXPECT_TRUE(cryptographer_.Decrypt(encrypted2, &decrypted)); | 114 EXPECT_TRUE(cryptographer_.Decrypt(encrypted2, &decrypted)); |
115 // encrypted2 should match encrypted, encrypted3 should not (due to salting). | 115 // encrypted2 should match encrypted, encrypted3 should not (due to salting). |
116 EXPECT_EQ(encrypted.SerializeAsString(), encrypted2.SerializeAsString()); | 116 EXPECT_EQ(encrypted.SerializeAsString(), encrypted2.SerializeAsString()); |
117 EXPECT_NE(encrypted.SerializeAsString(), encrypted3.SerializeAsString()); | 117 EXPECT_NE(encrypted.SerializeAsString(), encrypted3.SerializeAsString()); |
118 EXPECT_EQ(original.SerializeAsString(), decrypted.SerializeAsString()); | 118 EXPECT_EQ(original.SerializeAsString(), decrypted.SerializeAsString()); |
119 } | 119 } |
120 | 120 |
121 TEST_F(SyncCryptographerTest, AddKeySetsDefault) { | 121 TEST_F(CryptographerTest, AddKeySetsDefault) { |
122 KeyParams params1 = {"localhost", "dummy", "dummy1"}; | 122 KeyParams params1 = {"localhost", "dummy", "dummy1"}; |
123 EXPECT_TRUE(cryptographer_.AddKey(params1)); | 123 EXPECT_TRUE(cryptographer_.AddKey(params1)); |
124 EXPECT_TRUE(cryptographer_.is_ready()); | 124 EXPECT_TRUE(cryptographer_.is_ready()); |
125 | 125 |
126 sync_pb::PasswordSpecificsData original; | 126 sync_pb::PasswordSpecificsData original; |
127 original.set_origin("http://example.com"); | 127 original.set_origin("http://example.com"); |
128 original.set_username_value("azure"); | 128 original.set_username_value("azure"); |
129 original.set_password_value("hunter2"); | 129 original.set_password_value("hunter2"); |
130 | 130 |
131 sync_pb::EncryptedData encrypted1; | 131 sync_pb::EncryptedData encrypted1; |
132 EXPECT_TRUE(cryptographer_.Encrypt(original, &encrypted1)); | 132 EXPECT_TRUE(cryptographer_.Encrypt(original, &encrypted1)); |
133 sync_pb::EncryptedData encrypted2; | 133 sync_pb::EncryptedData encrypted2; |
134 EXPECT_TRUE(cryptographer_.Encrypt(original, &encrypted2)); | 134 EXPECT_TRUE(cryptographer_.Encrypt(original, &encrypted2)); |
135 | 135 |
136 KeyParams params2 = {"localhost", "dummy", "dummy2"}; | 136 KeyParams params2 = {"localhost", "dummy", "dummy2"}; |
137 EXPECT_TRUE(cryptographer_.AddKey(params2)); | 137 EXPECT_TRUE(cryptographer_.AddKey(params2)); |
138 EXPECT_TRUE(cryptographer_.is_ready()); | 138 EXPECT_TRUE(cryptographer_.is_ready()); |
139 | 139 |
140 sync_pb::EncryptedData encrypted3; | 140 sync_pb::EncryptedData encrypted3; |
141 EXPECT_TRUE(cryptographer_.Encrypt(original, &encrypted3)); | 141 EXPECT_TRUE(cryptographer_.Encrypt(original, &encrypted3)); |
142 sync_pb::EncryptedData encrypted4; | 142 sync_pb::EncryptedData encrypted4; |
143 EXPECT_TRUE(cryptographer_.Encrypt(original, &encrypted4)); | 143 EXPECT_TRUE(cryptographer_.Encrypt(original, &encrypted4)); |
144 | 144 |
145 EXPECT_EQ(encrypted1.key_name(), encrypted2.key_name()); | 145 EXPECT_EQ(encrypted1.key_name(), encrypted2.key_name()); |
146 EXPECT_NE(encrypted1.key_name(), encrypted3.key_name()); | 146 EXPECT_NE(encrypted1.key_name(), encrypted3.key_name()); |
147 EXPECT_EQ(encrypted3.key_name(), encrypted4.key_name()); | 147 EXPECT_EQ(encrypted3.key_name(), encrypted4.key_name()); |
148 } | 148 } |
149 | 149 |
150 // Ensure setting the keystore key works and doesn't modify the default nigori. | 150 // Ensure setting the keystore key works and doesn't modify the default nigori. |
151 TEST_F(SyncCryptographerTest, SetKeystore) { | 151 TEST_F(CryptographerTest, SetKeystore) { |
152 EXPECT_FALSE(cryptographer_.is_initialized()); | 152 EXPECT_FALSE(cryptographer_.is_initialized()); |
153 EXPECT_FALSE(cryptographer_.HasKeystoreKey()); | 153 EXPECT_FALSE(cryptographer_.HasKeystoreKey()); |
154 | 154 |
155 EXPECT_FALSE(cryptographer_.SetKeystoreKey("")); | 155 EXPECT_FALSE(cryptographer_.SetKeystoreKey("")); |
156 EXPECT_FALSE(cryptographer_.HasKeystoreKey()); | 156 EXPECT_FALSE(cryptographer_.HasKeystoreKey()); |
157 | 157 |
158 EXPECT_TRUE(cryptographer_.SetKeystoreKey("keystore_key")); | 158 EXPECT_TRUE(cryptographer_.SetKeystoreKey("keystore_key")); |
159 EXPECT_TRUE(cryptographer_.HasKeystoreKey()); | 159 EXPECT_TRUE(cryptographer_.HasKeystoreKey()); |
160 EXPECT_FALSE(cryptographer_.is_initialized()); | 160 EXPECT_FALSE(cryptographer_.is_initialized()); |
161 } | 161 } |
162 | 162 |
163 // Crashes, Bug 55178. | 163 // Crashes, Bug 55178. |
164 #if defined(OS_WIN) | 164 #if defined(OS_WIN) |
165 #define MAYBE_EncryptExportDecrypt DISABLED_EncryptExportDecrypt | 165 #define MAYBE_EncryptExportDecrypt DISABLED_EncryptExportDecrypt |
166 #else | 166 #else |
167 #define MAYBE_EncryptExportDecrypt EncryptExportDecrypt | 167 #define MAYBE_EncryptExportDecrypt EncryptExportDecrypt |
168 #endif | 168 #endif |
169 TEST_F(SyncCryptographerTest, MAYBE_EncryptExportDecrypt) { | 169 TEST_F(CryptographerTest, MAYBE_EncryptExportDecrypt) { |
170 sync_pb::EncryptedData nigori; | 170 sync_pb::EncryptedData nigori; |
171 sync_pb::EncryptedData encrypted; | 171 sync_pb::EncryptedData encrypted; |
172 | 172 |
173 sync_pb::PasswordSpecificsData original; | 173 sync_pb::PasswordSpecificsData original; |
174 original.set_origin("http://example.com"); | 174 original.set_origin("http://example.com"); |
175 original.set_username_value("azure"); | 175 original.set_username_value("azure"); |
176 original.set_password_value("hunter2"); | 176 original.set_password_value("hunter2"); |
177 | 177 |
178 { | 178 { |
179 Cryptographer cryptographer(&encryptor_); | 179 Cryptographer cryptographer(&encryptor_); |
(...skipping 24 matching lines...) Expand all Loading... |
204 EXPECT_EQ(original.SerializeAsString(), decrypted.SerializeAsString()); | 204 EXPECT_EQ(original.SerializeAsString(), decrypted.SerializeAsString()); |
205 } | 205 } |
206 } | 206 } |
207 | 207 |
208 // Crashes, Bug 55178. | 208 // Crashes, Bug 55178. |
209 #if defined(OS_WIN) | 209 #if defined(OS_WIN) |
210 #define MAYBE_PackUnpack DISABLED_PackUnpack | 210 #define MAYBE_PackUnpack DISABLED_PackUnpack |
211 #else | 211 #else |
212 #define MAYBE_PackUnpack PackUnpack | 212 #define MAYBE_PackUnpack PackUnpack |
213 #endif | 213 #endif |
214 TEST_F(SyncCryptographerTest, MAYBE_PackUnpack) { | 214 TEST_F(CryptographerTest, MAYBE_PackUnpack) { |
215 Nigori nigori; | 215 Nigori nigori; |
216 ASSERT_TRUE(nigori.InitByDerivation("example.com", "username", "password")); | 216 ASSERT_TRUE(nigori.InitByDerivation("example.com", "username", "password")); |
217 std::string expected_user, expected_encryption, expected_mac; | 217 std::string expected_user, expected_encryption, expected_mac; |
218 ASSERT_TRUE(nigori.ExportKeys(&expected_user, &expected_encryption, | 218 ASSERT_TRUE(nigori.ExportKeys(&expected_user, &expected_encryption, |
219 &expected_mac)); | 219 &expected_mac)); |
220 | 220 |
221 std::string token; | 221 std::string token; |
222 EXPECT_TRUE(cryptographer_.PackBootstrapToken(&nigori, &token)); | 222 EXPECT_TRUE(cryptographer_.PackBootstrapToken(&nigori, &token)); |
223 EXPECT_TRUE(IsStringUTF8(token)); | 223 EXPECT_TRUE(IsStringUTF8(token)); |
224 | 224 |
225 scoped_ptr<Nigori> unpacked(cryptographer_.UnpackBootstrapToken(token)); | 225 scoped_ptr<Nigori> unpacked(cryptographer_.UnpackBootstrapToken(token)); |
226 EXPECT_NE(static_cast<Nigori*>(NULL), unpacked.get()); | 226 EXPECT_NE(static_cast<Nigori*>(NULL), unpacked.get()); |
227 | 227 |
228 std::string user_key, encryption_key, mac_key; | 228 std::string user_key, encryption_key, mac_key; |
229 ASSERT_TRUE(unpacked->ExportKeys(&user_key, &encryption_key, &mac_key)); | 229 ASSERT_TRUE(unpacked->ExportKeys(&user_key, &encryption_key, &mac_key)); |
230 | 230 |
231 EXPECT_EQ(expected_user, user_key); | 231 EXPECT_EQ(expected_user, user_key); |
232 EXPECT_EQ(expected_encryption, encryption_key); | 232 EXPECT_EQ(expected_encryption, encryption_key); |
233 EXPECT_EQ(expected_mac, mac_key); | 233 EXPECT_EQ(expected_mac, mac_key); |
234 } | 234 } |
235 | 235 |
236 // Test that bootstrapping the keystore key works and doesn't affect the default | 236 // Test that bootstrapping the keystore key works and doesn't affect the default |
237 // nigori. | 237 // nigori. |
238 TEST_F(SyncCryptographerTest, BootstrapKeystore) { | 238 TEST_F(CryptographerTest, BootstrapKeystore) { |
239 std::string token; | 239 std::string token; |
240 cryptographer_.GetKeystoreKeyBootstrapToken(&token); | 240 cryptographer_.GetKeystoreKeyBootstrapToken(&token); |
241 EXPECT_TRUE(token.empty()); | 241 EXPECT_TRUE(token.empty()); |
242 | 242 |
243 cryptographer_.SetKeystoreKey("keystore_key"); | 243 cryptographer_.SetKeystoreKey("keystore_key"); |
244 cryptographer_.GetKeystoreKeyBootstrapToken(&token); | 244 cryptographer_.GetKeystoreKeyBootstrapToken(&token); |
245 EXPECT_FALSE(token.empty()); | 245 EXPECT_FALSE(token.empty()); |
246 | 246 |
247 Cryptographer cryptographer2(&encryptor_); | 247 Cryptographer cryptographer2(&encryptor_); |
248 EXPECT_FALSE(cryptographer2.HasKeystoreKey()); | 248 EXPECT_FALSE(cryptographer2.HasKeystoreKey()); |
249 cryptographer2.BootstrapKeystoreKey(token); | 249 cryptographer2.BootstrapKeystoreKey(token); |
250 EXPECT_TRUE(cryptographer2.HasKeystoreKey()); | 250 EXPECT_TRUE(cryptographer2.HasKeystoreKey()); |
251 EXPECT_FALSE(cryptographer2.is_initialized()); | 251 EXPECT_FALSE(cryptographer2.is_initialized()); |
252 } | 252 } |
253 | 253 |
254 TEST_F(SyncCryptographerTest, NigoriEncryptionTypes) { | 254 TEST_F(CryptographerTest, NigoriEncryptionTypes) { |
255 Cryptographer cryptographer2(&encryptor_); | 255 Cryptographer cryptographer2(&encryptor_); |
256 sync_pb::NigoriSpecifics nigori; | 256 sync_pb::NigoriSpecifics nigori; |
257 | 257 |
258 StrictMock<MockObserver> observer; | 258 StrictMock<MockObserver> observer; |
259 cryptographer_.AddObserver(&observer); | 259 cryptographer_.AddObserver(&observer); |
260 StrictMock<MockObserver> observer2; | 260 StrictMock<MockObserver> observer2; |
261 cryptographer2.AddObserver(&observer2); | 261 cryptographer2.AddObserver(&observer2); |
262 | 262 |
263 // Just set the sensitive types (shouldn't trigger any | 263 // Just set the sensitive types (shouldn't trigger any |
264 // notifications). | 264 // notifications). |
(...skipping 23 matching lines...) Expand all Loading... |
288 EXPECT_TRUE(encrypted_types.Equals(cryptographer2.GetEncryptedTypes())); | 288 EXPECT_TRUE(encrypted_types.Equals(cryptographer2.GetEncryptedTypes())); |
289 | 289 |
290 // Receiving an empty nigori should not reset any encrypted types or trigger | 290 // Receiving an empty nigori should not reset any encrypted types or trigger |
291 // an observer notification. | 291 // an observer notification. |
292 Mock::VerifyAndClearExpectations(&observer); | 292 Mock::VerifyAndClearExpectations(&observer); |
293 nigori = sync_pb::NigoriSpecifics(); | 293 nigori = sync_pb::NigoriSpecifics(); |
294 cryptographer_.UpdateEncryptedTypesFromNigori(nigori); | 294 cryptographer_.UpdateEncryptedTypesFromNigori(nigori); |
295 EXPECT_TRUE(encrypted_types.Equals(cryptographer_.GetEncryptedTypes())); | 295 EXPECT_TRUE(encrypted_types.Equals(cryptographer_.GetEncryptedTypes())); |
296 } | 296 } |
297 | 297 |
298 TEST_F(SyncCryptographerTest, EncryptEverythingExplicit) { | 298 TEST_F(CryptographerTest, EncryptEverythingExplicit) { |
299 ModelTypeSet real_types = ModelTypeSet::All(); | 299 ModelTypeSet real_types = ModelTypeSet::All(); |
300 sync_pb::NigoriSpecifics specifics; | 300 sync_pb::NigoriSpecifics specifics; |
301 specifics.set_encrypt_everything(true); | 301 specifics.set_encrypt_everything(true); |
302 | 302 |
303 StrictMock<MockObserver> observer; | 303 StrictMock<MockObserver> observer; |
304 cryptographer_.AddObserver(&observer); | 304 cryptographer_.AddObserver(&observer); |
305 | 305 |
306 EXPECT_CALL(observer, | 306 EXPECT_CALL(observer, |
307 OnEncryptedTypesChanged( | 307 OnEncryptedTypesChanged( |
308 HasModelTypes(ModelTypeSet::All()), true)); | 308 HasModelTypes(ModelTypeSet::All()), true)); |
(...skipping 16 matching lines...) Expand all Loading... |
325 iter.Good(); iter.Inc()) { | 325 iter.Good(); iter.Inc()) { |
326 EXPECT_TRUE(encrypted_types.Has(iter.Get())); | 326 EXPECT_TRUE(encrypted_types.Has(iter.Get())); |
327 } | 327 } |
328 | 328 |
329 // Shouldn't trigger another notification. | 329 // Shouldn't trigger another notification. |
330 specifics.set_encrypt_everything(true); | 330 specifics.set_encrypt_everything(true); |
331 | 331 |
332 cryptographer_.RemoveObserver(&observer); | 332 cryptographer_.RemoveObserver(&observer); |
333 } | 333 } |
334 | 334 |
335 TEST_F(SyncCryptographerTest, EncryptEverythingImplicit) { | 335 TEST_F(CryptographerTest, EncryptEverythingImplicit) { |
336 ModelTypeSet real_types = ModelTypeSet::All(); | 336 ModelTypeSet real_types = ModelTypeSet::All(); |
337 sync_pb::NigoriSpecifics specifics; | 337 sync_pb::NigoriSpecifics specifics; |
338 specifics.set_encrypt_bookmarks(true); // Non-passwords = encrypt everything | 338 specifics.set_encrypt_bookmarks(true); // Non-passwords = encrypt everything |
339 | 339 |
340 StrictMock<MockObserver> observer; | 340 StrictMock<MockObserver> observer; |
341 cryptographer_.AddObserver(&observer); | 341 cryptographer_.AddObserver(&observer); |
342 | 342 |
343 EXPECT_CALL(observer, | 343 EXPECT_CALL(observer, |
344 OnEncryptedTypesChanged( | 344 OnEncryptedTypesChanged( |
345 HasModelTypes(ModelTypeSet::All()), true)); | 345 HasModelTypes(ModelTypeSet::All()), true)); |
(...skipping 16 matching lines...) Expand all Loading... |
362 iter.Good(); iter.Inc()) { | 362 iter.Good(); iter.Inc()) { |
363 EXPECT_TRUE(encrypted_types.Has(iter.Get())); | 363 EXPECT_TRUE(encrypted_types.Has(iter.Get())); |
364 } | 364 } |
365 | 365 |
366 // Shouldn't trigger another notification. | 366 // Shouldn't trigger another notification. |
367 specifics.set_encrypt_everything(true); | 367 specifics.set_encrypt_everything(true); |
368 | 368 |
369 cryptographer_.RemoveObserver(&observer); | 369 cryptographer_.RemoveObserver(&observer); |
370 } | 370 } |
371 | 371 |
372 TEST_F(SyncCryptographerTest, UnknownSensitiveTypes) { | 372 TEST_F(CryptographerTest, UnknownSensitiveTypes) { |
373 ModelTypeSet real_types = ModelTypeSet::All(); | 373 ModelTypeSet real_types = ModelTypeSet::All(); |
374 sync_pb::NigoriSpecifics specifics; | 374 sync_pb::NigoriSpecifics specifics; |
375 // Explicitly setting encrypt everything should override logic for implicit | 375 // Explicitly setting encrypt everything should override logic for implicit |
376 // encrypt everything. | 376 // encrypt everything. |
377 specifics.set_encrypt_everything(false); | 377 specifics.set_encrypt_everything(false); |
378 specifics.set_encrypt_bookmarks(true); | 378 specifics.set_encrypt_bookmarks(true); |
379 | 379 |
380 StrictMock<MockObserver> observer; | 380 StrictMock<MockObserver> observer; |
381 cryptographer_.AddObserver(&observer); | 381 cryptographer_.AddObserver(&observer); |
382 | 382 |
(...skipping 25 matching lines...) Expand all Loading... |
408 iter.Get() == BOOKMARKS) | 408 iter.Get() == BOOKMARKS) |
409 EXPECT_TRUE(encrypted_types.Has(iter.Get())); | 409 EXPECT_TRUE(encrypted_types.Has(iter.Get())); |
410 else | 410 else |
411 EXPECT_FALSE(encrypted_types.Has(iter.Get())); | 411 EXPECT_FALSE(encrypted_types.Has(iter.Get())); |
412 } | 412 } |
413 | 413 |
414 cryptographer_.RemoveObserver(&observer); | 414 cryptographer_.RemoveObserver(&observer); |
415 } | 415 } |
416 | 416 |
417 } // namespace syncer | 417 } // namespace syncer |
OLD | NEW |