Refactor notifications of chrome/browser/webdata

chrome/browser/sync/profile_sync_service_autofill_unittest.cc

 // Copyright 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include <set>
 #include <string>
 #include <vector>
 
 #include "testing/gtest/include/gtest/gtest.h"
 
@@ skipping 26 matching lines @@
 #include "chrome/browser/sync/test_profile_sync_service.h"
 #include "chrome/browser/webdata/autocomplete_syncable_service.h"
 #include "chrome/browser/webdata/autofill_change.h"
 #include "chrome/browser/webdata/autofill_entry.h"
 #include "chrome/browser/webdata/autofill_profile_syncable_service.h"
 #include "chrome/browser/webdata/autofill_table.h"
 #include "chrome/browser/webdata/autofill_web_data_service.h"
 #include "chrome/browser/webdata/web_data_service_factory.h"
 #include "chrome/browser/webdata/web_data_service_test_util.h"
 #include "chrome/browser/webdata/web_database.h"
-#include "chrome/common/chrome_notification_types.h"
 #include "components/autofill/browser/autofill_common_test.h"
 #include "components/autofill/browser/personal_data_manager.h"
-#include "content/public/browser/notification_source.h"
 #include "content/public/test/test_browser_thread.h"
 #include "google_apis/gaia/gaia_constants.h"
 #include "sync/internal_api/public/base/model_type.h"
 #include "sync/internal_api/public/read_node.h"
 #include "sync/internal_api/public/read_transaction.h"
 #include "sync/internal_api/public/write_node.h"
 #include "sync/internal_api/public/write_transaction.h"
 #include "sync/protocol/autofill_specifics.pb.h"
 #include "sync/syncable/mutable_entry.h"
 #include "sync/syncable/syncable_write_transaction.h"
@@ skipping 25 matching lines @@
 using testing::ElementsAre;
 using testing::SetArgumentPointee;
 using testing::Return;
 
 namespace syncable {
 class Id;
 }
 
 class HistoryService;
 
