Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(54)

Issues Search
    My Issues | Starred     Open | Closed | All

Side by Side Diff: components/autofill/browser/personal_data_manager_unittest.cc

Issue 17392006: In components/autofill, move browser/ to core/browser/ (Closed) Base URL: svn://svn.chromium.org/chrome/trunk/src
Patch Set: Rebase to fix conflicts Created 7 years, 6 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View unified diff | Download patch | Annotate | Revision Log
« no previous file with comments | « components/autofill/browser/personal_data_manager_observer.h ('k') | components/autofill/browser/phone_field.h » ('j') | no next file with comments »
Toggle Intra-line Diffs ('i') | Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
OLDNEW
(Empty)
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
3 // found in the LICENSE file.
4
5 #include <string>
6
7 #include "base/basictypes.h"
8 #include "base/guid.h"
9 #include "base/memory/scoped_ptr.h"
10 #include "base/message_loop.h"
11 #include "base/strings/utf_string_conversions.h"
12 #include "base/synchronization/waitable_event.h"
13 #include "chrome/test/base/testing_browser_process.h"
14 #include "chrome/test/base/testing_profile.h"
15 #include "components/autofill/browser/autofill_common_test.h"
16 #include "components/autofill/browser/autofill_metrics.h"
17 #include "components/autofill/browser/autofill_profile.h"
18 #include "components/autofill/browser/form_structure.h"
19 #include "components/autofill/browser/personal_data_manager.h"
20 #include "components/autofill/browser/personal_data_manager_observer.h"
21 #include "components/autofill/browser/webdata/autofill_webdata_service.h"
22 #include "components/autofill/core/common/form_data.h"
23 #include "components/webdata/encryptor/encryptor.h"
24 #include "content/public/browser/notification_details.h"
25 #include "content/public/browser/notification_registrar.h"
26 #include "content/public/browser/notification_source.h"
27 #include "content/public/browser/notification_types.h"
28 #include "content/public/test/mock_notification_observer.h"
29 #include "content/public/test/test_browser_thread.h"
30 #include "testing/gmock/include/gmock/gmock.h"
31 #include "testing/gtest/include/gtest/gtest.h"
32
33 using content::BrowserThread;
34
35 namespace autofill {
36 namespace {
37
38 ACTION(QuitUIMessageLoop) {
39 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
40 base::MessageLoop::current()->Quit();
41 }
42
43 class PersonalDataLoadedObserverMock : public PersonalDataManagerObserver {
44 public:
45 PersonalDataLoadedObserverMock() {}
46 virtual ~PersonalDataLoadedObserverMock() {}
47
48 MOCK_METHOD0(OnPersonalDataChanged, void());
49 };
50
51 // Unlike the base AutofillMetrics, exposes copy and assignment constructors,
52 // which are handy for briefer test code. The AutofillMetrics class is
53 // stateless, so this is safe.
54 class TestAutofillMetrics : public AutofillMetrics {
55 public:
56 TestAutofillMetrics() {}
57 virtual ~TestAutofillMetrics() {}
58 };
59
60 } // anonymous namespace
61
62 class PersonalDataManagerTest : public testing::Test {
63 protected:
64 PersonalDataManagerTest()
65 : ui_thread_(BrowserThread::UI, &message_loop_),
66 db_thread_(BrowserThread::DB) {
67 }
68
69 virtual void SetUp() {
70 db_thread_.Start();
71
72 profile_.reset(new TestingProfile);
73 profile_->CreateWebDataService();
74
75 test::DisableSystemServices(profile_.get());
76 ResetPersonalDataManager();
77 }
78
79 virtual void TearDown() {
80 // Destruction order is imposed explicitly here.
81 personal_data_.reset(NULL);
82 profile_.reset(NULL);
83
84 // Schedule another task on the DB thread to notify us that it's safe to
85 // stop the thread.
86 base::WaitableEvent done(false, false);
87 BrowserThread::PostTask(BrowserThread::DB, FROM_HERE,
88 base::Bind(&base::WaitableEvent::Signal, base::Unretained(&done)));
89 done.Wait();
90 base::MessageLoop::current()->PostTask(FROM_HERE,
91 base::MessageLoop::QuitClosure());
92 base::MessageLoop::current()->Run();
93 db_thread_.Stop();
94 }
95
96 void ResetPersonalDataManager() {
97 personal_data_.reset(new PersonalDataManager("en-US"));
98 personal_data_->Init(profile_.get());
99 personal_data_->AddObserver(&personal_data_observer_);
100
101 // Verify that the web database has been updated and the notification sent.
102 EXPECT_CALL(personal_data_observer_,
103 OnPersonalDataChanged()).WillOnce(QuitUIMessageLoop());
104 base::MessageLoop::current()->Run();
105 }
106
107 void MakeProfileIncognito() {
108 profile_->set_incognito(true);
109 }
110
111 base::MessageLoopForUI message_loop_;
112 content::TestBrowserThread ui_thread_;
113 content::TestBrowserThread db_thread_;
114 scoped_ptr<TestingProfile> profile_;
115 scoped_ptr<PersonalDataManager> personal_data_;
116 content::NotificationRegistrar registrar_;
117 content::MockNotificationObserver observer_;
118 PersonalDataLoadedObserverMock personal_data_observer_;
119 };
120
121 TEST_F(PersonalDataManagerTest, AddProfile) {
122 // Add profile0 to the database.
123 AutofillProfile profile0(autofill::test::GetFullProfile());
124 profile0.SetRawInfo(EMAIL_ADDRESS, ASCIIToUTF16("j@s.com"));
125 personal_data_->AddProfile(profile0);
126
127 // Reload the database.
128 ResetPersonalDataManager();
129
130 // Verify the addition.
131 const std::vector<AutofillProfile*>& results1 = personal_data_->GetProfiles();
132 ASSERT_EQ(1U, results1.size());
133 EXPECT_EQ(0, profile0.Compare(*results1[0]));
134
135 // Add profile with identical values. Duplicates should not get saved.
136 AutofillProfile profile0a = profile0;
137 profile0a.set_guid(base::GenerateGUID());
138 personal_data_->AddProfile(profile0a);
139
140 // Reload the database.
141 ResetPersonalDataManager();
142
143 // Verify the non-addition.
144 const std::vector<AutofillProfile*>& results2 = personal_data_->GetProfiles();
145 ASSERT_EQ(1U, results2.size());
146 EXPECT_EQ(0, profile0.Compare(*results2[0]));
147
148 // New profile with different email.
149 AutofillProfile profile1 = profile0;
150 profile1.set_guid(base::GenerateGUID());
151 profile1.SetRawInfo(EMAIL_ADDRESS, ASCIIToUTF16("john@smith.com"));
152
153 // Add the different profile. This should save as a separate profile.
154 // Note that if this same profile was "merged" it would collapse to one
155 // profile with a multi-valued entry for email.
156 personal_data_->AddProfile(profile1);
157
158 // Reload the database.
159 ResetPersonalDataManager();
160
161 // Verify the addition.
162 const std::vector<AutofillProfile*>& results3 = personal_data_->GetProfiles();
163 ASSERT_EQ(2U, results3.size());
164 EXPECT_EQ(0, profile0.Compare(*results3[0]));
165 EXPECT_EQ(0, profile1.Compare(*results3[1]));
166 }
167
168 TEST_F(PersonalDataManagerTest, AddUpdateRemoveProfiles) {
169 AutofillProfile profile0(base::GenerateGUID(), "https://www.example.com");
170 test::SetProfileInfo(&profile0,
171 "Marion", "Mitchell", "Morrison",
172 "johnwayne@me.xyz", "Fox", "123 Zoo St.", "unit 5", "Hollywood", "CA",
173 "91601", "US", "12345678910");
174
175 AutofillProfile profile1(base::GenerateGUID(), "https://www.example.com");
176 test::SetProfileInfo(&profile1,
177 "Josephine", "Alicia", "Saenz",
178 "joewayne@me.xyz", "Fox", "903 Apple Ct.", NULL, "Orlando", "FL", "32801",
179 "US", "19482937549");
180
181 AutofillProfile profile2(base::GenerateGUID(), "https://www.example.com");
182 test::SetProfileInfo(&profile2,
183 "Josephine", "Alicia", "Saenz",
184 "joewayne@me.xyz", "Fox", "1212 Center.", "Bld. 5", "Orlando", "FL",
185 "32801", "US", "19482937549");
186
187 // Add two test profiles to the database.
188 personal_data_->AddProfile(profile0);
189 personal_data_->AddProfile(profile1);
190
191 // Verify that the web database has been updated and the notification sent.
192 EXPECT_CALL(personal_data_observer_,
193 OnPersonalDataChanged()).WillOnce(QuitUIMessageLoop());
194 base::MessageLoop::current()->Run();
195
196 const std::vector<AutofillProfile*>& results1 = personal_data_->GetProfiles();
197 ASSERT_EQ(2U, results1.size());
198 EXPECT_EQ(0, profile0.Compare(*results1[0]));
199 EXPECT_EQ(0, profile1.Compare(*results1[1]));
200
201 // Update, remove, and add.
202 profile0.SetRawInfo(NAME_FIRST, ASCIIToUTF16("John"));
203 personal_data_->UpdateProfile(profile0);
204 personal_data_->RemoveByGUID(profile1.guid());
205 personal_data_->AddProfile(profile2);
206
207 // Verify that the web database has been updated and the notification sent.
208 EXPECT_CALL(personal_data_observer_,
209 OnPersonalDataChanged()).WillOnce(QuitUIMessageLoop());
210 base::MessageLoop::current()->Run();
211
212 const std::vector<AutofillProfile*>& results2 = personal_data_->GetProfiles();
213 ASSERT_EQ(2U, results2.size());
214 EXPECT_EQ(0, profile0.Compare(*results2[0]));
215 EXPECT_EQ(0, profile2.Compare(*results2[1]));
216
217 // Reset the PersonalDataManager. This tests that the personal data was saved
218 // to the web database, and that we can load the profiles from the web
219 // database.
220 ResetPersonalDataManager();
221
222 // Verify that we've loaded the profiles from the web database.
223 const std::vector<AutofillProfile*>& results3 = personal_data_->GetProfiles();
224 ASSERT_EQ(2U, results3.size());
225 EXPECT_EQ(0, profile0.Compare(*results3[0]));
226 EXPECT_EQ(0, profile2.Compare(*results3[1]));
227 }
228
229 TEST_F(PersonalDataManagerTest, AddUpdateRemoveCreditCards) {
230 CreditCard credit_card0(base::GenerateGUID(), "https://www.example.com");
231 test::SetCreditCardInfo(&credit_card0,
232 "John Dillinger", "423456789012" /* Visa */, "01", "2010");
233
234 CreditCard credit_card1(base::GenerateGUID(), "https://www.example.com");
235 test::SetCreditCardInfo(&credit_card1,
236 "Bonnie Parker", "518765432109" /* Mastercard */, "12", "2012");
237
238 CreditCard credit_card2(base::GenerateGUID(), "https://www.example.com");
239 test::SetCreditCardInfo(&credit_card2,
240 "Clyde Barrow", "347666888555" /* American Express */, "04", "2015");
241
242 // Add two test credit cards to the database.
243 personal_data_->AddCreditCard(credit_card0);
244 personal_data_->AddCreditCard(credit_card1);
245
246 // Verify that the web database has been updated and the notification sent.
247 EXPECT_CALL(personal_data_observer_,
248 OnPersonalDataChanged()).WillOnce(QuitUIMessageLoop());
249 base::MessageLoop::current()->Run();
250
251 const std::vector<CreditCard*>& results1 = personal_data_->GetCreditCards();
252 ASSERT_EQ(2U, results1.size());
253 EXPECT_EQ(0, credit_card0.Compare(*results1[0]));
254 EXPECT_EQ(0, credit_card1.Compare(*results1[1]));
255
256 // Update, remove, and add.
257 credit_card0.SetRawInfo(CREDIT_CARD_NAME, ASCIIToUTF16("Joe"));
258 personal_data_->UpdateCreditCard(credit_card0);
259 personal_data_->RemoveByGUID(credit_card1.guid());
260 personal_data_->AddCreditCard(credit_card2);
261
262 // Verify that the web database has been updated and the notification sent.
263 EXPECT_CALL(personal_data_observer_,
264 OnPersonalDataChanged()).WillOnce(QuitUIMessageLoop());
265 base::MessageLoop::current()->Run();
266
267 const std::vector<CreditCard*>& results2 = personal_data_->GetCreditCards();
268 ASSERT_EQ(2U, results2.size());
269 EXPECT_EQ(credit_card0, *results2[0]);
270 EXPECT_EQ(credit_card2, *results2[1]);
271
272 // Reset the PersonalDataManager. This tests that the personal data was saved
273 // to the web database, and that we can load the credit cards from the web
274 // database.
275 ResetPersonalDataManager();
276
277 // Verify that we've loaded the credit cards from the web database.
278 const std::vector<CreditCard*>& results3 = personal_data_->GetCreditCards();
279 ASSERT_EQ(2U, results3.size());
280 EXPECT_EQ(credit_card0, *results3[0]);
281 EXPECT_EQ(credit_card2, *results3[1]);
282 }
283
284 TEST_F(PersonalDataManagerTest, UpdateUnverifiedProfilesAndCreditCards) {
285 // Start with unverified data.
286 AutofillProfile profile(base::GenerateGUID(), "https://www.example.com/");
287 test::SetProfileInfo(&profile,
288 "Marion", "Mitchell", "Morrison",
289 "johnwayne@me.xyz", "Fox", "123 Zoo St.", "unit 5", "Hollywood", "CA",
290 "91601", "US", "12345678910");
291 EXPECT_FALSE(profile.IsVerified());
292
293 CreditCard credit_card(base::GenerateGUID(), "https://www.example.com/");
294 test::SetCreditCardInfo(&credit_card,
295 "John Dillinger", "423456789012" /* Visa */, "01", "2010");
296 EXPECT_FALSE(credit_card.IsVerified());
297
298 // Add the data to the database.
299 personal_data_->AddProfile(profile);
300 personal_data_->AddCreditCard(credit_card);
301
302 // Verify that the web database has been updated and the notification sent.
303 EXPECT_CALL(personal_data_observer_,
304 OnPersonalDataChanged()).WillOnce(QuitUIMessageLoop());
305 base::MessageLoop::current()->Run();
306
307 const std::vector<AutofillProfile*>& profiles1 =
308 personal_data_->GetProfiles();
309 const std::vector<CreditCard*>& cards1 = personal_data_->GetCreditCards();
310 ASSERT_EQ(1U, profiles1.size());
311 ASSERT_EQ(1U, cards1.size());
312 EXPECT_EQ(0, profile.Compare(*profiles1[0]));
313 EXPECT_EQ(0, credit_card.Compare(*cards1[0]));
314
315 // Try to update with just the origin changed.
316 AutofillProfile original_profile(profile);
317 CreditCard original_credit_card(credit_card);
318 profile.set_origin("Chrome settings");
319 credit_card.set_origin("Chrome settings");
320
321 EXPECT_TRUE(profile.IsVerified());
322 EXPECT_TRUE(credit_card.IsVerified());
323
324 personal_data_->UpdateProfile(profile);
325 personal_data_->UpdateCreditCard(credit_card);
326
327 // Note: No refresh, as no update is expected.
328
329 const std::vector<AutofillProfile*>& profiles2 =
330 personal_data_->GetProfiles();
331 const std::vector<CreditCard*>& cards2 = personal_data_->GetCreditCards();
332 ASSERT_EQ(1U, profiles2.size());
333 ASSERT_EQ(1U, cards2.size());
334 EXPECT_NE(profile.origin(), profiles2[0]->origin());
335 EXPECT_NE(credit_card.origin(), cards2[0]->origin());
336 EXPECT_EQ(original_profile.origin(), profiles2[0]->origin());
337 EXPECT_EQ(original_credit_card.origin(), cards2[0]->origin());
338
339 // Try to update with data changed as well.
340 profile.SetRawInfo(NAME_FIRST, ASCIIToUTF16("John"));
341 credit_card.SetRawInfo(CREDIT_CARD_NAME, ASCIIToUTF16("Joe"));
342
343 personal_data_->UpdateProfile(profile);
344 personal_data_->UpdateCreditCard(credit_card);
345
346 // Verify that the web database has been updated and the notification sent.
347 EXPECT_CALL(personal_data_observer_,
348 OnPersonalDataChanged()).WillOnce(QuitUIMessageLoop());
349 base::MessageLoop::current()->Run();
350
351 const std::vector<AutofillProfile*>& profiles3 =
352 personal_data_->GetProfiles();
353 const std::vector<CreditCard*>& cards3 = personal_data_->GetCreditCards();
354 ASSERT_EQ(1U, profiles3.size());
355 ASSERT_EQ(1U, cards3.size());
356 EXPECT_EQ(0, profile.Compare(*profiles3[0]));
357 EXPECT_EQ(0, credit_card.Compare(*cards3[0]));
358 EXPECT_EQ(profile.origin(), profiles3[0]->origin());
359 EXPECT_EQ(credit_card.origin(), cards3[0]->origin());
360 }
361
362 TEST_F(PersonalDataManagerTest, AddProfilesAndCreditCards) {
363 AutofillProfile profile0(base::GenerateGUID(), "https://www.example.com");
364 test::SetProfileInfo(&profile0,
365 "Marion", "Mitchell", "Morrison",
366 "johnwayne@me.xyz", "Fox", "123 Zoo St.", "unit 5", "Hollywood", "CA",
367 "91601", "US", "12345678910");
368
369 AutofillProfile profile1(base::GenerateGUID(), "https://www.example.com");
370 test::SetProfileInfo(&profile1,
371 "Josephine", "Alicia", "Saenz",
372 "joewayne@me.xyz", "Fox", "903 Apple Ct.", NULL, "Orlando", "FL", "32801",
373 "US", "19482937549");
374
375 CreditCard credit_card0(base::GenerateGUID(), "https://www.example.com");
376 test::SetCreditCardInfo(&credit_card0,
377 "John Dillinger", "423456789012" /* Visa */, "01", "2010");
378
379 CreditCard credit_card1(base::GenerateGUID(), "https://www.example.com");
380 test::SetCreditCardInfo(&credit_card1,
381 "Bonnie Parker", "518765432109" /* Mastercard */, "12", "2012");
382
383 // Add two test profiles to the database.
384 personal_data_->AddProfile(profile0);
385 personal_data_->AddProfile(profile1);
386
387 // Verify that the web database has been updated and the notification sent.
388 EXPECT_CALL(personal_data_observer_,
389 OnPersonalDataChanged()).WillOnce(QuitUIMessageLoop());
390 base::MessageLoop::current()->Run();
391
392 const std::vector<AutofillProfile*>& results1 = personal_data_->GetProfiles();
393 ASSERT_EQ(2U, results1.size());
394 EXPECT_EQ(0, profile0.Compare(*results1[0]));
395 EXPECT_EQ(0, profile1.Compare(*results1[1]));
396
397 // Add two test credit cards to the database.
398 personal_data_->AddCreditCard(credit_card0);
399 personal_data_->AddCreditCard(credit_card1);
400
401 // Verify that the web database has been updated and the notification sent.
402 EXPECT_CALL(personal_data_observer_,
403 OnPersonalDataChanged()).WillOnce(QuitUIMessageLoop());
404 base::MessageLoop::current()->Run();
405
406 const std::vector<CreditCard*>& results2 = personal_data_->GetCreditCards();
407 ASSERT_EQ(2U, results2.size());
408 EXPECT_EQ(credit_card0, *results2[0]);
409 EXPECT_EQ(credit_card1, *results2[1]);
410
411 // Determine uniqueness by inserting all of the GUIDs into a set and verifying
412 // the size of the set matches the number of GUIDs.
413 std::set<std::string> guids;
414 guids.insert(profile0.guid());
415 guids.insert(profile1.guid());
416 guids.insert(credit_card0.guid());
417 guids.insert(credit_card1.guid());
418 EXPECT_EQ(4U, guids.size());
419 }
420
421 // Test for http://crbug.com/50047. Makes sure that guids are populated
422 // correctly on load.
423 TEST_F(PersonalDataManagerTest, PopulateUniqueIDsOnLoad) {
424 AutofillProfile profile0(base::GenerateGUID(), "https://www.example.com");
425 test::SetProfileInfo(&profile0,
426 "y", "", "", "", "", "", "", "", "", "", "", "");
427
428 // Add the profile0 to the db.
429 personal_data_->AddProfile(profile0);
430
431 // Verify that the web database has been updated and the notification sent.
432 EXPECT_CALL(personal_data_observer_,
433 OnPersonalDataChanged()).WillOnce(QuitUIMessageLoop());
434 base::MessageLoop::current()->Run();
435
436 // Verify that we've loaded the profiles from the web database.
437 const std::vector<AutofillProfile*>& results2 = personal_data_->GetProfiles();
438 ASSERT_EQ(1U, results2.size());
439 EXPECT_EQ(0, profile0.Compare(*results2[0]));
440
441 // Add a new profile.
442 AutofillProfile profile1(base::GenerateGUID(), "https://www.example.com");
443 test::SetProfileInfo(&profile1,
444 "z", "", "", "", "", "", "", "", "", "", "", "");
445 personal_data_->AddProfile(profile1);
446
447 // Verify that the web database has been updated and the notification sent.
448 EXPECT_CALL(personal_data_observer_,
449 OnPersonalDataChanged()).WillOnce(QuitUIMessageLoop());
450 base::MessageLoop::current()->Run();
451
452 // Make sure the two profiles have different GUIDs, both valid.
453 const std::vector<AutofillProfile*>& results3 = personal_data_->GetProfiles();
454 ASSERT_EQ(2U, results3.size());
455 EXPECT_NE(results3[0]->guid(), results3[1]->guid());
456 EXPECT_TRUE(base::IsValidGUID(results3[0]->guid()));
457 EXPECT_TRUE(base::IsValidGUID(results3[1]->guid()));
458 }
459
460 TEST_F(PersonalDataManagerTest, SetEmptyProfile) {
461 AutofillProfile profile0(base::GenerateGUID(), "https://www.example.com");
462 test::SetProfileInfo(&profile0,
463 "", "", "", "", "", "", "", "", "", "", "", "");
464
465 // Add the empty profile to the database.
466 personal_data_->AddProfile(profile0);
467
468 // Note: no refresh here.
469
470 // Reset the PersonalDataManager. This tests that the personal data was saved
471 // to the web database, and that we can load the profiles from the web
472 // database.
473 ResetPersonalDataManager();
474
475 // Verify that we've loaded the profiles from the web database.
476 const std::vector<AutofillProfile*>& results2 = personal_data_->GetProfiles();
477 ASSERT_EQ(0U, results2.size());
478 }
479
480 TEST_F(PersonalDataManagerTest, SetEmptyCreditCard) {
481 CreditCard credit_card0(base::GenerateGUID(), "https://www.example.com");
482 test::SetCreditCardInfo(&credit_card0, "", "", "", "");
483
484 // Add the empty credit card to the database.
485 personal_data_->AddCreditCard(credit_card0);
486
487 // Note: no refresh here.
488
489 // Reset the PersonalDataManager. This tests that the personal data was saved
490 // to the web database, and that we can load the credit cards from the web
491 // database.
492 ResetPersonalDataManager();
493
494 // Verify that we've loaded the credit cards from the web database.
495 const std::vector<CreditCard*>& results2 = personal_data_->GetCreditCards();
496 ASSERT_EQ(0U, results2.size());
497 }
498
499 TEST_F(PersonalDataManagerTest, Refresh) {
500 AutofillProfile profile0(base::GenerateGUID(), "https://www.example.com");
501 test::SetProfileInfo(&profile0,
502 "Marion", "Mitchell", "Morrison",
503 "johnwayne@me.xyz", "Fox", "123 Zoo St.", "unit 5", "Hollywood", "CA",
504 "91601", "US", "12345678910");
505
506 AutofillProfile profile1(base::GenerateGUID(), "https://www.example.com");
507 test::SetProfileInfo(&profile1,
508 "Josephine", "Alicia", "Saenz",
509 "joewayne@me.xyz", "Fox", "903 Apple Ct.", NULL, "Orlando", "FL", "32801",
510 "US", "19482937549");
511
512 // Add the test profiles to the database.
513 personal_data_->AddProfile(profile0);
514 personal_data_->AddProfile(profile1);
515
516 // Labels depend on other profiles in the list - update labels manually.
517 std::vector<AutofillProfile *> profile_pointers;
518 profile_pointers.push_back(&profile0);
519 profile_pointers.push_back(&profile1);
520 AutofillProfile::AdjustInferredLabels(&profile_pointers);
521
522 // Verify that the web database has been updated and the notification sent.
523 EXPECT_CALL(personal_data_observer_,
524 OnPersonalDataChanged()).WillOnce(QuitUIMessageLoop());
525 base::MessageLoop::current()->Run();
526
527 const std::vector<AutofillProfile*>& results1 = personal_data_->GetProfiles();
528 ASSERT_EQ(2U, results1.size());
529 EXPECT_EQ(profile0, *results1[0]);
530 EXPECT_EQ(profile1, *results1[1]);
531
532 AutofillProfile profile2(base::GenerateGUID(), "https://www.example.com");
533 test::SetProfileInfo(&profile2,
534 "Josephine", "Alicia", "Saenz",
535 "joewayne@me.xyz", "Fox", "1212 Center.", "Bld. 5", "Orlando", "FL",
536 "32801", "US", "19482937549");
537
538 // Adjust all labels.
539 profile_pointers.push_back(&profile2);
540 AutofillProfile::AdjustInferredLabels(&profile_pointers);
541
542 scoped_refptr<AutofillWebDataService> wds =
543 AutofillWebDataService::FromBrowserContext(profile_.get());
544 ASSERT_TRUE(wds.get());
545 wds->AddAutofillProfile(profile2);
546
547 personal_data_->Refresh();
548
549 // Verify that the web database has been updated and the notification sent.
550 EXPECT_CALL(personal_data_observer_,
551 OnPersonalDataChanged()).WillOnce(QuitUIMessageLoop());
552 base::MessageLoop::current()->Run();
553
554 const std::vector<AutofillProfile*>& results2 = personal_data_->GetProfiles();
555 ASSERT_EQ(3U, results2.size());
556 EXPECT_EQ(profile0, *results2[0]);
557 EXPECT_EQ(profile1, *results2[1]);
558 EXPECT_EQ(profile2, *results2[2]);
559
560 wds->RemoveAutofillProfile(profile1.guid());
561 wds->RemoveAutofillProfile(profile2.guid());
562
563 // Before telling the PDM to refresh, simulate an edit to one of the deleted
564 // profiles via a SetProfile update (this would happen if the Autofill window
565 // was open with a previous snapshot of the profiles, and something
566 // [e.g. sync] removed a profile from the browser. In this edge case, we will
567 // end up in a consistent state by dropping the write).
568 profile0.SetRawInfo(NAME_FIRST, ASCIIToUTF16("Mar"));
569 profile2.SetRawInfo(NAME_FIRST, ASCIIToUTF16("Jo"));
570 personal_data_->UpdateProfile(profile0);
571 personal_data_->AddProfile(profile1);
572 personal_data_->AddProfile(profile2);
573
574 // Verify that the web database has been updated and the notification sent.
575 EXPECT_CALL(personal_data_observer_,
576 OnPersonalDataChanged()).WillOnce(QuitUIMessageLoop());
577 base::MessageLoop::current()->Run();
578
579 const std::vector<AutofillProfile*>& results3 = personal_data_->GetProfiles();
580 ASSERT_EQ(1U, results3.size());
581 EXPECT_EQ(profile0, *results2[0]);
582 }
583
584 TEST_F(PersonalDataManagerTest, ImportFormData) {
585 FormData form;
586 FormFieldData field;
587 test::CreateTestFormField(
588 "First name:", "first_name", "George", "text", &field);
589 form.fields.push_back(field);
590 test::CreateTestFormField(
591 "Last name:", "last_name", "Washington", "text", &field);
592 form.fields.push_back(field);
593 test::CreateTestFormField(
594 "Email:", "email", "theprez@gmail.com", "text", &field);
595 form.fields.push_back(field);
596 test::CreateTestFormField(
597 "Address:", "address1", "21 Laussat St", "text", &field);
598 form.fields.push_back(field);
599 test::CreateTestFormField("City:", "city", "San Francisco", "text", &field);
600 form.fields.push_back(field);
601 test::CreateTestFormField("State:", "state", "California", "text", &field);
602 form.fields.push_back(field);
603 test::CreateTestFormField("Zip:", "zip", "94102", "text", &field);
604 form.fields.push_back(field);
605 FormStructure form_structure(form, std::string());
606 form_structure.DetermineHeuristicTypes(TestAutofillMetrics());
607 const CreditCard* imported_credit_card;
608 EXPECT_TRUE(personal_data_->ImportFormData(form_structure,
609 &imported_credit_card));
610 ASSERT_FALSE(imported_credit_card);
611
612 // Verify that the web database has been updated and the notification sent.
613 EXPECT_CALL(personal_data_observer_,
614 OnPersonalDataChanged()).WillOnce(QuitUIMessageLoop());
615 base::MessageLoop::current()->Run();
616
617 AutofillProfile expected(base::GenerateGUID(), "https://www.example.com");
618 test::SetProfileInfo(&expected, "George", NULL,
619 "Washington", "theprez@gmail.com", NULL, "21 Laussat St", NULL,
620 "San Francisco", "California", "94102", NULL, NULL);
621 const std::vector<AutofillProfile*>& results = personal_data_->GetProfiles();
622 ASSERT_EQ(1U, results.size());
623 EXPECT_EQ(0, expected.Compare(*results[0]));
624 }
625
626 TEST_F(PersonalDataManagerTest, ImportFormDataBadEmail) {
627 FormData form;
628 FormFieldData field;
629 test::CreateTestFormField(
630 "First name:", "first_name", "George", "text", &field);
631 form.fields.push_back(field);
632 test::CreateTestFormField(
633 "Last name:", "last_name", "Washington", "text", &field);
634 form.fields.push_back(field);
635 test::CreateTestFormField("Email:", "email", "bogus", "text", &field);
636 form.fields.push_back(field);
637 test::CreateTestFormField(
638 "Address:", "address1", "21 Laussat St", "text", &field);
639 form.fields.push_back(field);
640 test::CreateTestFormField("City:", "city", "San Francisco", "text", &field);
641 form.fields.push_back(field);
642 test::CreateTestFormField("State:", "state", "California", "text", &field);
643 form.fields.push_back(field);
644 test::CreateTestFormField("Zip:", "zip", "94102", "text", &field);
645 form.fields.push_back(field);
646 FormStructure form_structure(form, std::string());
647 form_structure.DetermineHeuristicTypes(TestAutofillMetrics());
648 const CreditCard* imported_credit_card;
649 EXPECT_FALSE(personal_data_->ImportFormData(form_structure,
650 &imported_credit_card));
651 ASSERT_EQ(static_cast<CreditCard*>(NULL), imported_credit_card);
652
653 const std::vector<AutofillProfile*>& results = personal_data_->GetProfiles();
654 ASSERT_EQ(0U, results.size());
655 }
656
657 // Tests that a 'confirm email' field does not block profile import.
658 TEST_F(PersonalDataManagerTest, ImportFormDataTwoEmails) {
659 FormData form;
660 FormFieldData field;
661 test::CreateTestFormField(
662 "Name:", "name", "George Washington", "text", &field);
663 form.fields.push_back(field);
664 test::CreateTestFormField(
665 "Address:", "address1", "21 Laussat St", "text", &field);
666 form.fields.push_back(field);
667 test::CreateTestFormField("City:", "city", "San Francisco", "text", &field);
668 form.fields.push_back(field);
669 test::CreateTestFormField("State:", "state", "California", "text", &field);
670 form.fields.push_back(field);
671 test::CreateTestFormField("Zip:", "zip", "94102", "text", &field);
672 form.fields.push_back(field);
673 test::CreateTestFormField(
674 "Email:", "email", "example@example.com", "text", &field);
675 form.fields.push_back(field);
676 test::CreateTestFormField(
677 "Confirm email:", "confirm_email", "example@example.com", "text", &field);
678 form.fields.push_back(field);
679 FormStructure form_structure(form, std::string());
680 form_structure.DetermineHeuristicTypes(TestAutofillMetrics());
681 const CreditCard* imported_credit_card;
682 EXPECT_TRUE(personal_data_->ImportFormData(form_structure,
683 &imported_credit_card));
684 const std::vector<AutofillProfile*>& results = personal_data_->GetProfiles();
685 ASSERT_EQ(1U, results.size());
686 }
687
688 // Tests two email fields containing different values blocks provile import.
689 TEST_F(PersonalDataManagerTest, ImportFormDataTwoDifferentEmails) {
690 FormData form;
691 FormFieldData field;
692 test::CreateTestFormField(
693 "Name:", "name", "George Washington", "text", &field);
694 form.fields.push_back(field);
695 test::CreateTestFormField(
696 "Address:", "address1", "21 Laussat St", "text", &field);
697 form.fields.push_back(field);
698 test::CreateTestFormField("City:", "city", "San Francisco", "text", &field);
699 form.fields.push_back(field);
700 test::CreateTestFormField("State:", "state", "California", "text", &field);
701 form.fields.push_back(field);
702 test::CreateTestFormField("Zip:", "zip", "94102", "text", &field);
703 form.fields.push_back(field);
704 test::CreateTestFormField(
705 "Email:", "email", "example@example.com", "text", &field);
706 form.fields.push_back(field);
707 test::CreateTestFormField(
708 "Email:", "email2", "example2@example.com", "text", &field);
709 form.fields.push_back(field);
710 FormStructure form_structure(form, std::string());
711 form_structure.DetermineHeuristicTypes(TestAutofillMetrics());
712 const CreditCard* imported_credit_card;
713 EXPECT_FALSE(personal_data_->ImportFormData(form_structure,
714 &imported_credit_card));
715 const std::vector<AutofillProfile*>& results = personal_data_->GetProfiles();
716 ASSERT_EQ(0U, results.size());
717 }
718
719 TEST_F(PersonalDataManagerTest, ImportFormDataNotEnoughFilledFields) {
720 FormData form;
721 FormFieldData field;
722 test::CreateTestFormField(
723 "First name:", "first_name", "George", "text", &field);
724 form.fields.push_back(field);
725 test::CreateTestFormField(
726 "Last name:", "last_name", "Washington", "text", &field);
727 form.fields.push_back(field);
728 test::CreateTestFormField(
729 "Card number:", "card_number", "4111 1111 1111 1111", "text", &field);
730 form.fields.push_back(field);
731 FormStructure form_structure(form, std::string());
732 form_structure.DetermineHeuristicTypes(TestAutofillMetrics());
733 const CreditCard* imported_credit_card;
734 EXPECT_FALSE(personal_data_->ImportFormData(form_structure,
735 &imported_credit_card));
736 ASSERT_FALSE(imported_credit_card);
737
738 const std::vector<AutofillProfile*>& profiles = personal_data_->GetProfiles();
739 ASSERT_EQ(0U, profiles.size());
740 const std::vector<CreditCard*>& cards = personal_data_->GetCreditCards();
741 ASSERT_EQ(0U, cards.size());
742 }
743
744 TEST_F(PersonalDataManagerTest, ImportFormMinimumAddressUSA) {
745 // United States addresses must specifiy one address line, a city, state and
746 // zip code.
747 FormData form;
748 FormFieldData field;
749 test::CreateTestFormField("Name:", "name", "Barack Obama", "text", &field);
750 form.fields.push_back(field);
751 test::CreateTestFormField(
752 "Address:", "address", "1600 Pennsylvania Avenue", "text", &field);
753 form.fields.push_back(field);
754 test::CreateTestFormField("City:", "city", "Washington", "text", &field);
755 form.fields.push_back(field);
756 test::CreateTestFormField("State:", "state", "DC", "text", &field);
757 form.fields.push_back(field);
758 test::CreateTestFormField("Zip:", "zip", "20500", "text", &field);
759 form.fields.push_back(field);
760 test::CreateTestFormField("Country:", "country", "USA", "text", &field);
761 form.fields.push_back(field);
762 FormStructure form_structure(form, std::string());
763 form_structure.DetermineHeuristicTypes(TestAutofillMetrics());
764 const CreditCard* imported_credit_card;
765 EXPECT_TRUE(personal_data_->ImportFormData(form_structure,
766 &imported_credit_card));
767 const std::vector<AutofillProfile*>& profiles = personal_data_->GetProfiles();
768 ASSERT_EQ(1U, profiles.size());
769 }
770
771 TEST_F(PersonalDataManagerTest, ImportFormMinimumAddressGB) {
772 // British addresses do not require a state/province as the county is usually
773 // not requested on forms.
774 FormData form;
775 FormFieldData field;
776 test::CreateTestFormField("Name:", "name", "David Cameron", "text", &field);
777 form.fields.push_back(field);
778 test::CreateTestFormField(
779 "Address:", "address", "10 Downing Street", "text", &field);
780 form.fields.push_back(field);
781 test::CreateTestFormField("City:", "city", "London", "text", &field);
782 form.fields.push_back(field);
783 test::CreateTestFormField(
784 "Postcode:", "postcode", "SW1A 2AA", "text", &field);
785 form.fields.push_back(field);
786 test::CreateTestFormField(
787 "Country:", "country", "United Kingdom", "text", &field);
788 form.fields.push_back(field);
789 FormStructure form_structure(form, std::string());
790 form_structure.DetermineHeuristicTypes(TestAutofillMetrics());
791 const CreditCard* imported_credit_card;
792 EXPECT_TRUE(personal_data_->ImportFormData(form_structure,
793 &imported_credit_card));
794 const std::vector<AutofillProfile*>& profiles = personal_data_->GetProfiles();
795 ASSERT_EQ(1U, profiles.size());
796 }
797
798 TEST_F(PersonalDataManagerTest, ImportFormMinimumAddressGI) {
799 // Gibraltar has the most minimal set of requirements for a valid address.
800 // There are no cities or provinces and no postal/zip code system.
801 FormData form;
802 FormFieldData field;
803 test::CreateTestFormField(
804 "Name:", "name", "Sir Adrian Johns", "text", &field);
805 form.fields.push_back(field);
806 test::CreateTestFormField(
807 "Address:", "address", "The Convent, Main Street", "text", &field);
808 form.fields.push_back(field);
809 test::CreateTestFormField("Country:", "country", "Gibraltar", "text", &field);
810 form.fields.push_back(field);
811 FormStructure form_structure(form, std::string());
812 form_structure.DetermineHeuristicTypes(TestAutofillMetrics());
813 const CreditCard* imported_credit_card;
814 EXPECT_TRUE(personal_data_->ImportFormData(form_structure,
815 &imported_credit_card));
816 const std::vector<AutofillProfile*>& profiles = personal_data_->GetProfiles();
817 ASSERT_EQ(1U, profiles.size());
818 }
819
820 TEST_F(PersonalDataManagerTest, ImportPhoneNumberSplitAcrossMultipleFields) {
821 FormData form;
822 FormFieldData field;
823 test::CreateTestFormField(
824 "First name:", "first_name", "George", "text", &field);
825 form.fields.push_back(field);
826 test::CreateTestFormField(
827 "Last name:", "last_name", "Washington", "text", &field);
828 form.fields.push_back(field);
829 test::CreateTestFormField(
830 "Phone #:", "home_phone_area_code", "650", "text", &field);
831 field.max_length = 3;
832 form.fields.push_back(field);
833 test::CreateTestFormField(
834 "Phone #:", "home_phone_prefix", "555", "text", &field);
835 field.max_length = 3;
836 form.fields.push_back(field);
837 test::CreateTestFormField(
838 "Phone #:", "home_phone_suffix", "0000", "text", &field);
839 field.max_length = 4;
840 form.fields.push_back(field);
841 test::CreateTestFormField(
842 "Address:", "address1", "21 Laussat St", "text", &field);
843 form.fields.push_back(field);
844 test::CreateTestFormField("City:", "city", "San Francisco", "text", &field);
845 form.fields.push_back(field);
846 test::CreateTestFormField("State:", "state", "California", "text", &field);
847 form.fields.push_back(field);
848 test::CreateTestFormField("Zip:", "zip", "94102", "text", &field);
849 form.fields.push_back(field);
850 FormStructure form_structure(form, std::string());
851 form_structure.DetermineHeuristicTypes(TestAutofillMetrics());
852 const CreditCard* imported_credit_card;
853 EXPECT_TRUE(personal_data_->ImportFormData(form_structure,
854 &imported_credit_card));
855 ASSERT_FALSE(imported_credit_card);
856
857 // Verify that the web database has been updated and the notification sent.
858 EXPECT_CALL(personal_data_observer_,
859 OnPersonalDataChanged()).WillOnce(QuitUIMessageLoop());
860 base::MessageLoop::current()->Run();
861
862 AutofillProfile expected(base::GenerateGUID(), "https://www.example.com");
863 test::SetProfileInfo(&expected, "George", NULL,
864 "Washington", NULL, NULL, "21 Laussat St", NULL,
865 "San Francisco", "California", "94102", NULL, "(650) 555-0000");
866 const std::vector<AutofillProfile*>& results = personal_data_->GetProfiles();
867 ASSERT_EQ(1U, results.size());
868 EXPECT_EQ(0, expected.Compare(*results[0]));
869 }
870
871 TEST_F(PersonalDataManagerTest, SetUniqueCreditCardLabels) {
872 CreditCard credit_card0(base::GenerateGUID(), "https://www.example.com");
873 credit_card0.SetRawInfo(CREDIT_CARD_NAME, ASCIIToUTF16("John"));
874 CreditCard credit_card1(base::GenerateGUID(), "https://www.example.com");
875 credit_card1.SetRawInfo(CREDIT_CARD_NAME, ASCIIToUTF16("Paul"));
876 CreditCard credit_card2(base::GenerateGUID(), "https://www.example.com");
877 credit_card2.SetRawInfo(CREDIT_CARD_NAME, ASCIIToUTF16("Ringo"));
878 CreditCard credit_card3(base::GenerateGUID(), "https://www.example.com");
879 credit_card3.SetRawInfo(CREDIT_CARD_NAME, ASCIIToUTF16("Other"));
880 CreditCard credit_card4(base::GenerateGUID(), "https://www.example.com");
881 credit_card4.SetRawInfo(CREDIT_CARD_NAME, ASCIIToUTF16("Ozzy"));
882 CreditCard credit_card5(base::GenerateGUID(), "https://www.example.com");
883 credit_card5.SetRawInfo(CREDIT_CARD_NAME, ASCIIToUTF16("Dio"));
884
885 // Add the test credit cards to the database.
886 personal_data_->AddCreditCard(credit_card0);
887 personal_data_->AddCreditCard(credit_card1);
888 personal_data_->AddCreditCard(credit_card2);
889 personal_data_->AddCreditCard(credit_card3);
890 personal_data_->AddCreditCard(credit_card4);
891 personal_data_->AddCreditCard(credit_card5);
892
893 // Reset the PersonalDataManager. This tests that the personal data was saved
894 // to the web database, and that we can load the credit cards from the web
895 // database.
896 ResetPersonalDataManager();
897
898 const std::vector<CreditCard*>& results = personal_data_->GetCreditCards();
899 ASSERT_EQ(6U, results.size());
900 EXPECT_EQ(credit_card0.guid(), results[0]->guid());
901 EXPECT_EQ(credit_card1.guid(), results[1]->guid());
902 EXPECT_EQ(credit_card2.guid(), results[2]->guid());
903 EXPECT_EQ(credit_card3.guid(), results[3]->guid());
904 EXPECT_EQ(credit_card4.guid(), results[4]->guid());
905 EXPECT_EQ(credit_card5.guid(), results[5]->guid());
906 }
907
908 TEST_F(PersonalDataManagerTest, AggregateTwoDifferentProfiles) {
909 FormData form1;
910 FormFieldData field;
911 test::CreateTestFormField(
912 "First name:", "first_name", "George", "text", &field);
913 form1.fields.push_back(field);
914 test::CreateTestFormField(
915 "Last name:", "last_name", "Washington", "text", &field);
916 form1.fields.push_back(field);
917 test::CreateTestFormField(
918 "Email:", "email", "theprez@gmail.com", "text", &field);
919 form1.fields.push_back(field);
920 test::CreateTestFormField(
921 "Address:", "address1", "21 Laussat St", "text", &field);
922 form1.fields.push_back(field);
923 test::CreateTestFormField("City:", "city", "San Francisco", "text", &field);
924 form1.fields.push_back(field);
925 test::CreateTestFormField("State:", "state", "California", "text", &field);
926 form1.fields.push_back(field);
927 test::CreateTestFormField("Zip:", "zip", "94102", "text", &field);
928 form1.fields.push_back(field);
929
930 FormStructure form_structure1(form1, std::string());
931 form_structure1.DetermineHeuristicTypes(TestAutofillMetrics());
932 const CreditCard* imported_credit_card;
933 EXPECT_TRUE(personal_data_->ImportFormData(form_structure1,
934 &imported_credit_card));
935 ASSERT_FALSE(imported_credit_card);
936
937 // Verify that the web database has been updated and the notification sent.
938 EXPECT_CALL(personal_data_observer_,
939 OnPersonalDataChanged()).WillOnce(QuitUIMessageLoop());
940 base::MessageLoop::current()->Run();
941
942 AutofillProfile expected(base::GenerateGUID(), "https://www.example.com");
943 test::SetProfileInfo(&expected, "George", NULL,
944 "Washington", "theprez@gmail.com", NULL, "21 Laussat St", NULL,
945 "San Francisco", "California", "94102", NULL, NULL);
946 const std::vector<AutofillProfile*>& results1 = personal_data_->GetProfiles();
947 ASSERT_EQ(1U, results1.size());
948 EXPECT_EQ(0, expected.Compare(*results1[0]));
949
950 // Now create a completely different profile.
951 FormData form2;
952 test::CreateTestFormField(
953 "First name:", "first_name", "John", "text", &field);
954 form2.fields.push_back(field);
955 test::CreateTestFormField(
956 "Last name:", "last_name", "Adams", "text", &field);
957 form2.fields.push_back(field);
958 test::CreateTestFormField(
959 "Email:", "email", "second@gmail.com", "text", &field);
960 form2.fields.push_back(field);
961 test::CreateTestFormField(
962 "Address:", "address1", "22 Laussat St", "text", &field);
963 form2.fields.push_back(field);
964 test::CreateTestFormField("City:", "city", "San Francisco", "text", &field);
965 form2.fields.push_back(field);
966 test::CreateTestFormField("State:", "state", "California", "text", &field);
967 form2.fields.push_back(field);
968 test::CreateTestFormField("Zip:", "zip", "94102", "text", &field);
969 form2.fields.push_back(field);
970
971 FormStructure form_structure2(form2, std::string());
972 form_structure2.DetermineHeuristicTypes(TestAutofillMetrics());
973 EXPECT_TRUE(personal_data_->ImportFormData(form_structure2,
974 &imported_credit_card));
975 ASSERT_FALSE(imported_credit_card);
976
977 // Verify that the web database has been updated and the notification sent.
978 EXPECT_CALL(personal_data_observer_,
979 OnPersonalDataChanged()).WillOnce(QuitUIMessageLoop());
980 base::MessageLoop::current()->Run();
981
982 const std::vector<AutofillProfile*>& results2 = personal_data_->GetProfiles();
983
984 AutofillProfile expected2(base::GenerateGUID(), "https://www.example.com");
985 test::SetProfileInfo(&expected2, "John", NULL,
986 "Adams", "second@gmail.com", NULL, "22 Laussat St", NULL,
987 "San Francisco", "California", "94102", NULL, NULL);
988 ASSERT_EQ(2U, results2.size());
989 EXPECT_EQ(0, expected.Compare(*results2[0]));
990 EXPECT_EQ(0, expected2.Compare(*results2[1]));
991 }
992
993 TEST_F(PersonalDataManagerTest, AggregateTwoProfilesWithMultiValue) {
994 FormData form1;
995 FormFieldData field;
996 test::CreateTestFormField(
997 "First name:", "first_name", "George", "text", &field);
998 form1.fields.push_back(field);
999 test::CreateTestFormField(
1000 "Last name:", "last_name", "Washington", "text", &field);
1001 form1.fields.push_back(field);
1002 test::CreateTestFormField(
1003 "Email:", "email", "theprez@gmail.com", "text", &field);
1004 form1.fields.push_back(field);
1005 test::CreateTestFormField(
1006 "Address:", "address1", "21 Laussat St", "text", &field);
1007 form1.fields.push_back(field);
1008 test::CreateTestFormField("City:", "city", "San Francisco", "text", &field);
1009 form1.fields.push_back(field);
1010 test::CreateTestFormField("State:", "state", "California", "text", &field);
1011 form1.fields.push_back(field);
1012 test::CreateTestFormField("Zip:", "zip", "94102", "text", &field);
1013 form1.fields.push_back(field);
1014
1015 FormStructure form_structure1(form1, std::string());
1016 form_structure1.DetermineHeuristicTypes(TestAutofillMetrics());
1017 const CreditCard* imported_credit_card;
1018 EXPECT_TRUE(personal_data_->ImportFormData(form_structure1,
1019 &imported_credit_card));
1020 ASSERT_FALSE(imported_credit_card);
1021
1022 // Verify that the web database has been updated and the notification sent.
1023 EXPECT_CALL(personal_data_observer_,
1024 OnPersonalDataChanged()).WillOnce(QuitUIMessageLoop());
1025 base::MessageLoop::current()->Run();
1026
1027 AutofillProfile expected(base::GenerateGUID(), "https://www.example.com");
1028 test::SetProfileInfo(&expected, "George", NULL,
1029 "Washington", "theprez@gmail.com", NULL, "21 Laussat St", NULL,
1030 "San Francisco", "California", "94102", NULL, NULL);
1031 const std::vector<AutofillProfile*>& results1 = personal_data_->GetProfiles();
1032 ASSERT_EQ(1U, results1.size());
1033 EXPECT_EQ(0, expected.Compare(*results1[0]));
1034
1035 // Now create a completely different profile.
1036 FormData form2;
1037 test::CreateTestFormField(
1038 "First name:", "first_name", "John", "text", &field);
1039 form2.fields.push_back(field);
1040 test::CreateTestFormField("Last name:", "last_name", "Adams", "text", &field);
1041 form2.fields.push_back(field);
1042 test::CreateTestFormField(
1043 "Email:", "email", "second@gmail.com", "text", &field);
1044 form2.fields.push_back(field);
1045 test::CreateTestFormField(
1046 "Address:", "address1", "21 Laussat St", "text", &field);
1047 form2.fields.push_back(field);
1048 test::CreateTestFormField("City:", "city", "San Francisco", "text", &field);
1049 form2.fields.push_back(field);
1050 test::CreateTestFormField("State:", "state", "California", "text", &field);
1051 form2.fields.push_back(field);
1052 test::CreateTestFormField("Zip:", "zip", "94102", "text", &field);
1053 form2.fields.push_back(field);
1054
1055 FormStructure form_structure2(form2, std::string());
1056 form_structure2.DetermineHeuristicTypes(TestAutofillMetrics());
1057 EXPECT_TRUE(personal_data_->ImportFormData(form_structure2,
1058 &imported_credit_card));
1059 ASSERT_FALSE(imported_credit_card);
1060
1061 // Verify that the web database has been updated and the notification sent.
1062 EXPECT_CALL(personal_data_observer_,
1063 OnPersonalDataChanged()).WillOnce(QuitUIMessageLoop());
1064 base::MessageLoop::current()->Run();
1065
1066 const std::vector<AutofillProfile*>& results2 = personal_data_->GetProfiles();
1067
1068 // Modify expected to include multi-valued fields.
1069 std::vector<base::string16> values;
1070 expected.GetRawMultiInfo(NAME_FULL, &values);
1071 values.push_back(ASCIIToUTF16("John Adams"));
1072 expected.SetRawMultiInfo(NAME_FULL, values);
1073 expected.GetRawMultiInfo(EMAIL_ADDRESS, &values);
1074 values.push_back(ASCIIToUTF16("second@gmail.com"));
1075 expected.SetRawMultiInfo(EMAIL_ADDRESS, values);
1076
1077 ASSERT_EQ(1U, results2.size());
1078 EXPECT_EQ(0, expected.Compare(*results2[0]));
1079 }
1080
1081 TEST_F(PersonalDataManagerTest, AggregateSameProfileWithConflict) {
1082 FormData form1;
1083 FormFieldData field;
1084 test::CreateTestFormField(
1085 "First name:", "first_name", "George", "text", &field);
1086 form1.fields.push_back(field);
1087 test::CreateTestFormField(
1088 "Last name:", "last_name", "Washington", "text", &field);
1089 form1.fields.push_back(field);
1090 test::CreateTestFormField(
1091 "Address:", "address", "1600 Pennsylvania Avenue", "text", &field);
1092 form1.fields.push_back(field);
1093 test::CreateTestFormField(
1094 "Address Line 2:", "address2", "Suite A", "text", &field);
1095 form1.fields.push_back(field);
1096 test::CreateTestFormField("City:", "city", "San Francisco", "text", &field);
1097 form1.fields.push_back(field);
1098 test::CreateTestFormField("State:", "state", "California", "text", &field);
1099 form1.fields.push_back(field);
1100 test::CreateTestFormField("Zip:", "zip", "94102", "text", &field);
1101 form1.fields.push_back(field);
1102 test::CreateTestFormField(
1103 "Email:", "email", "theprez@gmail.com", "text", &field);
1104 form1.fields.push_back(field);
1105 test::CreateTestFormField("Phone:", "phone", "6505556666", "text", &field);
1106 form1.fields.push_back(field);
1107
1108 FormStructure form_structure1(form1, std::string());
1109 form_structure1.DetermineHeuristicTypes(TestAutofillMetrics());
1110 const CreditCard* imported_credit_card;
1111 EXPECT_TRUE(personal_data_->ImportFormData(form_structure1,
1112 &imported_credit_card));
1113 ASSERT_FALSE(imported_credit_card);
1114
1115 // Verify that the web database has been updated and the notification sent.
1116 EXPECT_CALL(personal_data_observer_,
1117 OnPersonalDataChanged()).WillOnce(QuitUIMessageLoop());
1118 base::MessageLoop::current()->Run();
1119
1120 AutofillProfile expected(base::GenerateGUID(), "https://www.example.com");
1121 test::SetProfileInfo(
1122 &expected, "George", NULL, "Washington", "theprez@gmail.com", NULL,
1123 "1600 Pennsylvania Avenue", "Suite A", "San Francisco", "California",
1124 "94102", NULL, "(650) 555-6666");
1125 const std::vector<AutofillProfile*>& results1 = personal_data_->GetProfiles();
1126 ASSERT_EQ(1U, results1.size());
1127 EXPECT_EQ(0, expected.Compare(*results1[0]));
1128
1129 // Now create an updated profile.
1130 FormData form2;
1131 test::CreateTestFormField(
1132 "First name:", "first_name", "George", "text", &field);
1133 form2.fields.push_back(field);
1134 test::CreateTestFormField(
1135 "Last name:", "last_name", "Washington", "text", &field);
1136 form2.fields.push_back(field);
1137 test::CreateTestFormField(
1138 "Address:", "address", "1600 Pennsylvania Avenue", "text", &field);
1139 form2.fields.push_back(field);
1140 test::CreateTestFormField(
1141 "Address Line 2:", "address2", "Suite A", "text", &field);
1142 form2.fields.push_back(field);
1143 test::CreateTestFormField("City:", "city", "San Francisco", "text", &field);
1144 form2.fields.push_back(field);
1145 test::CreateTestFormField("State:", "state", "California", "text", &field);
1146 form2.fields.push_back(field);
1147 test::CreateTestFormField("Zip:", "zip", "94102", "text", &field);
1148 form2.fields.push_back(field);
1149 test::CreateTestFormField(
1150 "Email:", "email", "theprez@gmail.com", "text", &field);
1151 form2.fields.push_back(field);
1152 // Country gets added.
1153 test::CreateTestFormField("Country:", "country", "USA", "text", &field);
1154 form2.fields.push_back(field);
1155 // Phone gets updated.
1156 test::CreateTestFormField("Phone:", "phone", "6502231234", "text", &field);
1157 form2.fields.push_back(field);
1158
1159 FormStructure form_structure2(form2, std::string());
1160 form_structure2.DetermineHeuristicTypes(TestAutofillMetrics());
1161 EXPECT_TRUE(personal_data_->ImportFormData(form_structure2,
1162 &imported_credit_card));
1163 ASSERT_FALSE(imported_credit_card);
1164
1165 // Verify that the web database has been updated and the notification sent.
1166 EXPECT_CALL(personal_data_observer_,
1167 OnPersonalDataChanged()).WillOnce(QuitUIMessageLoop());
1168 base::MessageLoop::current()->Run();
1169
1170 const std::vector<AutofillProfile*>& results2 = personal_data_->GetProfiles();
1171
1172 // Add multi-valued phone number to expectation. Also, country gets added.
1173 std::vector<base::string16> values;
1174 expected.GetRawMultiInfo(PHONE_HOME_WHOLE_NUMBER, &values);
1175 values.push_back(ASCIIToUTF16("(650) 223-1234"));
1176 expected.SetRawMultiInfo(PHONE_HOME_WHOLE_NUMBER, values);
1177 expected.SetRawInfo(ADDRESS_HOME_COUNTRY, ASCIIToUTF16("US"));
1178 ASSERT_EQ(1U, results2.size());
1179 EXPECT_EQ(0, expected.Compare(*results2[0]));
1180 }
1181
1182 TEST_F(PersonalDataManagerTest, AggregateProfileWithMissingInfoInOld) {
1183 FormData form1;
1184 FormFieldData field;
1185 test::CreateTestFormField(
1186 "First name:", "first_name", "George", "text", &field);
1187 form1.fields.push_back(field);
1188 test::CreateTestFormField(
1189 "Last name:", "last_name", "Washington", "text", &field);
1190 form1.fields.push_back(field);
1191 test::CreateTestFormField(
1192 "Address Line 1:", "address", "190 High Street", "text", &field);
1193 form1.fields.push_back(field);
1194 test::CreateTestFormField("City:", "city", "Philadelphia", "text", &field);
1195 form1.fields.push_back(field);
1196 test::CreateTestFormField("State:", "state", "Pennsylvania", "text", &field);
1197 form1.fields.push_back(field);
1198 test::CreateTestFormField("Zip:", "zipcode", "19106", "text", &field);
1199 form1.fields.push_back(field);
1200
1201 FormStructure form_structure1(form1, std::string());
1202 form_structure1.DetermineHeuristicTypes(TestAutofillMetrics());
1203 const CreditCard* imported_credit_card;
1204 EXPECT_TRUE(personal_data_->ImportFormData(form_structure1,
1205 &imported_credit_card));
1206 EXPECT_FALSE(imported_credit_card);
1207
1208 // Verify that the web database has been updated and the notification sent.
1209 EXPECT_CALL(personal_data_observer_,
1210 OnPersonalDataChanged()).WillOnce(QuitUIMessageLoop());
1211 base::MessageLoop::current()->Run();
1212
1213 AutofillProfile expected(base::GenerateGUID(), "https://www.example.com");
1214 test::SetProfileInfo(&expected, "George", NULL,
1215 "Washington", NULL, NULL, "190 High Street", NULL,
1216 "Philadelphia", "Pennsylvania", "19106", NULL, NULL);
1217 const std::vector<AutofillProfile*>& results1 = personal_data_->GetProfiles();
1218 ASSERT_EQ(1U, results1.size());
1219 EXPECT_EQ(0, expected.Compare(*results1[0]));
1220
1221 // Submit a form with new data for the first profile.
1222 FormData form2;
1223 test::CreateTestFormField(
1224 "First name:", "first_name", "George", "text", &field);
1225 form2.fields.push_back(field);
1226 test::CreateTestFormField(
1227 "Last name:", "last_name", "Washington", "text", &field);
1228 form2.fields.push_back(field);
1229 test::CreateTestFormField(
1230 "Email:", "email", "theprez@gmail.com", "text", &field);
1231 form2.fields.push_back(field);
1232 test::CreateTestFormField(
1233 "Address Line 1:", "address", "190 High Street", "text", &field);
1234 form2.fields.push_back(field);
1235 test::CreateTestFormField("City:", "city", "Philadelphia", "text", &field);
1236 form2.fields.push_back(field);
1237 test::CreateTestFormField("State:", "state", "Pennsylvania", "text", &field);
1238 form2.fields.push_back(field);
1239 test::CreateTestFormField("Zip:", "zipcode", "19106", "text", &field);
1240 form2.fields.push_back(field);
1241
1242 FormStructure form_structure2(form2, std::string());
1243 form_structure2.DetermineHeuristicTypes(TestAutofillMetrics());
1244 EXPECT_TRUE(personal_data_->ImportFormData(form_structure2,
1245 &imported_credit_card));
1246 ASSERT_FALSE(imported_credit_card);
1247
1248 // Verify that the web database has been updated and the notification sent.
1249 EXPECT_CALL(personal_data_observer_,
1250 OnPersonalDataChanged()).WillOnce(QuitUIMessageLoop());
1251 base::MessageLoop::current()->Run();
1252
1253 const std::vector<AutofillProfile*>& results2 = personal_data_->GetProfiles();
1254
1255 AutofillProfile expected2(base::GenerateGUID(), "https://www.example.com");
1256 test::SetProfileInfo(&expected2, "George", NULL,
1257 "Washington", "theprez@gmail.com", NULL, "190 High Street", NULL,
1258 "Philadelphia", "Pennsylvania", "19106", NULL, NULL);
1259 ASSERT_EQ(1U, results2.size());
1260 EXPECT_EQ(0, expected2.Compare(*results2[0]));
1261 }
1262
1263 TEST_F(PersonalDataManagerTest, AggregateProfileWithMissingInfoInNew) {
1264 FormData form1;
1265 FormFieldData field;
1266 test::CreateTestFormField(
1267 "First name:", "first_name", "George", "text", &field);
1268 form1.fields.push_back(field);
1269 test::CreateTestFormField(
1270 "Last name:", "last_name", "Washington", "text", &field);
1271 form1.fields.push_back(field);
1272 test::CreateTestFormField(
1273 "Company:", "company", "Government", "text", &field);
1274 form1.fields.push_back(field);
1275 test::CreateTestFormField(
1276 "Email:", "email", "theprez@gmail.com", "text", &field);
1277 form1.fields.push_back(field);
1278 test::CreateTestFormField(
1279 "Address Line 1:", "address", "190 High Street", "text", &field);
1280 form1.fields.push_back(field);
1281 test::CreateTestFormField("City:", "city", "Philadelphia", "text", &field);
1282 form1.fields.push_back(field);
1283 test::CreateTestFormField("State:", "state", "Pennsylvania", "text", &field);
1284 form1.fields.push_back(field);
1285 test::CreateTestFormField("Zip:", "zipcode", "19106", "text", &field);
1286 form1.fields.push_back(field);
1287
1288 FormStructure form_structure1(form1, std::string());
1289 form_structure1.DetermineHeuristicTypes(TestAutofillMetrics());
1290 const CreditCard* imported_credit_card;
1291 EXPECT_TRUE(personal_data_->ImportFormData(form_structure1,
1292 &imported_credit_card));
1293 ASSERT_FALSE(imported_credit_card);
1294
1295 // Verify that the web database has been updated and the notification sent.
1296 EXPECT_CALL(personal_data_observer_,
1297 OnPersonalDataChanged()).WillOnce(QuitUIMessageLoop());
1298 base::MessageLoop::current()->Run();
1299
1300 AutofillProfile expected(base::GenerateGUID(), "https://www.example.com");
1301 test::SetProfileInfo(&expected, "George", NULL,
1302 "Washington", "theprez@gmail.com", "Government", "190 High Street", NULL,
1303 "Philadelphia", "Pennsylvania", "19106", NULL, NULL);
1304 const std::vector<AutofillProfile*>& results1 = personal_data_->GetProfiles();
1305 ASSERT_EQ(1U, results1.size());
1306 EXPECT_EQ(0, expected.Compare(*results1[0]));
1307
1308 // Submit a form with new data for the first profile.
1309 FormData form2;
1310 test::CreateTestFormField(
1311 "First name:", "first_name", "George", "text", &field);
1312 form2.fields.push_back(field);
1313 test::CreateTestFormField(
1314 "Last name:", "last_name", "Washington", "text", &field);
1315 form2.fields.push_back(field);
1316 // Note missing Company field.
1317 test::CreateTestFormField(
1318 "Email:", "email", "theprez@gmail.com", "text", &field);
1319 form2.fields.push_back(field);
1320 test::CreateTestFormField(
1321 "Address Line 1:", "address", "190 High Street", "text", &field);
1322 form2.fields.push_back(field);
1323 test::CreateTestFormField("City:", "city", "Philadelphia", "text", &field);
1324 form2.fields.push_back(field);
1325 test::CreateTestFormField("State:", "state", "Pennsylvania", "text", &field);
1326 form2.fields.push_back(field);
1327 test::CreateTestFormField("Zip:", "zipcode", "19106", "text", &field);
1328 form2.fields.push_back(field);
1329
1330 FormStructure form_structure2(form2, std::string());
1331 form_structure2.DetermineHeuristicTypes(TestAutofillMetrics());
1332 EXPECT_TRUE(personal_data_->ImportFormData(form_structure2,
1333 &imported_credit_card));
1334 ASSERT_FALSE(imported_credit_card);
1335
1336 // Verify that the web database has been updated and the notification sent.
1337 EXPECT_CALL(personal_data_observer_,
1338 OnPersonalDataChanged()).WillOnce(QuitUIMessageLoop());
1339 base::MessageLoop::current()->Run();
1340
1341 const std::vector<AutofillProfile*>& results2 = personal_data_->GetProfiles();
1342
1343 // Expect no change.
1344 ASSERT_EQ(1U, results2.size());
1345 EXPECT_EQ(0, expected.Compare(*results2[0]));
1346 }
1347
1348 TEST_F(PersonalDataManagerTest, AggregateProfileWithInsufficientAddress) {
1349 FormData form1;
1350 FormFieldData field;
1351 test::CreateTestFormField(
1352 "First name:", "first_name", "George", "text", &field);
1353 form1.fields.push_back(field);
1354 test::CreateTestFormField(
1355 "Last name:", "last_name", "Washington", "text", &field);
1356 form1.fields.push_back(field);
1357 test::CreateTestFormField(
1358 "Company:", "company", "Government", "text", &field);
1359 form1.fields.push_back(field);
1360 test::CreateTestFormField(
1361 "Email:", "email", "theprez@gmail.com", "text", &field);
1362 form1.fields.push_back(field);
1363 test::CreateTestFormField(
1364 "Address Line 1:", "address", "190 High Street", "text", &field);
1365 form1.fields.push_back(field);
1366 test::CreateTestFormField("City:", "city", "Philadelphia", "text", &field);
1367 form1.fields.push_back(field);
1368
1369 FormStructure form_structure1(form1, std::string());
1370 form_structure1.DetermineHeuristicTypes(TestAutofillMetrics());
1371 const CreditCard* imported_credit_card;
1372 EXPECT_FALSE(personal_data_->ImportFormData(form_structure1,
1373 &imported_credit_card));
1374 ASSERT_FALSE(imported_credit_card);
1375
1376 // Since no refresh is expected, reload the data from the database to make
1377 // sure no changes were written out.
1378 ResetPersonalDataManager();
1379
1380 const std::vector<AutofillProfile*>& profiles = personal_data_->GetProfiles();
1381 ASSERT_EQ(0U, profiles.size());
1382 const std::vector<CreditCard*>& cards = personal_data_->GetCreditCards();
1383 ASSERT_EQ(0U, cards.size());
1384 }
1385
1386 TEST_F(PersonalDataManagerTest, AggregateExistingAuxiliaryProfile) {
1387 // Simulate having access to an auxiliary profile.
1388 // |auxiliary_profile| will be owned by |personal_data_|.
1389 AutofillProfile* auxiliary_profile =
1390 new AutofillProfile(base::GenerateGUID(), "https://www.example.com");
1391 test::SetProfileInfo(auxiliary_profile,
1392 "Tester", "Frederick", "McAddressBookTesterson",
1393 "tester@example.com", "Acme Inc.", "1 Main", "Apt A", "San Francisco",
1394 "CA", "94102", "US", "1.415.888.9999");
1395 ScopedVector<AutofillProfile>& auxiliary_profiles =
1396 personal_data_->auxiliary_profiles_;
1397 auxiliary_profiles.push_back(auxiliary_profile);
1398
1399 // Simulate a form submission with a subset of the info.
1400 // Note that the phone number format is different from the saved format.
1401 FormData form;
1402 FormFieldData field;
1403 test::CreateTestFormField(
1404 "First name:", "first_name", "Tester", "text", &field);
1405 form.fields.push_back(field);
1406 test::CreateTestFormField(
1407 "Last name:", "last_name", "McAddressBookTesterson", "text", &field);
1408 form.fields.push_back(field);
1409 test::CreateTestFormField(
1410 "Email:", "email", "tester@example.com", "text", &field);
1411 form.fields.push_back(field);
1412 test::CreateTestFormField("Address:", "address1", "1 Main", "text", &field);
1413 form.fields.push_back(field);
1414 test::CreateTestFormField("City:", "city", "San Francisco", "text", &field);
1415 form.fields.push_back(field);
1416 test::CreateTestFormField("State:", "state", "CA", "text", &field);
1417 form.fields.push_back(field);
1418 test::CreateTestFormField("Zip:", "zip", "94102", "text", &field);
1419 form.fields.push_back(field);
1420 test::CreateTestFormField("Phone:", "phone", "4158889999", "text", &field);
1421 form.fields.push_back(field);
1422
1423 FormStructure form_structure(form, std::string());
1424 form_structure.DetermineHeuristicTypes(TestAutofillMetrics());
1425 const CreditCard* imported_credit_card;
1426 EXPECT_TRUE(personal_data_->ImportFormData(form_structure,
1427 &imported_credit_card));
1428 EXPECT_FALSE(imported_credit_card);
1429
1430 // Note: No refresh.
1431
1432 // Expect no change.
1433 const std::vector<AutofillProfile*>& web_profiles =
1434 personal_data_->web_profiles();
1435 EXPECT_EQ(0U, web_profiles.size());
1436 ASSERT_EQ(1U, auxiliary_profiles.size());
1437 EXPECT_EQ(0, auxiliary_profile->Compare(*auxiliary_profiles[0]));
1438 }
1439
1440 TEST_F(PersonalDataManagerTest, AggregateTwoDifferentCreditCards) {
1441 FormData form1;
1442
1443 // Start with a single valid credit card form.
1444 FormFieldData field;
1445 test::CreateTestFormField(
1446 "Name on card:", "name_on_card", "Biggie Smalls", "text", &field);
1447 form1.fields.push_back(field);
1448 test::CreateTestFormField(
1449 "Card Number:", "card_number", "4111-1111-1111-1111", "text", &field);
1450 form1.fields.push_back(field);
1451 test::CreateTestFormField("Exp Month:", "exp_month", "01", "text", &field);
1452 form1.fields.push_back(field);
1453 test::CreateTestFormField("Exp Year:", "exp_year", "2011", "text", &field);
1454 form1.fields.push_back(field);
1455
1456 FormStructure form_structure1(form1, std::string());
1457 form_structure1.DetermineHeuristicTypes(TestAutofillMetrics());
1458 const CreditCard* imported_credit_card;
1459 EXPECT_TRUE(personal_data_->ImportFormData(form_structure1,
1460 &imported_credit_card));
1461 ASSERT_TRUE(imported_credit_card);
1462 personal_data_->SaveImportedCreditCard(*imported_credit_card);
1463 delete imported_credit_card;
1464
1465 // Verify that the web database has been updated and the notification sent.
1466 EXPECT_CALL(personal_data_observer_,
1467 OnPersonalDataChanged()).WillOnce(QuitUIMessageLoop());
1468 base::MessageLoop::current()->Run();
1469
1470 CreditCard expected(base::GenerateGUID(), "https://www.example.com");
1471 test::SetCreditCardInfo(&expected,
1472 "Biggie Smalls", "4111111111111111", "01", "2011");
1473 const std::vector<CreditCard*>& results = personal_data_->GetCreditCards();
1474 ASSERT_EQ(1U, results.size());
1475 EXPECT_EQ(0, expected.Compare(*results[0]));
1476
1477 // Add a second different valid credit card.
1478 FormData form2;
1479 test::CreateTestFormField(
1480 "Name on card:", "name_on_card", "", "text", &field);
1481 form2.fields.push_back(field);
1482 test::CreateTestFormField(
1483 "Card Number:", "card_number", "5500 0000 0000 0004", "text", &field);
1484 form2.fields.push_back(field);
1485 test::CreateTestFormField("Exp Month:", "exp_month", "02", "text", &field);
1486 form2.fields.push_back(field);
1487 test::CreateTestFormField("Exp Year:", "exp_year", "2012", "text", &field);
1488 form2.fields.push_back(field);
1489
1490 FormStructure form_structure2(form2, std::string());
1491 form_structure2.DetermineHeuristicTypes(TestAutofillMetrics());
1492 EXPECT_TRUE(personal_data_->ImportFormData(form_structure2,
1493 &imported_credit_card));
1494 ASSERT_TRUE(imported_credit_card);
1495 personal_data_->SaveImportedCreditCard(*imported_credit_card);
1496 delete imported_credit_card;
1497
1498 // Verify that the web database has been updated and the notification sent.
1499 EXPECT_CALL(personal_data_observer_,
1500 OnPersonalDataChanged()).WillOnce(QuitUIMessageLoop());
1501 base::MessageLoop::current()->Run();
1502
1503 CreditCard expected2(base::GenerateGUID(), "https://www.example.com");
1504 test::SetCreditCardInfo(&expected2,"", "5500000000000004", "02", "2012");
1505 const std::vector<CreditCard*>& results2 = personal_data_->GetCreditCards();
1506 ASSERT_EQ(2U, results2.size());
1507 EXPECT_EQ(0, expected.Compare(*results2[0]));
1508 EXPECT_EQ(0, expected2.Compare(*results2[1]));
1509 }
1510
1511 TEST_F(PersonalDataManagerTest, AggregateInvalidCreditCard) {
1512 FormData form1;
1513
1514 // Start with a single valid credit card form.
1515 FormFieldData field;
1516 test::CreateTestFormField(
1517 "Name on card:", "name_on_card", "Biggie Smalls", "text", &field);
1518 form1.fields.push_back(field);
1519 test::CreateTestFormField(
1520 "Card Number:", "card_number", "4111-1111-1111-1111", "text", &field);
1521 form1.fields.push_back(field);
1522 test::CreateTestFormField("Exp Month:", "exp_month", "01", "text", &field);
1523 form1.fields.push_back(field);
1524 test::CreateTestFormField("Exp Year:", "exp_year", "2011", "text", &field);
1525 form1.fields.push_back(field);
1526
1527 FormStructure form_structure1(form1, std::string());
1528 form_structure1.DetermineHeuristicTypes(TestAutofillMetrics());
1529 const CreditCard* imported_credit_card;
1530 EXPECT_TRUE(personal_data_->ImportFormData(form_structure1,
1531 &imported_credit_card));
1532 ASSERT_TRUE(imported_credit_card);
1533 personal_data_->SaveImportedCreditCard(*imported_credit_card);
1534 delete imported_credit_card;
1535
1536 // Verify that the web database has been updated and the notification sent.
1537 EXPECT_CALL(personal_data_observer_,
1538 OnPersonalDataChanged()).WillOnce(QuitUIMessageLoop());
1539 base::MessageLoop::current()->Run();
1540
1541 CreditCard expected(base::GenerateGUID(), "https://www.example.com");
1542 test::SetCreditCardInfo(&expected,
1543 "Biggie Smalls", "4111111111111111", "01", "2011");
1544 const std::vector<CreditCard*>& results = personal_data_->GetCreditCards();
1545 ASSERT_EQ(1U, results.size());
1546 EXPECT_EQ(0, expected.Compare(*results[0]));
1547
1548 // Add a second different invalid credit card.
1549 FormData form2;
1550 test::CreateTestFormField(
1551 "Name on card:", "name_on_card", "Jim Johansen", "text", &field);
1552 form2.fields.push_back(field);
1553 test::CreateTestFormField(
1554 "Card Number:", "card_number", "1000000000000000", "text", &field);
1555 form2.fields.push_back(field);
1556 test::CreateTestFormField("Exp Month:", "exp_month", "02", "text", &field);
1557 form2.fields.push_back(field);
1558 test::CreateTestFormField("Exp Year:", "exp_year", "2012", "text", &field);
1559 form2.fields.push_back(field);
1560
1561 FormStructure form_structure2(form2, std::string());
1562 form_structure2.DetermineHeuristicTypes(TestAutofillMetrics());
1563 EXPECT_FALSE(personal_data_->ImportFormData(form_structure2,
1564 &imported_credit_card));
1565 ASSERT_FALSE(imported_credit_card);
1566
1567 // Since no refresh is expected, reload the data from the database to make
1568 // sure no changes were written out.
1569 ResetPersonalDataManager();
1570
1571 const std::vector<CreditCard*>& results2 = personal_data_->GetCreditCards();
1572 ASSERT_EQ(1U, results2.size());
1573 EXPECT_EQ(0, expected.Compare(*results2[0]));
1574 }
1575
1576 TEST_F(PersonalDataManagerTest, AggregateSameCreditCardWithConflict) {
1577 FormData form1;
1578
1579 // Start with a single valid credit card form.
1580 FormFieldData field;
1581 test::CreateTestFormField(
1582 "Name on card:", "name_on_card", "Biggie Smalls", "text", &field);
1583 form1.fields.push_back(field);
1584 test::CreateTestFormField(
1585 "Card Number:", "card_number", "4111-1111-1111-1111", "text", &field);
1586 form1.fields.push_back(field);
1587 test::CreateTestFormField("Exp Month:", "exp_month", "01", "text", &field);
1588 form1.fields.push_back(field);
1589 test::CreateTestFormField("Exp Year:", "exp_year", "2011", "text", &field);
1590 form1.fields.push_back(field);
1591
1592 FormStructure form_structure1(form1, std::string());
1593 form_structure1.DetermineHeuristicTypes(TestAutofillMetrics());
1594 const CreditCard* imported_credit_card;
1595 EXPECT_TRUE(personal_data_->ImportFormData(form_structure1,
1596 &imported_credit_card));
1597 ASSERT_TRUE(imported_credit_card);
1598 personal_data_->SaveImportedCreditCard(*imported_credit_card);
1599 delete imported_credit_card;
1600
1601 // Verify that the web database has been updated and the notification sent.
1602 EXPECT_CALL(personal_data_observer_,
1603 OnPersonalDataChanged()).WillOnce(QuitUIMessageLoop());
1604 base::MessageLoop::current()->Run();
1605
1606 CreditCard expected(base::GenerateGUID(), "https://www.example.com");
1607 test::SetCreditCardInfo(&expected,
1608 "Biggie Smalls", "4111111111111111", "01", "2011");
1609 const std::vector<CreditCard*>& results = personal_data_->GetCreditCards();
1610 ASSERT_EQ(1U, results.size());
1611 EXPECT_EQ(0, expected.Compare(*results[0]));
1612
1613 // Add a second different valid credit card where the year is different but
1614 // the credit card number matches.
1615 FormData form2;
1616 test::CreateTestFormField(
1617 "Name on card:", "name_on_card", "Biggie Smalls", "text", &field);
1618 form2.fields.push_back(field);
1619 test::CreateTestFormField(
1620 "Card Number:", "card_number", "4111 1111 1111 1111", "text", &field);
1621 form2.fields.push_back(field);
1622 test::CreateTestFormField("Exp Month:", "exp_month", "01", "text", &field);
1623 form2.fields.push_back(field);
1624 test::CreateTestFormField("Exp Year:", "exp_year", "2012", "text", &field);
1625 form2.fields.push_back(field);
1626
1627 FormStructure form_structure2(form2, std::string());
1628 form_structure2.DetermineHeuristicTypes(TestAutofillMetrics());
1629 EXPECT_TRUE(personal_data_->ImportFormData(form_structure2,
1630 &imported_credit_card));
1631 EXPECT_FALSE(imported_credit_card);
1632
1633 // Verify that the web database has been updated and the notification sent.
1634 EXPECT_CALL(personal_data_observer_,
1635 OnPersonalDataChanged()).WillOnce(QuitUIMessageLoop());
1636 base::MessageLoop::current()->Run();
1637
1638 // Expect that the newer information is saved. In this case the year is
1639 // updated to "2012".
1640 CreditCard expected2(base::GenerateGUID(), "https://www.example.com");
1641 test::SetCreditCardInfo(&expected2,
1642 "Biggie Smalls", "4111111111111111", "01", "2012");
1643 const std::vector<CreditCard*>& results2 = personal_data_->GetCreditCards();
1644 ASSERT_EQ(1U, results2.size());
1645 EXPECT_EQ(0, expected2.Compare(*results2[0]));
1646 }
1647
1648 TEST_F(PersonalDataManagerTest, AggregateEmptyCreditCardWithConflict) {
1649 FormData form1;
1650
1651 // Start with a single valid credit card form.
1652 FormFieldData field;
1653 test::CreateTestFormField(
1654 "Name on card:", "name_on_card", "Biggie Smalls", "text", &field);
1655 form1.fields.push_back(field);
1656 test::CreateTestFormField(
1657 "Card Number:", "card_number", "4111-1111-1111-1111", "text", &field);
1658 form1.fields.push_back(field);
1659 test::CreateTestFormField("Exp Month:", "exp_month", "01", "text", &field);
1660 form1.fields.push_back(field);
1661 test::CreateTestFormField("Exp Year:", "exp_year", "2011", "text", &field);
1662 form1.fields.push_back(field);
1663
1664 FormStructure form_structure1(form1, std::string());
1665 form_structure1.DetermineHeuristicTypes(TestAutofillMetrics());
1666 const CreditCard* imported_credit_card;
1667 EXPECT_TRUE(personal_data_->ImportFormData(form_structure1,
1668 &imported_credit_card));
1669 ASSERT_TRUE(imported_credit_card);
1670 personal_data_->SaveImportedCreditCard(*imported_credit_card);
1671 delete imported_credit_card;
1672
1673 // Verify that the web database has been updated and the notification sent.
1674 EXPECT_CALL(personal_data_observer_,
1675 OnPersonalDataChanged()).WillOnce(QuitUIMessageLoop());
1676 base::MessageLoop::current()->Run();
1677
1678 CreditCard expected(base::GenerateGUID(), "https://www.example.com");
1679 test::SetCreditCardInfo(&expected,
1680 "Biggie Smalls", "4111111111111111", "01", "2011");
1681 const std::vector<CreditCard*>& results = personal_data_->GetCreditCards();
1682 ASSERT_EQ(1U, results.size());
1683 EXPECT_EQ(0, expected.Compare(*results[0]));
1684
1685 // Add a second credit card with no number.
1686 FormData form2;
1687 test::CreateTestFormField(
1688 "Name on card:", "name_on_card", "Biggie Smalls", "text", &field);
1689 form2.fields.push_back(field);
1690 test::CreateTestFormField("Exp Month:", "exp_month", "01", "text", &field);
1691 form2.fields.push_back(field);
1692 test::CreateTestFormField("Exp Year:", "exp_year", "2012", "text", &field);
1693 form2.fields.push_back(field);
1694
1695 FormStructure form_structure2(form2, std::string());
1696 form_structure2.DetermineHeuristicTypes(TestAutofillMetrics());
1697 EXPECT_FALSE(personal_data_->ImportFormData(form_structure2,
1698 &imported_credit_card));
1699 EXPECT_FALSE(imported_credit_card);
1700
1701 // Since no refresh is expected, reload the data from the database to make
1702 // sure no changes were written out.
1703 ResetPersonalDataManager();
1704
1705 // No change is expected.
1706 CreditCard expected2(base::GenerateGUID(), "https://www.example.com");
1707 test::SetCreditCardInfo(&expected2,
1708 "Biggie Smalls", "4111111111111111", "01", "2011");
1709 const std::vector<CreditCard*>& results2 = personal_data_->GetCreditCards();
1710 ASSERT_EQ(1U, results2.size());
1711 EXPECT_EQ(0, expected2.Compare(*results2[0]));
1712 }
1713
1714 TEST_F(PersonalDataManagerTest, AggregateCreditCardWithMissingInfoInNew) {
1715 FormData form1;
1716
1717 // Start with a single valid credit card form.
1718 FormFieldData field;
1719 test::CreateTestFormField(
1720 "Name on card:", "name_on_card", "Biggie Smalls", "text", &field);
1721 form1.fields.push_back(field);
1722 test::CreateTestFormField(
1723 "Card Number:", "card_number", "4111-1111-1111-1111", "text", &field);
1724 form1.fields.push_back(field);
1725 test::CreateTestFormField("Exp Month:", "exp_month", "01", "text", &field);
1726 form1.fields.push_back(field);
1727 test::CreateTestFormField("Exp Year:", "exp_year", "2011", "text", &field);
1728 form1.fields.push_back(field);
1729
1730 FormStructure form_structure1(form1, std::string());
1731 form_structure1.DetermineHeuristicTypes(TestAutofillMetrics());
1732 const CreditCard* imported_credit_card;
1733 EXPECT_TRUE(personal_data_->ImportFormData(form_structure1,
1734 &imported_credit_card));
1735 ASSERT_TRUE(imported_credit_card);
1736 personal_data_->SaveImportedCreditCard(*imported_credit_card);
1737 delete imported_credit_card;
1738
1739 // Verify that the web database has been updated and the notification sent.
1740 EXPECT_CALL(personal_data_observer_,
1741 OnPersonalDataChanged()).WillOnce(QuitUIMessageLoop());
1742 base::MessageLoop::current()->Run();
1743
1744 CreditCard expected(base::GenerateGUID(), "https://www.example.com");
1745 test::SetCreditCardInfo(&expected,
1746 "Biggie Smalls", "4111111111111111", "01", "2011");
1747 const std::vector<CreditCard*>& results = personal_data_->GetCreditCards();
1748 ASSERT_EQ(1U, results.size());
1749 EXPECT_EQ(0, expected.Compare(*results[0]));
1750
1751 // Add a second different valid credit card where the name is missing but
1752 // the credit card number matches.
1753 FormData form2;
1754 // Note missing name.
1755 test::CreateTestFormField(
1756 "Card Number:", "card_number", "4111111111111111", "text", &field);
1757 form2.fields.push_back(field);
1758 test::CreateTestFormField("Exp Month:", "exp_month", "01", "text", &field);
1759 form2.fields.push_back(field);
1760 test::CreateTestFormField("Exp Year:", "exp_year", "2011", "text", &field);
1761 form2.fields.push_back(field);
1762
1763 FormStructure form_structure2(form2, std::string());
1764 form_structure2.DetermineHeuristicTypes(TestAutofillMetrics());
1765 EXPECT_TRUE(personal_data_->ImportFormData(form_structure2,
1766 &imported_credit_card));
1767 EXPECT_FALSE(imported_credit_card);
1768
1769 // Since no refresh is expected, reload the data from the database to make
1770 // sure no changes were written out.
1771 ResetPersonalDataManager();
1772
1773 // No change is expected.
1774 CreditCard expected2(base::GenerateGUID(), "https://www.example.com");
1775 test::SetCreditCardInfo(&expected2,
1776 "Biggie Smalls", "4111111111111111", "01", "2011");
1777 const std::vector<CreditCard*>& results2 = personal_data_->GetCreditCards();
1778 ASSERT_EQ(1U, results2.size());
1779 EXPECT_EQ(0, expected2.Compare(*results2[0]));
1780
1781 // Add a third credit card where the expiration date is missing.
1782 FormData form3;
1783 test::CreateTestFormField(
1784 "Name on card:", "name_on_card", "Johnny McEnroe", "text", &field);
1785 form3.fields.push_back(field);
1786 test::CreateTestFormField(
1787 "Card Number:", "card_number", "5555555555554444", "text", &field);
1788 form3.fields.push_back(field);
1789 // Note missing expiration month and year..
1790
1791 FormStructure form_structure3(form3, std::string());
1792 form_structure3.DetermineHeuristicTypes(TestAutofillMetrics());
1793 EXPECT_FALSE(personal_data_->ImportFormData(form_structure3,
1794 &imported_credit_card));
1795 ASSERT_FALSE(imported_credit_card);
1796
1797 // Since no refresh is expected, reload the data from the database to make
1798 // sure no changes were written out.
1799 ResetPersonalDataManager();
1800
1801 // No change is expected.
1802 CreditCard expected3(base::GenerateGUID(), "https://www.example.com");
1803 test::SetCreditCardInfo(&expected3,
1804 "Biggie Smalls", "4111111111111111", "01", "2011");
1805 const std::vector<CreditCard*>& results3 = personal_data_->GetCreditCards();
1806 ASSERT_EQ(1U, results3.size());
1807 EXPECT_EQ(0, expected3.Compare(*results3[0]));
1808 }
1809
1810 TEST_F(PersonalDataManagerTest, AggregateCreditCardWithMissingInfoInOld) {
1811 // Start with a single valid credit card stored via the preferences.
1812 // Note the empty name.
1813 CreditCard saved_credit_card(base::GenerateGUID(), "https://www.example.com");
1814 test::SetCreditCardInfo(&saved_credit_card,
1815 "", "4111111111111111" /* Visa */, "01", "2011");
1816 personal_data_->AddCreditCard(saved_credit_card);
1817
1818 // Verify that the web database has been updated and the notification sent.
1819 EXPECT_CALL(personal_data_observer_,
1820 OnPersonalDataChanged()).WillOnce(QuitUIMessageLoop());
1821 base::MessageLoop::current()->Run();
1822
1823 const std::vector<CreditCard*>& results1 = personal_data_->GetCreditCards();
1824 ASSERT_EQ(1U, results1.size());
1825 EXPECT_EQ(saved_credit_card, *results1[0]);
1826
1827
1828 // Add a second different valid credit card where the year is different but
1829 // the credit card number matches.
1830 FormData form;
1831 FormFieldData field;
1832 test::CreateTestFormField(
1833 "Name on card:", "name_on_card", "Biggie Smalls", "text", &field);
1834 form.fields.push_back(field);
1835 test::CreateTestFormField(
1836 "Card Number:", "card_number", "4111-1111-1111-1111", "text", &field);
1837 form.fields.push_back(field);
1838 test::CreateTestFormField("Exp Month:", "exp_month", "01", "text", &field);
1839 form.fields.push_back(field);
1840 test::CreateTestFormField("Exp Year:", "exp_year", "2012", "text", &field);
1841 form.fields.push_back(field);
1842
1843 FormStructure form_structure(form, std::string());
1844 form_structure.DetermineHeuristicTypes(TestAutofillMetrics());
1845 const CreditCard* imported_credit_card;
1846 EXPECT_TRUE(personal_data_->ImportFormData(form_structure,
1847 &imported_credit_card));
1848 EXPECT_FALSE(imported_credit_card);
1849
1850 // Verify that the web database has been updated and the notification sent.
1851 EXPECT_CALL(personal_data_observer_,
1852 OnPersonalDataChanged()).WillOnce(QuitUIMessageLoop());
1853 base::MessageLoop::current()->Run();
1854
1855 // Expect that the newer information is saved. In this case the year is
1856 // added to the existing credit card.
1857 CreditCard expected2(base::GenerateGUID(), "https://www.example.com");
1858 test::SetCreditCardInfo(&expected2,
1859 "Biggie Smalls", "4111111111111111", "01", "2012");
1860 const std::vector<CreditCard*>& results2 = personal_data_->GetCreditCards();
1861 ASSERT_EQ(1U, results2.size());
1862 EXPECT_EQ(0, expected2.Compare(*results2[0]));
1863 }
1864
1865 // We allow the user to store a credit card number with separators via the UI.
1866 // We should not try to re-aggregate the same card with the separators stripped.
1867 TEST_F(PersonalDataManagerTest, AggregateSameCreditCardWithSeparators) {
1868 // Start with a single valid credit card stored via the preferences.
1869 // Note the separators in the credit card number.
1870 CreditCard saved_credit_card(base::GenerateGUID(), "https://www.example.com");
1871 test::SetCreditCardInfo(&saved_credit_card,
1872 "Biggie Smalls", "4111 1111 1111 1111" /* Visa */, "01", "2011");
1873 personal_data_->AddCreditCard(saved_credit_card);
1874
1875 // Verify that the web database has been updated and the notification sent.
1876 EXPECT_CALL(personal_data_observer_,
1877 OnPersonalDataChanged()).WillOnce(QuitUIMessageLoop());
1878 base::MessageLoop::current()->Run();
1879
1880 const std::vector<CreditCard*>& results1 = personal_data_->GetCreditCards();
1881 ASSERT_EQ(1U, results1.size());
1882 EXPECT_EQ(0, saved_credit_card.Compare(*results1[0]));
1883
1884 // Import the same card info, but with different separators in the number.
1885 FormData form;
1886 FormFieldData field;
1887 test::CreateTestFormField(
1888 "Name on card:", "name_on_card", "Biggie Smalls", "text", &field);
1889 form.fields.push_back(field);
1890 test::CreateTestFormField(
1891 "Card Number:", "card_number", "4111-1111-1111-1111", "text", &field);
1892 form.fields.push_back(field);
1893 test::CreateTestFormField("Exp Month:", "exp_month", "01", "text", &field);
1894 form.fields.push_back(field);
1895 test::CreateTestFormField("Exp Year:", "exp_year", "2011", "text", &field);
1896 form.fields.push_back(field);
1897
1898 FormStructure form_structure(form, std::string());
1899 form_structure.DetermineHeuristicTypes(TestAutofillMetrics());
1900 const CreditCard* imported_credit_card;
1901 EXPECT_TRUE(personal_data_->ImportFormData(form_structure,
1902 &imported_credit_card));
1903 EXPECT_FALSE(imported_credit_card);
1904
1905 // Since no refresh is expected, reload the data from the database to make
1906 // sure no changes were written out.
1907 ResetPersonalDataManager();
1908
1909 // Expect that no new card is saved.
1910 const std::vector<CreditCard*>& results2 = personal_data_->GetCreditCards();
1911 ASSERT_EQ(1U, results2.size());
1912 EXPECT_EQ(0, saved_credit_card.Compare(*results2[0]));
1913 }
1914
1915 // Ensure that if a verified profile already exists, aggregated profiles cannot
1916 // modify it in any way.
1917 TEST_F(PersonalDataManagerTest, AggregateExistingVerifiedProfileWithConflict) {
1918 // Start with a verified profile.
1919 AutofillProfile profile(base::GenerateGUID(), "Chrome settings");
1920 test::SetProfileInfo(&profile,
1921 "Marion", "Mitchell", "Morrison",
1922 "johnwayne@me.xyz", "Fox", "123 Zoo St.", "unit 5", "Hollywood", "CA",
1923 "91601", "US", "12345678910");
1924 EXPECT_TRUE(profile.IsVerified());
1925
1926 // Add the profile to the database.
1927 personal_data_->AddProfile(profile);
1928
1929 // Verify that the web database has been updated and the notification sent.
1930 EXPECT_CALL(personal_data_observer_,
1931 OnPersonalDataChanged()).WillOnce(QuitUIMessageLoop());
1932 base::MessageLoop::current()->Run();
1933
1934 // Simulate a form submission with conflicting info.
1935 FormData form;
1936 FormFieldData field;
1937 test::CreateTestFormField(
1938 "First name:", "first_name", "Marion", "text", &field);
1939 form.fields.push_back(field);
1940 test::CreateTestFormField(
1941 "Last name:", "last_name", "Morrison", "text", &field);
1942 form.fields.push_back(field);
1943 test::CreateTestFormField(
1944 "Email:", "email", "other.email@example.com", "text", &field);
1945 form.fields.push_back(field);
1946 test::CreateTestFormField(
1947 "Address:", "address1", "123 Zoo St.", "text", &field);
1948 form.fields.push_back(field);
1949 test::CreateTestFormField("City:", "city", "Hollywood", "text", &field);
1950 form.fields.push_back(field);
1951 test::CreateTestFormField("State:", "state", "CA", "text", &field);
1952 form.fields.push_back(field);
1953 test::CreateTestFormField("Zip:", "zip", "91601", "text", &field);
1954 form.fields.push_back(field);
1955
1956 FormStructure form_structure(form, std::string());
1957 form_structure.DetermineHeuristicTypes(TestAutofillMetrics());
1958 const CreditCard* imported_credit_card;
1959 EXPECT_TRUE(personal_data_->ImportFormData(form_structure,
1960 &imported_credit_card));
1961 EXPECT_FALSE(imported_credit_card);
1962
1963 // Wait for the refresh, which in this case is a no-op.
1964 EXPECT_CALL(personal_data_observer_,
1965 OnPersonalDataChanged()).WillOnce(QuitUIMessageLoop());
1966 base::MessageLoop::current()->Run();
1967
1968 // Expect that no new profile is saved.
1969 const std::vector<AutofillProfile*>& results = personal_data_->GetProfiles();
1970 ASSERT_EQ(1U, results.size());
1971 EXPECT_EQ(0, profile.Compare(*results[0]));
1972 }
1973
1974 // Ensure that if a verified credit card already exists, aggregated credit cards
1975 // cannot modify it in any way.
1976 TEST_F(PersonalDataManagerTest,
1977 AggregateExistingVerifiedCreditCardWithConflict) {
1978 // Start with a verified credit card.
1979 CreditCard credit_card(base::GenerateGUID(), "Chrome settings");
1980 test::SetCreditCardInfo(&credit_card,
1981 "Biggie Smalls", "4111 1111 1111 1111" /* Visa */, "01", "2011");
1982 EXPECT_TRUE(credit_card.IsVerified());
1983
1984 // Add the credit card to the database.
1985 personal_data_->AddCreditCard(credit_card);
1986
1987 // Verify that the web database has been updated and the notification sent.
1988 EXPECT_CALL(personal_data_observer_,
1989 OnPersonalDataChanged()).WillOnce(QuitUIMessageLoop());
1990 base::MessageLoop::current()->Run();
1991
1992 // Simulate a form submission with conflicting expiration year.
1993 FormData form;
1994 FormFieldData field;
1995 test::CreateTestFormField(
1996 "Name on card:", "name_on_card", "Biggie Smalls", "text", &field);
1997 form.fields.push_back(field);
1998 test::CreateTestFormField(
1999 "Card Number:", "card_number", "4111 1111 1111 1111", "text", &field);
2000 form.fields.push_back(field);
2001 test::CreateTestFormField("Exp Month:", "exp_month", "01", "text", &field);
2002 form.fields.push_back(field);
2003 test::CreateTestFormField("Exp Year:", "exp_year", "2012", "text", &field);
2004 form.fields.push_back(field);
2005
2006 FormStructure form_structure(form, std::string());
2007 form_structure.DetermineHeuristicTypes(TestAutofillMetrics());
2008 const CreditCard* imported_credit_card;
2009 EXPECT_TRUE(personal_data_->ImportFormData(form_structure,
2010 &imported_credit_card));
2011 ASSERT_FALSE(imported_credit_card);
2012
2013 // Since no refresh is expected, reload the data from the database to make
2014 // sure no changes were written out.
2015 ResetPersonalDataManager();
2016
2017 // Expect that the saved credit card is not modified.
2018 const std::vector<CreditCard*>& results = personal_data_->GetCreditCards();
2019 ASSERT_EQ(1U, results.size());
2020 EXPECT_EQ(0, credit_card.Compare(*results[0]));
2021 }
2022
2023 // Ensure that verified profiles can be saved via SaveImportedProfile,
2024 // overwriting existing unverified profiles.
2025 TEST_F(PersonalDataManagerTest, SaveImportedProfileWithVerifiedData) {
2026 // Start with an unverified profile.
2027 AutofillProfile profile(base::GenerateGUID(), "https://www.example.com");
2028 test::SetProfileInfo(&profile,
2029 "Marion", "Mitchell", "Morrison",
2030 "johnwayne@me.xyz", "Fox", "123 Zoo St.", "unit 5", "Hollywood", "CA",
2031 "91601", "US", "12345678910");
2032 EXPECT_FALSE(profile.IsVerified());
2033
2034 // Add the profile to the database.
2035 personal_data_->AddProfile(profile);
2036
2037 // Verify that the web database has been updated and the notification sent.
2038 EXPECT_CALL(personal_data_observer_,
2039 OnPersonalDataChanged()).WillOnce(QuitUIMessageLoop());
2040 base::MessageLoop::current()->Run();
2041
2042 AutofillProfile new_verified_profile = profile;
2043 new_verified_profile.set_guid(base::GenerateGUID());
2044 new_verified_profile.set_origin("Chrome settings");
2045 new_verified_profile.SetRawInfo(COMPANY_NAME, ASCIIToUTF16("Fizzbang, Inc."));
2046 EXPECT_TRUE(new_verified_profile.IsVerified());
2047
2048 personal_data_->SaveImportedProfile(new_verified_profile);
2049
2050 // Verify that the web database has been updated and the notification sent.
2051 EXPECT_CALL(personal_data_observer_,
2052 OnPersonalDataChanged()).WillOnce(QuitUIMessageLoop());
2053 base::MessageLoop::current()->Run();
2054
2055 // Expect that the existing profile is not modified, and instead the new
2056 // profile is added.
2057 const std::vector<AutofillProfile*>& results = personal_data_->GetProfiles();
2058 ASSERT_EQ(1U, results.size());
2059 EXPECT_EQ(0, new_verified_profile.Compare(*results[0]));
2060 }
2061
2062 // Ensure that verified profiles can be saved via SaveImportedProfile,
2063 // overwriting existing verified profiles as well.
2064 TEST_F(PersonalDataManagerTest, SaveImportedProfileWithExistingVerifiedData) {
2065 // Start with a verified profile.
2066 AutofillProfile profile(base::GenerateGUID(), "Chrome settings");
2067 test::SetProfileInfo(&profile,
2068 "Marion", "Mitchell", "Morrison",
2069 "johnwayne@me.xyz", "Fox", "123 Zoo St.", "unit 5", "Hollywood", "CA",
2070 "91601", "US", "12345678910");
2071 EXPECT_TRUE(profile.IsVerified());
2072
2073 // Add the profile to the database.
2074 personal_data_->AddProfile(profile);
2075
2076 // Verify that the web database has been updated and the notification sent.
2077 EXPECT_CALL(personal_data_observer_,
2078 OnPersonalDataChanged()).WillOnce(QuitUIMessageLoop());
2079 base::MessageLoop::current()->Run();
2080
2081 AutofillProfile new_verified_profile = profile;
2082 new_verified_profile.set_guid(base::GenerateGUID());
2083 new_verified_profile.SetRawInfo(COMPANY_NAME, ASCIIToUTF16("Fizzbang, Inc."));
2084 new_verified_profile.SetRawInfo(NAME_MIDDLE, base::string16());
2085 EXPECT_TRUE(new_verified_profile.IsVerified());
2086
2087 personal_data_->SaveImportedProfile(new_verified_profile);
2088
2089 // Verify that the web database has been updated and the notification sent.
2090 EXPECT_CALL(personal_data_observer_,
2091 OnPersonalDataChanged()).WillOnce(QuitUIMessageLoop());
2092 base::MessageLoop::current()->Run();
2093
2094 // The new profile should be merged into the existing one.
2095 AutofillProfile expected_profile = new_verified_profile;
2096 expected_profile.set_guid(profile.guid());
2097 std::vector<base::string16> names;
2098 expected_profile.GetRawMultiInfo(NAME_FULL, &names);
2099 names.insert(names.begin(), ASCIIToUTF16("Marion Mitchell Morrison"));
2100 expected_profile.SetRawMultiInfo(NAME_FULL, names);
2101
2102 const std::vector<AutofillProfile*>& results = personal_data_->GetProfiles();
2103 ASSERT_EQ(1U, results.size());
2104 EXPECT_EQ(expected_profile, *results[0]);
2105 }
2106
2107 // Ensure that verified credit cards can be saved via SaveImportedCreditCard.
2108 TEST_F(PersonalDataManagerTest, SaveImportedCreditCardWithVerifiedData) {
2109 // Start with a verified credit card.
2110 CreditCard credit_card(base::GenerateGUID(), "Chrome settings");
2111 test::SetCreditCardInfo(&credit_card,
2112 "Biggie Smalls", "4111 1111 1111 1111" /* Visa */, "01", "2011");
2113 EXPECT_TRUE(credit_card.IsVerified());
2114
2115 // Add the credit card to the database.
2116 personal_data_->AddCreditCard(credit_card);
2117
2118 // Verify that the web database has been updated and the notification sent.
2119 EXPECT_CALL(personal_data_observer_,
2120 OnPersonalDataChanged()).WillOnce(QuitUIMessageLoop());
2121 base::MessageLoop::current()->Run();
2122
2123 CreditCard new_verified_card = credit_card;
2124 new_verified_card.set_guid(base::GenerateGUID());
2125 new_verified_card.SetRawInfo(CREDIT_CARD_NAME, ASCIIToUTF16("B. Small"));
2126 EXPECT_TRUE(new_verified_card.IsVerified());
2127
2128 personal_data_->SaveImportedCreditCard(new_verified_card);
2129
2130 // Verify that the web database has been updated and the notification sent.
2131 EXPECT_CALL(personal_data_observer_,
2132 OnPersonalDataChanged()).WillOnce(QuitUIMessageLoop());
2133 base::MessageLoop::current()->Run();
2134
2135 // Expect that the saved credit card is updated.
2136 const std::vector<CreditCard*>& results = personal_data_->GetCreditCards();
2137 ASSERT_EQ(1U, results.size());
2138 EXPECT_EQ(ASCIIToUTF16("B. Small"), results[0]->GetRawInfo(CREDIT_CARD_NAME));
2139 }
2140
2141 TEST_F(PersonalDataManagerTest, GetNonEmptyTypes) {
2142 // Check that there are no available types with no profiles stored.
2143 FieldTypeSet non_empty_types;
2144 personal_data_->GetNonEmptyTypes(&non_empty_types);
2145 EXPECT_EQ(0U, non_empty_types.size());
2146
2147 // Test with one profile stored.
2148 AutofillProfile profile0(base::GenerateGUID(), "https://www.example.com");
2149 test::SetProfileInfo(&profile0,
2150 "Marion", NULL, "Morrison",
2151 "johnwayne@me.xyz", NULL, "123 Zoo St.", NULL, "Hollywood", "CA",
2152 "91601", "US", "14155678910");
2153
2154 personal_data_->AddProfile(profile0);
2155
2156 // Verify that the web database has been updated and the notification sent.
2157 EXPECT_CALL(personal_data_observer_,
2158 OnPersonalDataChanged()).WillOnce(QuitUIMessageLoop());
2159 base::MessageLoop::current()->Run();
2160
2161 personal_data_->GetNonEmptyTypes(&non_empty_types);
2162 EXPECT_EQ(14U, non_empty_types.size());
2163 EXPECT_TRUE(non_empty_types.count(NAME_FIRST));
2164 EXPECT_TRUE(non_empty_types.count(NAME_LAST));
2165 EXPECT_TRUE(non_empty_types.count(NAME_FULL));
2166 EXPECT_TRUE(non_empty_types.count(EMAIL_ADDRESS));
2167 EXPECT_TRUE(non_empty_types.count(ADDRESS_HOME_LINE1));
2168 EXPECT_TRUE(non_empty_types.count(ADDRESS_HOME_CITY));
2169 EXPECT_TRUE(non_empty_types.count(ADDRESS_HOME_STATE));
2170 EXPECT_TRUE(non_empty_types.count(ADDRESS_HOME_ZIP));
2171 EXPECT_TRUE(non_empty_types.count(ADDRESS_HOME_COUNTRY));
2172 EXPECT_TRUE(non_empty_types.count(PHONE_HOME_NUMBER));
2173 EXPECT_TRUE(non_empty_types.count(PHONE_HOME_COUNTRY_CODE));
2174 EXPECT_TRUE(non_empty_types.count(PHONE_HOME_CITY_CODE));
2175 EXPECT_TRUE(non_empty_types.count(PHONE_HOME_CITY_AND_NUMBER));
2176 EXPECT_TRUE(non_empty_types.count(PHONE_HOME_WHOLE_NUMBER));
2177
2178 // Test with multiple profiles stored.
2179 AutofillProfile profile1(base::GenerateGUID(), "https://www.example.com");
2180 test::SetProfileInfo(&profile1,
2181 "Josephine", "Alicia", "Saenz",
2182 "joewayne@me.xyz", "Fox", "903 Apple Ct.", NULL, "Orlando", "FL", "32801",
2183 "US", "16502937549");
2184
2185 AutofillProfile profile2(base::GenerateGUID(), "https://www.example.com");
2186 test::SetProfileInfo(&profile2,
2187 "Josephine", "Alicia", "Saenz",
2188 "joewayne@me.xyz", "Fox", "1212 Center.", "Bld. 5", "Orlando", "FL",
2189 "32801", "US", "16502937549");
2190
2191 personal_data_->AddProfile(profile1);
2192 personal_data_->AddProfile(profile2);
2193
2194 // Verify that the web database has been updated and the notification sent.
2195 EXPECT_CALL(personal_data_observer_,
2196 OnPersonalDataChanged()).WillOnce(QuitUIMessageLoop());
2197 base::MessageLoop::current()->Run();
2198
2199 personal_data_->GetNonEmptyTypes(&non_empty_types);
2200 EXPECT_EQ(18U, non_empty_types.size());
2201 EXPECT_TRUE(non_empty_types.count(NAME_FIRST));
2202 EXPECT_TRUE(non_empty_types.count(NAME_MIDDLE));
2203 EXPECT_TRUE(non_empty_types.count(NAME_MIDDLE_INITIAL));
2204 EXPECT_TRUE(non_empty_types.count(NAME_LAST));
2205 EXPECT_TRUE(non_empty_types.count(NAME_FULL));
2206 EXPECT_TRUE(non_empty_types.count(EMAIL_ADDRESS));
2207 EXPECT_TRUE(non_empty_types.count(COMPANY_NAME));
2208 EXPECT_TRUE(non_empty_types.count(ADDRESS_HOME_LINE1));
2209 EXPECT_TRUE(non_empty_types.count(ADDRESS_HOME_LINE2));
2210 EXPECT_TRUE(non_empty_types.count(ADDRESS_HOME_CITY));
2211 EXPECT_TRUE(non_empty_types.count(ADDRESS_HOME_STATE));
2212 EXPECT_TRUE(non_empty_types.count(ADDRESS_HOME_ZIP));
2213 EXPECT_TRUE(non_empty_types.count(ADDRESS_HOME_COUNTRY));
2214 EXPECT_TRUE(non_empty_types.count(PHONE_HOME_NUMBER));
2215 EXPECT_TRUE(non_empty_types.count(PHONE_HOME_CITY_CODE));
2216 EXPECT_TRUE(non_empty_types.count(PHONE_HOME_COUNTRY_CODE));
2217 EXPECT_TRUE(non_empty_types.count(PHONE_HOME_CITY_AND_NUMBER));
2218 EXPECT_TRUE(non_empty_types.count(PHONE_HOME_WHOLE_NUMBER));
2219
2220 // Test with credit card information also stored.
2221 CreditCard credit_card(base::GenerateGUID(), "https://www.example.com");
2222 test::SetCreditCardInfo(&credit_card,
2223 "John Dillinger", "423456789012" /* Visa */,
2224 "01", "2010");
2225 personal_data_->AddCreditCard(credit_card);
2226
2227 // Verify that the web database has been updated and the notification sent.
2228 EXPECT_CALL(personal_data_observer_,
2229 OnPersonalDataChanged()).WillOnce(QuitUIMessageLoop());
2230 base::MessageLoop::current()->Run();
2231
2232 personal_data_->GetNonEmptyTypes(&non_empty_types);
2233 EXPECT_EQ(25U, non_empty_types.size());
2234 EXPECT_TRUE(non_empty_types.count(NAME_FIRST));
2235 EXPECT_TRUE(non_empty_types.count(NAME_MIDDLE));
2236 EXPECT_TRUE(non_empty_types.count(NAME_MIDDLE_INITIAL));
2237 EXPECT_TRUE(non_empty_types.count(NAME_LAST));
2238 EXPECT_TRUE(non_empty_types.count(NAME_FULL));
2239 EXPECT_TRUE(non_empty_types.count(EMAIL_ADDRESS));
2240 EXPECT_TRUE(non_empty_types.count(COMPANY_NAME));
2241 EXPECT_TRUE(non_empty_types.count(ADDRESS_HOME_LINE1));
2242 EXPECT_TRUE(non_empty_types.count(ADDRESS_HOME_LINE2));
2243 EXPECT_TRUE(non_empty_types.count(ADDRESS_HOME_CITY));
2244 EXPECT_TRUE(non_empty_types.count(ADDRESS_HOME_STATE));
2245 EXPECT_TRUE(non_empty_types.count(ADDRESS_HOME_ZIP));
2246 EXPECT_TRUE(non_empty_types.count(ADDRESS_HOME_COUNTRY));
2247 EXPECT_TRUE(non_empty_types.count(PHONE_HOME_NUMBER));
2248 EXPECT_TRUE(non_empty_types.count(PHONE_HOME_CITY_CODE));
2249 EXPECT_TRUE(non_empty_types.count(PHONE_HOME_COUNTRY_CODE));
2250 EXPECT_TRUE(non_empty_types.count(PHONE_HOME_CITY_AND_NUMBER));
2251 EXPECT_TRUE(non_empty_types.count(PHONE_HOME_WHOLE_NUMBER));
2252 EXPECT_TRUE(non_empty_types.count(CREDIT_CARD_NAME));
2253 EXPECT_TRUE(non_empty_types.count(CREDIT_CARD_NUMBER));
2254 EXPECT_TRUE(non_empty_types.count(CREDIT_CARD_EXP_MONTH));
2255 EXPECT_TRUE(non_empty_types.count(CREDIT_CARD_EXP_2_DIGIT_YEAR));
2256 EXPECT_TRUE(non_empty_types.count(CREDIT_CARD_EXP_4_DIGIT_YEAR));
2257 EXPECT_TRUE(non_empty_types.count(CREDIT_CARD_EXP_DATE_2_DIGIT_YEAR));
2258 EXPECT_TRUE(non_empty_types.count(CREDIT_CARD_EXP_DATE_4_DIGIT_YEAR));
2259 }
2260
2261 TEST_F(PersonalDataManagerTest, CaseInsensitiveMultiValueAggregation) {
2262 FormData form1;
2263 FormFieldData field;
2264 test::CreateTestFormField(
2265 "First name:", "first_name", "George", "text", &field);
2266 form1.fields.push_back(field);
2267 test::CreateTestFormField(
2268 "Last name:", "last_name", "Washington", "text", &field);
2269 form1.fields.push_back(field);
2270 test::CreateTestFormField(
2271 "Email:", "email", "theprez@gmail.com", "text", &field);
2272 form1.fields.push_back(field);
2273 test::CreateTestFormField(
2274 "Address:", "address1", "21 Laussat St", "text", &field);
2275 form1.fields.push_back(field);
2276 test::CreateTestFormField(
2277 "City:", "city", "San Francisco", "text", &field);
2278 form1.fields.push_back(field);
2279 test::CreateTestFormField("State:", "state", "California", "text", &field);
2280 form1.fields.push_back(field);
2281 test::CreateTestFormField(
2282 "Zip:", "zip", "94102", "text", &field);
2283 form1.fields.push_back(field);
2284 test::CreateTestFormField(
2285 "Phone number:", "phone_number", "817-555-6789", "text", &field);
2286 form1.fields.push_back(field);
2287
2288 FormStructure form_structure1(form1, std::string());
2289 form_structure1.DetermineHeuristicTypes(TestAutofillMetrics());
2290 const CreditCard* imported_credit_card;
2291 EXPECT_TRUE(personal_data_->ImportFormData(form_structure1,
2292 &imported_credit_card));
2293 ASSERT_FALSE(imported_credit_card);
2294
2295 // Verify that the web database has been updated and the notification sent.
2296 EXPECT_CALL(personal_data_observer_,
2297 OnPersonalDataChanged()).WillOnce(QuitUIMessageLoop());
2298 base::MessageLoop::current()->Run();
2299
2300 AutofillProfile expected(base::GenerateGUID(), "https://www.example.com");
2301 test::SetProfileInfo(&expected, "George", NULL,
2302 "Washington", "theprez@gmail.com", NULL, "21 Laussat St", NULL,
2303 "San Francisco", "California", "94102", NULL, "(817) 555-6789");
2304 const std::vector<AutofillProfile*>& results1 = personal_data_->GetProfiles();
2305 ASSERT_EQ(1U, results1.size());
2306 EXPECT_EQ(0, expected.Compare(*results1[0]));
2307
2308 // Upper-case the first name and change the phone number.
2309 FormData form2;
2310 test::CreateTestFormField(
2311 "First name:", "first_name", "GEORGE", "text", &field);
2312 form2.fields.push_back(field);
2313 test::CreateTestFormField(
2314 "Last name:", "last_name", "Washington", "text", &field);
2315 form2.fields.push_back(field);
2316 test::CreateTestFormField(
2317 "Email:", "email", "theprez@gmail.com", "text", &field);
2318 form2.fields.push_back(field);
2319 test::CreateTestFormField(
2320 "Address:", "address1", "21 Laussat St", "text", &field);
2321 form2.fields.push_back(field);
2322 test::CreateTestFormField("City:", "city", "San Francisco", "text", &field);
2323 form2.fields.push_back(field);
2324 test::CreateTestFormField("State:", "state", "California", "text", &field);
2325 form2.fields.push_back(field);
2326 test::CreateTestFormField("Zip:", "zip", "94102", "text", &field);
2327 form2.fields.push_back(field);
2328 test::CreateTestFormField(
2329 "Phone number:", "phone_number", "214-555-1234", "text", &field);
2330 form2.fields.push_back(field);
2331
2332 FormStructure form_structure2(form2, std::string());
2333 form_structure2.DetermineHeuristicTypes(TestAutofillMetrics());
2334 EXPECT_TRUE(personal_data_->ImportFormData(form_structure2,
2335 &imported_credit_card));
2336 ASSERT_FALSE(imported_credit_card);
2337
2338 // Verify that the web database has been updated and the notification sent.
2339 EXPECT_CALL(personal_data_observer_,
2340 OnPersonalDataChanged()).WillOnce(QuitUIMessageLoop());
2341 base::MessageLoop::current()->Run();
2342
2343 const std::vector<AutofillProfile*>& results2 = personal_data_->GetProfiles();
2344
2345 // Modify expected to include multi-valued fields.
2346 std::vector<base::string16> values;
2347 expected.GetRawMultiInfo(PHONE_HOME_WHOLE_NUMBER, &values);
2348 values.push_back(ASCIIToUTF16("(214) 555-1234"));
2349 expected.SetRawMultiInfo(PHONE_HOME_WHOLE_NUMBER, values);
2350
2351 ASSERT_EQ(1U, results2.size());
2352 EXPECT_EQ(0, expected.Compare(*results2[0]));
2353 }
2354
2355 TEST_F(PersonalDataManagerTest, IncognitoReadOnly) {
2356 ASSERT_TRUE(personal_data_->GetProfiles().empty());
2357 ASSERT_TRUE(personal_data_->GetCreditCards().empty());
2358
2359 AutofillProfile steve_jobs(base::GenerateGUID(), "https://www.example.com");
2360 test::SetProfileInfo(&steve_jobs, "Steven", "Paul", "Jobs", "sjobs@apple.com",
2361 "Apple Computer, Inc.", "1 Infinite Loop", "", "Cupertino", "CA", "95014",
2362 "US", "(800) 275-2273");
2363 personal_data_->AddProfile(steve_jobs);
2364
2365 CreditCard bill_gates(base::GenerateGUID(), "https://www.example.com");
2366 test::SetCreditCardInfo(
2367 &bill_gates, "William H. Gates", "5555555555554444", "1", "2020");
2368 personal_data_->AddCreditCard(bill_gates);
2369
2370 ResetPersonalDataManager();
2371 ASSERT_EQ(1U, personal_data_->GetProfiles().size());
2372 ASSERT_EQ(1U, personal_data_->GetCreditCards().size());
2373
2374 // After this point no adds, saves, or updates should take effect.
2375 MakeProfileIncognito();
2376 EXPECT_CALL(personal_data_observer_, OnPersonalDataChanged()).Times(0);
2377
2378 // Add profiles or credit card shouldn't work.
2379 personal_data_->AddProfile(test::GetFullProfile());
2380
2381 CreditCard larry_page(base::GenerateGUID(), "https://www.example.com");
2382 test::SetCreditCardInfo(
2383 &larry_page, "Lawrence Page", "4111111111111111", "10", "2025");
2384 personal_data_->AddCreditCard(larry_page);
2385
2386 ResetPersonalDataManager();
2387 EXPECT_EQ(1U, personal_data_->GetProfiles().size());
2388 EXPECT_EQ(1U, personal_data_->GetCreditCards().size());
2389
2390 // Saving or creating profiles from imported profiles shouldn't work.
2391 steve_jobs.SetRawInfo(NAME_FIRST, ASCIIToUTF16("Steve"));
2392 personal_data_->SaveImportedProfile(steve_jobs);
2393
2394 bill_gates.SetRawInfo(CREDIT_CARD_NAME, ASCIIToUTF16("Bill Gates"));
2395 personal_data_->SaveImportedCreditCard(bill_gates);
2396
2397 ResetPersonalDataManager();
2398 EXPECT_EQ(ASCIIToUTF16("Steven"),
2399 personal_data_->GetProfiles()[0]->GetRawInfo(NAME_FIRST));
2400 EXPECT_EQ(ASCIIToUTF16("William H. Gates"),
2401 personal_data_->GetCreditCards()[0]->GetRawInfo(CREDIT_CARD_NAME));
2402
2403 // Updating existing profiles shouldn't work.
2404 steve_jobs.SetRawInfo(NAME_FIRST, ASCIIToUTF16("Steve"));
2405 personal_data_->UpdateProfile(steve_jobs);
2406
2407 bill_gates.SetRawInfo(CREDIT_CARD_NAME, ASCIIToUTF16("Bill Gates"));
2408 personal_data_->UpdateCreditCard(bill_gates);
2409
2410 ResetPersonalDataManager();
2411 EXPECT_EQ(ASCIIToUTF16("Steven"),
2412 personal_data_->GetProfiles()[0]->GetRawInfo(NAME_FIRST));
2413 EXPECT_EQ(ASCIIToUTF16("William H. Gates"),
2414 personal_data_->GetCreditCards()[0]->GetRawInfo(CREDIT_CARD_NAME));
2415
2416 // Removing shouldn't work.
2417 personal_data_->RemoveByGUID(steve_jobs.guid());
2418 personal_data_->RemoveByGUID(bill_gates.guid());
2419
2420 ResetPersonalDataManager();
2421 EXPECT_EQ(1U, personal_data_->GetProfiles().size());
2422 EXPECT_EQ(1U, personal_data_->GetCreditCards().size());
2423 }
2424
2425 } // namespace autofill
OLDNEW
« no previous file with comments | « components/autofill/browser/personal_data_manager_observer.h ('k') | components/autofill/browser/phone_field.h » ('j') | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698