1 // Copyright (c) 2011 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 #include <vector>
7
8 #include "base/basictypes.h"
9 #include "base/file_util.h"
10 #include "base/memory/ref_counted.h"
11 #include "base/memory/scoped_ptr.h"
12 #include "base/memory/scoped_vector.h"
13 #include "base/message_loop.h"
14 #include "base/path_service.h"
15 #include "base/stl_util-inl.h"
16 #include "base/string16.h"
17 #include "base/string_util.h"
18 #include "base/synchronization/waitable_event.h"
19 #include "base/time.h"
20 #include "base/utf_string_conversions.h"
21 #include "chrome/browser/autofill/autofill_profile.h"
22 #include "chrome/browser/autofill/credit_card.h"
23 #include "chrome/browser/webdata/autofill_change.h"
24 #include "chrome/browser/webdata/autofill_entry.h"
25 #include "chrome/browser/webdata/web_data_service.h"
26 #include "chrome/browser/webdata/web_data_service_test_util.h"
27 #include "chrome/common/chrome_paths.h"
28 #include "chrome/common/guid.h"
29 #include "chrome/test/thread_observer_helper.h"
30 #include "content/browser/browser_thread.h"
31 #include "content/common/notification_details.h"
32 #include "content/common/notification_service.h"
33 #include "content/common/notification_type.h"
34 #include "testing/gmock/include/gmock/gmock.h"
35 #include "testing/gtest/include/gtest/gtest.h"
36 #include "webkit/glue/form_field.h"
37
38 using base::Time;
39 using base::TimeDelta;
40 using base::WaitableEvent;
41 using testing::_;
42 using testing::DoDefault;
43 using testing::ElementsAreArray;
44 using testing::Pointee;
45 using testing::Property;
46
47 typedef std::vector<AutofillChange> AutofillChangeList;
48
49 static const int kWebDataServiceTimeoutSeconds = 8;
50
ACTION_P(SignalEvent,event)51 ACTION_P(SignalEvent, event) {
52 event->Signal();
53 }
54
55 class AutofillDBThreadObserverHelper : public DBThreadObserverHelper {
56 protected:
RegisterObservers()57 virtual void RegisterObservers() {
58 registrar_.Add(&observer_,
59 NotificationType::AUTOFILL_ENTRIES_CHANGED,
60 NotificationService::AllSources());
61 registrar_.Add(&observer_,
62 NotificationType::AUTOFILL_PROFILE_CHANGED,
63 NotificationService::AllSources());
64 registrar_.Add(&observer_,
65 NotificationType::AUTOFILL_CREDIT_CARD_CHANGED,
66 NotificationService::AllSources());
67 }
68 };
69
70 class WebDataServiceTest : public testing::Test {
71 public:
WebDataServiceTest()72 WebDataServiceTest()
73 : ui_thread_(BrowserThread::UI, &message_loop_),
74 db_thread_(BrowserThread::DB) {}
75
76 protected:
SetUp()77 virtual void SetUp() {
78 db_thread_.Start();
79
80 PathService::Get(chrome::DIR_TEST_DATA, &profile_dir_);
81 const std::string test_profile = "WebDataServiceTest";
82 profile_dir_ = profile_dir_.AppendASCII(test_profile);
83 file_util::Delete(profile_dir_, true);
84 file_util::CreateDirectory(profile_dir_);
85 wds_ = new WebDataService();
86 wds_->Init(profile_dir_);
87 }
88
TearDown()89 virtual void TearDown() {
90 if (wds_.get())
91 wds_->Shutdown();
92 file_util::Delete(profile_dir_, true);
93
94 db_thread_.Stop();
95 MessageLoop::current()->PostTask(FROM_HERE, new MessageLoop::QuitTask);
96 MessageLoop::current()->Run();
97 }
98
99 MessageLoopForUI message_loop_;
100 BrowserThread ui_thread_;
101 BrowserThread db_thread_;
102 FilePath profile_dir_;
103 scoped_refptr<WebDataService> wds_;
104 };
105
106 class WebDataServiceAutofillTest : public WebDataServiceTest {
107 public:
WebDataServiceAutofillTest()108 WebDataServiceAutofillTest()
109 : WebDataServiceTest(),
110 unique_id1_(1),
111 unique_id2_(2),
112 test_timeout_(TimeDelta::FromSeconds(kWebDataServiceTimeoutSeconds)),
113 done_event_(false, false) {}
114
115 protected:
SetUp()116 virtual void SetUp() {
117 WebDataServiceTest::SetUp();
118 name1_ = ASCIIToUTF16("name1");
119 name2_ = ASCIIToUTF16("name2");
120 value1_ = ASCIIToUTF16("value1");
121 value2_ = ASCIIToUTF16("value2");
122 observer_helper_ = new AutofillDBThreadObserverHelper();
123 observer_helper_->Init();
124 }
125
TearDown()126 virtual void TearDown() {
127 // Release this first so it can get destructed on the db thread.
128 observer_helper_ = NULL;
129 WebDataServiceTest::TearDown();
130 }
131
AppendFormField(const string16 & name,const string16 & value,std::vector<webkit_glue::FormField> * form_fields)132 void AppendFormField(const string16& name,
133 const string16& value,
134 std::vector<webkit_glue::FormField>* form_fields) {
135 form_fields->push_back(
136 webkit_glue::FormField(string16(),
137 name,
138 value,
139 string16(),
140 0,
141 false));
142 }
143
144 string16 name1_;
145 string16 name2_;
146 string16 value1_;
147 string16 value2_;
148 int unique_id1_, unique_id2_;
149 const TimeDelta test_timeout_;
150 scoped_refptr<AutofillDBThreadObserverHelper> observer_helper_;
151 WaitableEvent done_event_;
152 };
153
TEST_F(WebDataServiceAutofillTest,FormFillAdd)154 TEST_F(WebDataServiceAutofillTest, FormFillAdd) {
155 const AutofillChange expected_changes[] = {
156 AutofillChange(AutofillChange::ADD, AutofillKey(name1_, value1_)),
157 AutofillChange(AutofillChange::ADD, AutofillKey(name2_, value2_))
158 };
159
160 // This will verify that the correct notification is triggered,
161 // passing the correct list of autofill keys in the details.
162 EXPECT_CALL(
163 *observer_helper_->observer(),
164 Observe(NotificationType(NotificationType::AUTOFILL_ENTRIES_CHANGED),
165 Source<WebDataService>(wds_.get()),
166 Property(&Details<const AutofillChangeList>::ptr,
167 Pointee(ElementsAreArray(expected_changes))))).
168 WillOnce(SignalEvent(&done_event_));
169
170 std::vector<webkit_glue::FormField> form_fields;
171 AppendFormField(name1_, value1_, &form_fields);
172 AppendFormField(name2_, value2_, &form_fields);
173 wds_->AddFormFields(form_fields);
174
175 // The event will be signaled when the mock observer is notified.
176 done_event_.TimedWait(test_timeout_);
177
178 AutofillWebDataServiceConsumer<std::vector<string16> > consumer;
179 WebDataService::Handle handle;
180 static const int limit = 10;
181 handle = wds_->GetFormValuesForElementName(
182 name1_, string16(), limit, &consumer);
183
184 // The message loop will exit when the consumer is called.
185 MessageLoop::current()->Run();
186
187 EXPECT_EQ(handle, consumer.handle());
188 ASSERT_EQ(1U, consumer.result().size());
189 EXPECT_EQ(value1_, consumer.result()[0]);
190 }
191
TEST_F(WebDataServiceAutofillTest,FormFillRemoveOne)192 TEST_F(WebDataServiceAutofillTest, FormFillRemoveOne) {
193 // First add some values to autofill.
194 EXPECT_CALL(*observer_helper_->observer(), Observe(_, _, _)).
195 WillOnce(SignalEvent(&done_event_));
196 std::vector<webkit_glue::FormField> form_fields;
197 AppendFormField(name1_, value1_, &form_fields);
198 wds_->AddFormFields(form_fields);
199
200 // The event will be signaled when the mock observer is notified.
201 done_event_.TimedWait(test_timeout_);
202
203 // This will verify that the correct notification is triggered,
204 // passing the correct list of autofill keys in the details.
205 const AutofillChange expected_changes[] = {
206 AutofillChange(AutofillChange::REMOVE, AutofillKey(name1_, value1_))
207 };
208 EXPECT_CALL(
209 *observer_helper_->observer(),
210 Observe(NotificationType(NotificationType::AUTOFILL_ENTRIES_CHANGED),
211 Source<WebDataService>(wds_.get()),
212 Property(&Details<const AutofillChangeList>::ptr,
213 Pointee(ElementsAreArray(expected_changes))))).
214 WillOnce(SignalEvent(&done_event_));
215 wds_->RemoveFormValueForElementName(name1_, value1_);
216
217 // The event will be signaled when the mock observer is notified.
218 done_event_.TimedWait(test_timeout_);
219 }
220
TEST_F(WebDataServiceAutofillTest,FormFillRemoveMany)221 TEST_F(WebDataServiceAutofillTest, FormFillRemoveMany) {
222 TimeDelta one_day(TimeDelta::FromDays(1));
223 Time t = Time::Now();
224
225 EXPECT_CALL(*observer_helper_->observer(), Observe(_, _, _)).
226 WillOnce(SignalEvent(&done_event_));
227 std::vector<webkit_glue::FormField> form_fields;
228 AppendFormField(name1_, value1_, &form_fields);
229 AppendFormField(name2_, value2_, &form_fields);
230 wds_->AddFormFields(form_fields);
231
232 // The event will be signaled when the mock observer is notified.
233 done_event_.TimedWait(test_timeout_);
234
235 // This will verify that the correct notification is triggered,
236 // passing the correct list of autofill keys in the details.
237 const AutofillChange expected_changes[] = {
238 AutofillChange(AutofillChange::REMOVE, AutofillKey(name1_, value1_)),
239 AutofillChange(AutofillChange::REMOVE, AutofillKey(name2_, value2_))
240 };
241 EXPECT_CALL(
242 *observer_helper_->observer(),
243 Observe(NotificationType(NotificationType::AUTOFILL_ENTRIES_CHANGED),
244 Source<WebDataService>(wds_.get()),
245 Property(&Details<const AutofillChangeList>::ptr,
246 Pointee(ElementsAreArray(expected_changes))))).
247 WillOnce(SignalEvent(&done_event_));
248 wds_->RemoveFormElementsAddedBetween(t, t + one_day);
249
250 // The event will be signaled when the mock observer is notified.
251 done_event_.TimedWait(test_timeout_);
252 }
253
TEST_F(WebDataServiceAutofillTest,ProfileAdd)254 TEST_F(WebDataServiceAutofillTest, ProfileAdd) {
255 AutofillProfile profile;
256
257 // Check that GUID-based notification was sent.
258 const AutofillProfileChange expected_change(
259 AutofillProfileChange::ADD, profile.guid(), &profile);
260 EXPECT_CALL(
261 *observer_helper_->observer(),
262 Observe(NotificationType(NotificationType::AUTOFILL_PROFILE_CHANGED),
263 Source<WebDataService>(wds_.get()),
264 Property(&Details<const AutofillProfileChange>::ptr,
265 Pointee(expected_change)))).
266 WillOnce(SignalEvent(&done_event_));
267
268 wds_->AddAutofillProfile(profile);
269 done_event_.TimedWait(test_timeout_);
270
271 // Check that it was added.
272 AutofillWebDataServiceConsumer<std::vector<AutofillProfile*> > consumer;
273 WebDataService::Handle handle = wds_->GetAutofillProfiles(&consumer);
274 MessageLoop::current()->Run();
275 EXPECT_EQ(handle, consumer.handle());
276 ASSERT_EQ(1U, consumer.result().size());
277 EXPECT_EQ(profile, *consumer.result()[0]);
278 STLDeleteElements(&consumer.result());
279 }
280
TEST_F(WebDataServiceAutofillTest,ProfileRemove)281 TEST_F(WebDataServiceAutofillTest, ProfileRemove) {
282 AutofillProfile profile;
283
284 // Add a profile.
285 EXPECT_CALL(*observer_helper_->observer(), Observe(_, _, _)).
286 Times(1).
287 WillOnce(SignalEvent(&done_event_));
288 wds_->AddAutofillProfile(profile);
289 done_event_.TimedWait(test_timeout_);
290
291 // Check that it was added.
292 AutofillWebDataServiceConsumer<std::vector<AutofillProfile*> > consumer;
293 WebDataService::Handle handle = wds_->GetAutofillProfiles(&consumer);
294 MessageLoop::current()->Run();
295 EXPECT_EQ(handle, consumer.handle());
296 ASSERT_EQ(1U, consumer.result().size());
297 EXPECT_EQ(profile, *consumer.result()[0]);
298 STLDeleteElements(&consumer.result());
299
300 // Check that GUID-based notification was sent.
301 const AutofillProfileChange expected_change(
302 AutofillProfileChange::REMOVE, profile.guid(), NULL);
303 EXPECT_CALL(
304 *observer_helper_->observer(),
305 Observe(NotificationType(NotificationType::AUTOFILL_PROFILE_CHANGED),
306 Source<WebDataService>(wds_.get()),
307 Property(&Details<const AutofillProfileChange>::ptr,
308 Pointee(expected_change)))).
309 WillOnce(SignalEvent(&done_event_));
310
311 // Remove the profile.
312 wds_->RemoveAutofillProfile(profile.guid());
313 done_event_.TimedWait(test_timeout_);
314
315 // Check that it was removed.
316 AutofillWebDataServiceConsumer<std::vector<AutofillProfile*> > consumer2;
317 WebDataService::Handle handle2 = wds_->GetAutofillProfiles(&consumer2);
318 MessageLoop::current()->Run();
319 EXPECT_EQ(handle2, consumer2.handle());
320 ASSERT_EQ(0U, consumer2.result().size());
321 }
322
TEST_F(WebDataServiceAutofillTest,ProfileUpdate)323 TEST_F(WebDataServiceAutofillTest, ProfileUpdate) {
324 AutofillProfile profile1;
325 profile1.SetInfo(NAME_FIRST, ASCIIToUTF16("Abe"));
326 AutofillProfile profile2;
327 profile2.SetInfo(NAME_FIRST, ASCIIToUTF16("Alice"));
328
329 EXPECT_CALL(*observer_helper_->observer(), Observe(_, _, _)).
330 WillOnce(DoDefault()).
331 WillOnce(SignalEvent(&done_event_));
332 wds_->AddAutofillProfile(profile1);
333 wds_->AddAutofillProfile(profile2);
334 done_event_.TimedWait(test_timeout_);
335
336 // Check that they were added.
337 AutofillWebDataServiceConsumer<std::vector<AutofillProfile*> > consumer;
338 WebDataService::Handle handle = wds_->GetAutofillProfiles(&consumer);
339 MessageLoop::current()->Run();
340 EXPECT_EQ(handle, consumer.handle());
341 ASSERT_EQ(2U, consumer.result().size());
342 EXPECT_EQ(profile1, *consumer.result()[0]);
343 EXPECT_EQ(profile2, *consumer.result()[1]);
344 STLDeleteElements(&consumer.result());
345
346 AutofillProfile profile1_changed(profile1);
347 profile1_changed.SetInfo(NAME_FIRST, ASCIIToUTF16("Bill"));
348 const AutofillProfileChange expected_change(
349 AutofillProfileChange::UPDATE, profile1.guid(), &profile1_changed);
350
351 EXPECT_CALL(
352 *observer_helper_->observer(),
353 Observe(NotificationType(NotificationType::AUTOFILL_PROFILE_CHANGED),
354 Source<WebDataService>(wds_.get()),
355 Property(&Details<const AutofillProfileChange>::ptr,
356 Pointee(expected_change)))).
357 WillOnce(SignalEvent(&done_event_));
358
359 // Update the profile.
360 wds_->UpdateAutofillProfile(profile1_changed);
361 done_event_.TimedWait(test_timeout_);
362
363 // Check that the updates were made.
364 AutofillWebDataServiceConsumer<std::vector<AutofillProfile*> > consumer2;
365 WebDataService::Handle handle2 = wds_->GetAutofillProfiles(&consumer2);
366 MessageLoop::current()->Run();
367 EXPECT_EQ(handle2, consumer2.handle());
368 ASSERT_EQ(2U, consumer2.result().size());
369 EXPECT_NE(profile1, *consumer2.result()[0]);
370 EXPECT_EQ(profile1_changed, *consumer2.result()[0]);
371 EXPECT_EQ(profile2, *consumer2.result()[1]);
372 STLDeleteElements(&consumer2.result());
373 }
374
TEST_F(WebDataServiceAutofillTest,CreditAdd)375 TEST_F(WebDataServiceAutofillTest, CreditAdd) {
376 CreditCard card;
377 const AutofillCreditCardChange expected_change(
378 AutofillCreditCardChange::ADD, card.guid(), &card);
379
380 EXPECT_CALL(
381 *observer_helper_->observer(),
382 Observe(
383 NotificationType(NotificationType::AUTOFILL_CREDIT_CARD_CHANGED),
384 Source<WebDataService>(wds_.get()),
385 Property(&Details<const AutofillCreditCardChange>::ptr,
386 Pointee(expected_change)))).
387 WillOnce(SignalEvent(&done_event_));
388
389 wds_->AddCreditCard(card);
390 done_event_.TimedWait(test_timeout_);
391
392 // Check that it was added.
393 AutofillWebDataServiceConsumer<std::vector<CreditCard*> > consumer;
394 WebDataService::Handle handle = wds_->GetCreditCards(&consumer);
395 MessageLoop::current()->Run();
396 EXPECT_EQ(handle, consumer.handle());
397 ASSERT_EQ(1U, consumer.result().size());
398 EXPECT_EQ(card, *consumer.result()[0]);
399 STLDeleteElements(&consumer.result());
400 }
401
TEST_F(WebDataServiceAutofillTest,CreditCardRemove)402 TEST_F(WebDataServiceAutofillTest, CreditCardRemove) {
403 CreditCard credit_card;
404
405 // Add a credit card.
406 EXPECT_CALL(*observer_helper_->observer(), Observe(_, _, _)).
407 WillOnce(SignalEvent(&done_event_));
408 wds_->AddCreditCard(credit_card);
409 done_event_.TimedWait(test_timeout_);
410
411 // Check that it was added.
412 AutofillWebDataServiceConsumer<std::vector<CreditCard*> > consumer;
413 WebDataService::Handle handle = wds_->GetCreditCards(&consumer);
414 MessageLoop::current()->Run();
415 EXPECT_EQ(handle, consumer.handle());
416 ASSERT_EQ(1U, consumer.result().size());
417 EXPECT_EQ(credit_card, *consumer.result()[0]);
418 STLDeleteElements(&consumer.result());
419
420 // Remove the credit card.
421 const AutofillCreditCardChange expected_change(
422 AutofillCreditCardChange::REMOVE, credit_card.guid(), NULL);
423 EXPECT_CALL(
424 *observer_helper_->observer(),
425 Observe(
426 NotificationType(NotificationType::AUTOFILL_CREDIT_CARD_CHANGED),
427 Source<WebDataService>(wds_.get()),
428 Property(&Details<const AutofillCreditCardChange>::ptr,
429 Pointee(expected_change)))).
430 WillOnce(SignalEvent(&done_event_));
431 wds_->RemoveCreditCard(credit_card.guid());
432 done_event_.TimedWait(test_timeout_);
433
434 // Check that it was removed.
435 AutofillWebDataServiceConsumer<std::vector<CreditCard*> > consumer2;
436 WebDataService::Handle handle2 = wds_->GetCreditCards(&consumer2);
437 MessageLoop::current()->Run();
438 EXPECT_EQ(handle2, consumer2.handle());
439 ASSERT_EQ(0U, consumer2.result().size());
440 }
441
TEST_F(WebDataServiceAutofillTest,CreditUpdate)442 TEST_F(WebDataServiceAutofillTest, CreditUpdate) {
443 CreditCard card1;
444 card1.SetInfo(CREDIT_CARD_NAME, ASCIIToUTF16("Abe"));
445 CreditCard card2;
446 card2.SetInfo(CREDIT_CARD_NAME, ASCIIToUTF16("Alice"));
447
448 EXPECT_CALL(*observer_helper_->observer(), Observe(_, _, _)).
449 Times(2).
450 WillOnce(DoDefault()).
451 WillOnce(SignalEvent(&done_event_));
452 wds_->AddCreditCard(card1);
453 wds_->AddCreditCard(card2);
454 done_event_.TimedWait(test_timeout_);
455
456 // Check that they got added.
457 AutofillWebDataServiceConsumer<std::vector<CreditCard*> > consumer;
458 WebDataService::Handle handle = wds_->GetCreditCards(&consumer);
459 MessageLoop::current()->Run();
460 EXPECT_EQ(handle, consumer.handle());
461 ASSERT_EQ(2U, consumer.result().size());
462 EXPECT_EQ(card1, *consumer.result()[0]);
463 EXPECT_EQ(card2, *consumer.result()[1]);
464 STLDeleteElements(&consumer.result());
465
466 CreditCard card1_changed(card1);
467 card1_changed.SetInfo(CREDIT_CARD_NAME, ASCIIToUTF16("Bill"));
468 const AutofillCreditCardChange expected_change(
469 AutofillCreditCardChange::UPDATE, card1.guid(), &card1_changed);
470
471 EXPECT_CALL(
472 *observer_helper_->observer(),
473 Observe(
474 NotificationType(NotificationType::AUTOFILL_CREDIT_CARD_CHANGED),
475 Source<WebDataService>(wds_.get()),
476 Property(&Details<const AutofillCreditCardChange>::ptr,
477 Pointee(expected_change)))).
478 WillOnce(SignalEvent(&done_event_));
479
480 wds_->UpdateCreditCard(card1_changed);
481 done_event_.TimedWait(test_timeout_);
482
483 // Check that the updates were made.
484 AutofillWebDataServiceConsumer<std::vector<CreditCard*> > consumer2;
485 WebDataService::Handle handle2 = wds_->GetCreditCards(&consumer2);
486 MessageLoop::current()->Run();
487 EXPECT_EQ(handle2, consumer2.handle());
488 ASSERT_EQ(2U, consumer2.result().size());
489 EXPECT_NE(card1, *consumer2.result()[0]);
490 EXPECT_EQ(card1_changed, *consumer2.result()[0]);
491 EXPECT_EQ(card2, *consumer2.result()[1]);
492 STLDeleteElements(&consumer2.result());
493 }
494
TEST_F(WebDataServiceAutofillTest,AutofillRemoveModifiedBetween)495 TEST_F(WebDataServiceAutofillTest, AutofillRemoveModifiedBetween) {
496 // Add a profile.
497 EXPECT_CALL(*observer_helper_->observer(), Observe(_, _, _)).
498 Times(1).
499 WillOnce(SignalEvent(&done_event_));
500 AutofillProfile profile;
501 wds_->AddAutofillProfile(profile);
502 done_event_.TimedWait(test_timeout_);
503
504 // Check that it was added.
505 AutofillWebDataServiceConsumer<std::vector<AutofillProfile*> >
506 profile_consumer;
507 WebDataService::Handle handle = wds_->GetAutofillProfiles(&profile_consumer);
508 MessageLoop::current()->Run();
509 EXPECT_EQ(handle, profile_consumer.handle());
510 ASSERT_EQ(1U, profile_consumer.result().size());
511 EXPECT_EQ(profile, *profile_consumer.result()[0]);
512 STLDeleteElements(&profile_consumer.result());
513
514 // Add a credit card.
515 EXPECT_CALL(*observer_helper_->observer(), Observe(_, _, _)).
516 WillOnce(SignalEvent(&done_event_));
517 CreditCard credit_card;
518 wds_->AddCreditCard(credit_card);
519 done_event_.TimedWait(test_timeout_);
520
521 // Check that it was added.
522 AutofillWebDataServiceConsumer<std::vector<CreditCard*> >
523 card_consumer;
524 handle = wds_->GetCreditCards(&card_consumer);
525 MessageLoop::current()->Run();
526 EXPECT_EQ(handle, card_consumer.handle());
527 ASSERT_EQ(1U, card_consumer.result().size());
528 EXPECT_EQ(credit_card, *card_consumer.result()[0]);
529 STLDeleteElements(&card_consumer.result());
530
531 // Check that GUID-based notification was sent for the profile.
532 const AutofillProfileChange expected_profile_change(
533 AutofillProfileChange::REMOVE, profile.guid(), NULL);
534 EXPECT_CALL(
535 *observer_helper_->observer(),
536 Observe(NotificationType(NotificationType::AUTOFILL_PROFILE_CHANGED),
537 Source<WebDataService>(wds_.get()),
538 Property(&Details<const AutofillProfileChange>::ptr,
539 Pointee(expected_profile_change)))).
540 WillOnce(SignalEvent(&done_event_));
541
542 // Check that GUID-based notification was sent for the credit card.
543 const AutofillCreditCardChange expected_card_change(
544 AutofillCreditCardChange::REMOVE, credit_card.guid(), NULL);
545 EXPECT_CALL(
546 *observer_helper_->observer(),
547 Observe(
548 NotificationType(NotificationType::AUTOFILL_CREDIT_CARD_CHANGED),
549 Source<WebDataService>(wds_.get()),
550 Property(&Details<const AutofillCreditCardChange>::ptr,
551 Pointee(expected_card_change)))).
552 WillOnce(SignalEvent(&done_event_));
553
554 // Remove the profile using time range of "all time".
555 wds_->RemoveAutofillProfilesAndCreditCardsModifiedBetween(Time(), Time());
556 done_event_.TimedWait(test_timeout_);
557 done_event_.TimedWait(test_timeout_);
558
559 // Check that the profile was removed.
560 AutofillWebDataServiceConsumer<std::vector<AutofillProfile*> >
561 profile_consumer2;
562 WebDataService::Handle handle2 =
563 wds_->GetAutofillProfiles(&profile_consumer2);
564 MessageLoop::current()->Run();
565 EXPECT_EQ(handle2, profile_consumer2.handle());
566 ASSERT_EQ(0U, profile_consumer2.result().size());
567
568 // Check that the credit card was removed.
569 AutofillWebDataServiceConsumer<std::vector<CreditCard*> >
570 card_consumer2;
571 handle2 = wds_->GetCreditCards(&card_consumer2);
572 MessageLoop::current()->Run();
573 EXPECT_EQ(handle2, card_consumer2.handle());
574 ASSERT_EQ(0U, card_consumer2.result().size());
575 }
576