+namespace {
+
+void RunAndSignal(const base::Closure& cb, WaitableEvent* event) {
+  cb.Run();
+  event->Signal();
+}
+
+}  // namespace
+
 class AutofillTableMock : public AutofillTable {
  public:
   AutofillTableMock() : AutofillTable() {}
   MOCK_METHOD2(RemoveFormElement,
                bool(const string16& name, const string16& value));  // NOLINT
   MOCK_METHOD1(GetAllAutofillEntries,
                bool(std::vector<AutofillEntry>* entries));  // NOLINT
   MOCK_METHOD3(GetAutofillTimestamps,
                bool(const string16& name,  // NOLINT
                     const string16& value,
@@ skipping 62 matching lines @@
 
  private:
   virtual ~TokenWebDataServiceFake() {}
 
   DISALLOW_COPY_AND_ASSIGN(TokenWebDataServiceFake);
 };
 
 class WebDataServiceFake : public AutofillWebDataService {
  public:
   WebDataServiceFake()
-      : AutofillWebDataService(
-            NULL, WebDataServiceBase::ProfileErrorCallback()),
+      : AutofillWebDataService(NULL,
+                               WebDataServiceBase::ProfileErrorCallback()),
         web_database_(NULL),
+        autocomplete_syncable_service_(NULL),
+        autofill_profile_syncable_service_(NULL),
         syncable_service_created_or_destroyed_(false, false) {
   }
 
   void SetDatabase(WebDatabase* web_database) {
     web_database_ = web_database;
   }
 
   void StartSyncableService() {
     // The |autofill_profile_syncable_service_| must be constructed on the DB
     // thread.
@@ skipping 15 matching lines @@
   virtual bool IsDatabaseLoaded() OVERRIDE {
     return true;
   }
 
   virtual WebDatabase* GetDatabase() OVERRIDE {
     return web_database_;
   }
 
   virtual void ShutdownOnUIThread() OVERRIDE {}
 
+  void OnAutofillEntriesChanged(const AutofillChangeList& changes) {
+    WaitableEvent event(true, false);
+
+    base::Closure notify_cb =
+        base::Bind(&AutocompleteSyncableService::AutofillEntriesChanged,
+                   base::Unretained(autocomplete_syncable_service_),
+                   changes);
+    BrowserThread::PostTask(
+        BrowserThread::DB,
+        FROM_HERE,
+        base::Bind(&RunAndSignal, notify_cb, &event));
+    event.Wait();
+  }
+
+  void OnAutofillProfileChanged(const AutofillProfileChange& changes) {
+    WaitableEvent event(true, false);
+
+    base::Closure notify_cb =
+        base::Bind(&AutocompleteSyncableService::AutofillProfileChanged,
+                   base::Unretained(autofill_profile_syncable_service_),
+                   changes);
+    BrowserThread::PostTask(
+        BrowserThread::DB,
+        FROM_HERE,
+        base::Bind(&RunAndSignal, notify_cb, &event));
+    event.Wait();
+  }
+
  private:
   virtual ~WebDataServiceFake() {}
 
   void CreateSyncableService() {
     ASSERT_TRUE(BrowserThread::CurrentlyOn(BrowserThread::DB));
     // These services are deleted in DestroySyncableService().
     AutocompleteSyncableService::CreateForWebDataService(this);
     AutofillProfileSyncableService::CreateForWebDataService(this);
+
+    autocomplete_syncable_service_ =
+        AutocompleteSyncableService::FromWebDataService(this);
+    autofill_profile_syncable_service_ =
+        AutofillProfileSyncableService::FromWebDataService(this);
+
     syncable_service_created_or_destroyed_.Signal();
   }
 
   void DestroySyncableService() {
     ASSERT_TRUE(BrowserThread::CurrentlyOn(BrowserThread::DB));
     WebDataServiceBase::ShutdownOnDBThread();
+    autocomplete_syncable_service_ = NULL;
+    autofill_profile_syncable_service_ = NULL;
     syncable_service_created_or_destroyed_.Signal();
   }
 
   WebDatabase* web_database_;
+  AutocompleteSyncableService* autocomplete_syncable_service_;
+  AutofillProfileSyncableService* autofill_profile_syncable_service_;
 
   WaitableEvent syncable_service_created_or_destroyed_;
 
   DISALLOW_COPY_AND_ASSIGN(WebDataServiceFake);
 };
 
 ProfileKeyedService* BuildMockWebDataServiceWrapper(Profile* profile) {
   return new MockWebDataServiceWrapper(
       new TokenWebDataServiceFake(),
       new WebDataServiceFake());
@@ skipping 100 matching lines @@
   MOCK_METHOD0(LoadCreditCards, void());
   MOCK_METHOD0(Refresh, void());
 };
 
 class MockPersonalDataManagerService : public PersonalDataManagerService {
  public:
   static ProfileKeyedService* Build(Profile* profile) {
     return new MockPersonalDataManagerService();
   }
 
-  MockPersonalDataManagerService() {}
+  MockPersonalDataManagerService() {
+    personal_data_manager_.reset(new MockPersonalDataManager());
+  }
   virtual ~MockPersonalDataManagerService() {}
 
+  virtual void Shutdown() OVERRIDE {
+    personal_data_manager_.reset();
+  }
+
   virtual MockPersonalDataManager* GetPersonalDataManager() OVERRIDE {
-    return &personal_data_manager_;
+    return personal_data_manager_.get();
   }
 
  private:
-  MockPersonalDataManager personal_data_manager_;
+  scoped_ptr<MockPersonalDataManager> personal_data_manager_;
   DISALLOW_COPY_AND_ASSIGN(MockPersonalDataManagerService);
 };
 
 template <class T> class AddAutofillHelper;
 
 class ProfileSyncServiceAutofillTest
    : public AbstractProfileSyncServiceTest,
      public syncer::DataTypeDebugInfoListener {
  public:
   // DataTypeDebugInfoListener implementation.
@@ skipping 47 matching lines @@
         personal_data_manager_service->GetPersonalDataManager();
 
     token_service_ = static_cast<TokenService*>(
         TokenServiceFactory::GetInstance()->SetTestingFactoryAndUse(
             profile_.get(), BuildTokenService));
     EXPECT_CALL(*personal_data_manager_, LoadProfiles()).Times(1);
     EXPECT_CALL(*personal_data_manager_, LoadCreditCards()).Times(1);
 
     personal_data_manager_->Init(profile_.get());
 
-    // Note: This must be called *after* the notification service is created.
     web_data_service_->StartSyncableService();
   }
 
   virtual void TearDown() OVERRIDE {
     // Note: The tear down order is important.
     ProfileSyncServiceFactory::GetInstance()->SetTestingFactory(
         profile_.get(), NULL);
     web_data_service_->ShutdownSyncableService();
     profile_->ResetRequestContext();
     // To prevent a leak, fully release TestURLRequestContext to ensure its
@@ skipping 681 matching lines @@
   ASSERT_TRUE(create_root.success());
 
   AutofillEntry added_entry(MakeAutofillEntry("added", "entry", 1));
   std::vector<base::Time> timestamps(added_entry.timestamps());
 
   EXPECT_CALL(autofill_table_, GetAutofillTimestamps(_, _, _)).
       WillOnce(DoAll(SetArgumentPointee<2>(timestamps), Return(true)));
 
   AutofillChangeList changes;
   changes.push_back(AutofillChange(AutofillChange::ADD, added_entry.key()));
-  scoped_refptr<ThreadNotifier> notifier(new ThreadNotifier(
-      db_thread_.DeprecatedGetThreadObject()));
-  notifier->Notify(chrome::NOTIFICATION_AUTOFILL_ENTRIES_CHANGED,
-                   content::Source<AutofillWebDataService>(
-                        web_data_service_.get()),
-                   content::Details<AutofillChangeList>(&changes));
+
+  web_data_service_->OnAutofillEntriesChanged(changes);
 
   std::vector<AutofillEntry> new_sync_entries;
   std::vector<AutofillProfile> new_sync_profiles;
   ASSERT_TRUE(GetAutofillEntriesFromSyncDB(&new_sync_entries,
                                            &new_sync_profiles));
   ASSERT_EQ(1U, new_sync_entries.size());
   EXPECT_TRUE(added_entry == new_sync_entries[0]);
 }
 
 TEST_F(ProfileSyncServiceAutofillTest, ProcessUserChangeAddProfile) {
   EXPECT_CALL(autofill_table_, GetAutofillProfiles(_)).WillOnce(Return(true));
   EXPECT_CALL(*personal_data_manager_, Refresh());
   SetIdleChangeProcessorExpectations();
   CreateRootHelper create_root(this, syncer::AUTOFILL_PROFILE);
   StartSyncService(create_root.callback(), false, syncer::AUTOFILL_PROFILE);
   ASSERT_TRUE(create_root.success());
 
   AutofillProfile added_profile;
   autofill_test::SetProfileInfoWithGuid(&added_profile,
       "D6ADA912-D374-4C0A-917D-F5C8EBE43011", "Josephine", "Alicia", "Saenz",
       "joewayne@me.xyz", "Fox", "1212 Center.", "Bld. 5", "Orlando", "FL",
       "32801", "US", "19482937549");
 
-  AutofillProfileChange change(AutofillProfileChange::ADD,
-      added_profile.guid(), &added_profile);
-  scoped_refptr<ThreadNotifier> notifier(new ThreadNotifier(
-      db_thread_.DeprecatedGetThreadObject()));
-  notifier->Notify(chrome::NOTIFICATION_AUTOFILL_PROFILE_CHANGED,
-                   content::Source<AutofillWebDataService>(
-                        web_data_service_.get()),
-                   content::Details<AutofillProfileChange>(&change));
+  AutofillProfileChange change(
+      AutofillProfileChange::ADD, added_profile.guid(), &added_profile);
+  web_data_service_->OnAutofillProfileChanged(change);
 
   std::vector<AutofillProfile> new_sync_profiles;
   ASSERT_TRUE(GetAutofillProfilesFromSyncDBUnderProfileNode(
       &new_sync_profiles));
   ASSERT_EQ(1U, new_sync_profiles.size());
   EXPECT_EQ(0, added_profile.Compare(new_sync_profiles[0]));
 }
 
 TEST_F(ProfileSyncServiceAutofillTest, ProcessUserChangeUpdateEntry) {
   AutofillEntry original_entry(MakeAutofillEntry("my", "entry", 1));
   std::vector<AutofillEntry> original_entries;
   original_entries.push_back(original_entry);
 
   EXPECT_CALL(autofill_table_, GetAllAutofillEntries(_)).
       WillOnce(DoAll(SetArgumentPointee<0>(original_entries), Return(true)));
   EXPECT_CALL(*personal_data_manager_, Refresh());
   CreateRootHelper create_root(this, syncer::AUTOFILL);
   StartSyncService(create_root.callback(), false, syncer::AUTOFILL);
   ASSERT_TRUE(create_root.success());
 
   AutofillEntry updated_entry(MakeAutofillEntry("my", "entry", 1, 2));
   std::vector<base::Time> timestamps(updated_entry.timestamps());
 
   EXPECT_CALL(autofill_table_, GetAutofillTimestamps(_, _, _)).
       WillOnce(DoAll(SetArgumentPointee<2>(timestamps), Return(true)));
 
   AutofillChangeList changes;
   changes.push_back(AutofillChange(AutofillChange::UPDATE,
                                    updated_entry.key()));
-  scoped_refptr<ThreadNotifier> notifier(new ThreadNotifier(
-      db_thread_.DeprecatedGetThreadObject()));
-  notifier->Notify(chrome::NOTIFICATION_AUTOFILL_ENTRIES_CHANGED,
-                   content::Source<AutofillWebDataService>(
-                        web_data_service_.get()),
-                   content::Details<AutofillChangeList>(&changes));
+  web_data_service_->OnAutofillEntriesChanged(changes);
 
   std::vector<AutofillEntry> new_sync_entries;
   std::vector<AutofillProfile> new_sync_profiles;
   ASSERT_TRUE(GetAutofillEntriesFromSyncDB(&new_sync_entries,
                                            &new_sync_profiles));
   ASSERT_EQ(1U, new_sync_entries.size());
   EXPECT_TRUE(updated_entry == new_sync_entries[0]);
 }
 
 
 TEST_F(ProfileSyncServiceAutofillTest, ProcessUserChangeRemoveEntry) {
   AutofillEntry original_entry(MakeAutofillEntry("my", "entry", 1));
   std::vector<AutofillEntry> original_entries;
   original_entries.push_back(original_entry);
 
   EXPECT_CALL(autofill_table_, GetAllAutofillEntries(_)).
       WillOnce(DoAll(SetArgumentPointee<0>(original_entries), Return(true)));
   EXPECT_CALL(*personal_data_manager_, Refresh());
   CreateRootHelper create_root(this, syncer::AUTOFILL);
   StartSyncService(create_root.callback(), false, syncer::AUTOFILL);
   ASSERT_TRUE(create_root.success());
 
   AutofillChangeList changes;
   changes.push_back(AutofillChange(AutofillChange::REMOVE,
                                    original_entry.key()));
-  scoped_refptr<ThreadNotifier> notifier(new ThreadNotifier(
-      db_thread_.DeprecatedGetThreadObject()));
-  notifier->Notify(chrome::NOTIFICATION_AUTOFILL_ENTRIES_CHANGED,
-                   content::Source<AutofillWebDataService>(
-                        web_data_service_.get()),
-                   content::Details<AutofillChangeList>(&changes));
+  web_data_service_->OnAutofillEntriesChanged(changes);
 
   std::vector<AutofillEntry> new_sync_entries;
   std::vector<AutofillProfile> new_sync_profiles;
   ASSERT_TRUE(GetAutofillEntriesFromSyncDB(&new_sync_entries,
                                            &new_sync_profiles));
   ASSERT_EQ(0U, new_sync_entries.size());
 }
 
 TEST_F(ProfileSyncServiceAutofillTest, ProcessUserChangeRemoveProfile) {
   AutofillProfile sync_profile;
@@ skipping 12 matching lines @@
   EXPECT_CALL(autofill_table_, GetAutofillProfiles(_)).
       WillOnce(DoAll(SetArgumentPointee<0>(native_profiles), Return(true)));
 
   std::vector<AutofillProfile> sync_profiles;
   sync_profiles.push_back(sync_profile);
   AddAutofillHelper<AutofillProfile> add_autofill(this, sync_profiles);
   EXPECT_CALL(*personal_data_manager_, Refresh());
   StartSyncService(add_autofill.callback(), false, syncer::AUTOFILL_PROFILE);
   ASSERT_TRUE(add_autofill.success());
 
-  AutofillProfileChange change(AutofillProfileChange::REMOVE,
-                               sync_profile.guid(), NULL);
-  scoped_refptr<ThreadNotifier> notifier(new ThreadNotifier(
-      db_thread_.DeprecatedGetThreadObject()));
-  notifier->Notify(chrome::NOTIFICATION_AUTOFILL_PROFILE_CHANGED,
-                   content::Source<AutofillWebDataService>(
-                        web_data_service_.get()),
-                   content::Details<AutofillProfileChange>(&change));
+  AutofillProfileChange change(
+      AutofillProfileChange::REMOVE, sync_profile.guid(), NULL);
+  web_data_service_->OnAutofillProfileChanged(change);
 
   std::vector<AutofillProfile> new_sync_profiles;
   ASSERT_TRUE(GetAutofillProfilesFromSyncDBUnderProfileNode(
       &new_sync_profiles));
   ASSERT_EQ(0U, new_sync_profiles.size());
 }
 
 // http://crbug.com/57884
 TEST_F(ProfileSyncServiceAutofillTest, DISABLED_ServerChangeRace) {
   // Once for MergeDataAndStartSyncing() and twice for ProcessSyncChanges(), via
@@ skipping 35 matching lines @@
   std::vector<AutofillEntry> sync_entries;
   std::vector<AutofillProfile> sync_profiles;
   ASSERT_TRUE(GetAutofillEntriesFromSyncDB(&sync_entries, &sync_profiles));
   EXPECT_EQ(3U, sync_entries.size());
   EXPECT_EQ(0U, sync_profiles.size());
   for (size_t i = 0; i < sync_entries.size(); i++) {
     DVLOG(1) << "Entry " << i << ": " << sync_entries[i].key().name()
              << ", " << sync_entries[i].key().value();
   }
 }