The AutofillProfileSyncableService's lifetime should be managed by the WebDataService

chrome/browser/sync/profile_sync_service_autofill_unittest.cc

 // Copyright (c) 2011 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"
 
+#include "base/bind.h"
 #include "base/callback.h"
 #include "base/location.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop.h"
 #include "base/string16.h"
 #include "base/synchronization/waitable_event.h"
 #include "base/task.h"
 #include "base/time.h"
 #include "base/utf_string_conversions.h"
@@ skipping 32 matching lines @@
 #include "content/browser/browser_thread.h"
 #include "content/common/notification_source.h"
 #include "testing/gmock/include/gmock/gmock.h"
 
 using base::Time;
 using base::WaitableEvent;
 using browser_sync::AutofillChangeProcessor;
 using browser_sync::AutofillDataTypeController;
 using browser_sync::AutofillModelAssociator;
 using browser_sync::AutofillProfileDataTypeController;
-using browser_sync::AutofillProfileSyncableService;
 using browser_sync::DataTypeController;
 using browser_sync::GenericChangeProcessor;
 using browser_sync::SyncableServiceAdapter;
 using browser_sync::GROUP_DB;
 using browser_sync::kAutofillTag;
 using browser_sync::SyncBackendHostForProfileSyncTest;
 using browser_sync::UnrecoverableErrorHandler;
 using syncable::CREATE_NEW_UPDATE_ITEM;
 using syncable::AUTOFILL;
 using syncable::BASE_VERSION;
@@ skipping 72 matching lines @@
 }
 
 template<>
 syncable::ModelType GetModelType<AutofillProfile>() {
   return syncable::AUTOFILL_PROFILE;
 }
 
 class WebDataServiceFake : public WebDataService {
  public:
   explicit WebDataServiceFake(WebDatabase* web_database)
-      : web_database_(web_database) {}
+      : web_database_(web_database),
+        syncable_service_created_or_destroyed_(false, false) {
+  }
+
+  void StartSyncableService() {
+    // The |autofill_profile_syncable_service_| must be constructed on the DB
+    // thread.
+    BrowserThread::PostTask(BrowserThread::DB, FROM_HERE,
+        base::Bind(&WebDataServiceFake::CreateSyncableService,
+                   base::Unretained(this)));
+    EXPECT_TRUE(syncable_service_created_or_destroyed_.Wait());
+  }
+
+  void ShutdownSyncableService() {
+    // The |autofill_profile_syncable_service_| must be destructed on the DB
+    // thread.
+    BrowserThread::PostTask(BrowserThread::DB, FROM_HERE,
+        base::Bind(&WebDataServiceFake::DestroySyncableService,
+                   base::Unretained(this)));
+    EXPECT_TRUE(syncable_service_created_or_destroyed_.Wait());
+  }
+
   virtual bool IsDatabaseLoaded() {
     return true;
   }
 
   virtual WebDatabase* GetDatabase() {
     return web_database_;
   }
 
+  virtual AutofillProfileSyncableService*
+      GetAutofillProfileSyncableService() const OVERRIDE {
+    return autofill_profile_syncable_service_;

[akalin, 2011/10/11 22:20:12]

add checks for on db thread, non-null service here

[Ilya Sherman, 2011/10/11 22:35:29]

Done.

+  }
+
  private:
+  void CreateSyncableService() {
+    ASSERT_TRUE(BrowserThread::CurrentlyOn(BrowserThread::DB));
+    autofill_profile_syncable_service_ =
+        new AutofillProfileSyncableService(this);
+    syncable_service_created_or_destroyed_.Signal();
+  }
+
+  void DestroySyncableService() {
+    ASSERT_TRUE(BrowserThread::CurrentlyOn(BrowserThread::DB));
+    delete autofill_profile_syncable_service_;
+    syncable_service_created_or_destroyed_.Signal();
+  }
+
   WebDatabase* web_database_;
+
+  // We own the syncable service, but don't use a |scoped_ptr| because the
+  // lifetime must be managed on the DB thread.
+  AutofillProfileSyncableService* autofill_profile_syncable_service_;
+  WaitableEvent syncable_service_created_or_destroyed_;
 };
 
 ACTION_P3(MakeAutofillSyncComponents, service, wd, dtc) {
   EXPECT_TRUE(BrowserThread::CurrentlyOn(BrowserThread::DB));
   if (!BrowserThread::CurrentlyOn(BrowserThread::DB))
     return ProfileSyncFactory::SyncComponents(NULL, NULL);
   AutofillModelAssociator* model_associator =
       new AutofillModelAssociator(service, wd, service->profile());
   AutofillChangeProcessor* change_processor =
       new AutofillChangeProcessor(model_associator, wd,
                                   service->profile(), dtc);
   return ProfileSyncFactory::SyncComponents(model_associator,
                                             change_processor);
 }
 
 ACTION_P3(MakeAutofillProfileSyncComponents, service, wds, dtc) {
   EXPECT_TRUE(BrowserThread::CurrentlyOn(BrowserThread::DB));
   if (!BrowserThread::CurrentlyOn(BrowserThread::DB))
     return ProfileSyncFactory::SyncComponents(NULL, NULL);
   AutofillProfileSyncableService* sync_service =
-      new AutofillProfileSyncableService(wds);
+      wds->GetAutofillProfileSyncableService();
   sync_api::UserShare* user_share = service->GetUserShare();
   GenericChangeProcessor* change_processor =
       new GenericChangeProcessor(sync_service, dtc, user_share);
   SyncableServiceAdapter* sync_service_adapter =
       new SyncableServiceAdapter(syncable::AUTOFILL_PROFILE,
                                  sync_service,
                                  change_processor);
   return ProfileSyncFactory::SyncComponents(sync_service_adapter,
                                             change_processor);
 }
@@ skipping 10 matching lines @@
                               DataTypeController* dtc) = 0;
   virtual ~AbstractAutofillFactory() {}
 };
 
 class AutofillEntryFactory : public AbstractAutofillFactory {
  public:
   browser_sync::AutofillDataTypeController* CreateDataTypeController(
       ProfileSyncFactory* factory,
       ProfileMock* profile,
       ProfileSyncService* service) {
-    return new AutofillDataTypeController(factory,
-        profile);
+    return new AutofillDataTypeController(factory, profile);
   }
 
   void SetExpectation(ProfileSyncFactoryMock* factory,
                       ProfileSyncService* service,
                       WebDataService* wds,
                       DataTypeController* dtc) {
     EXPECT_CALL(*factory, CreateAutofillSyncComponents(_,_,_)).
         WillOnce(MakeAutofillSyncComponents(service, wds->GetDatabase(), dtc));
   }
 };
 
 class AutofillProfileFactory : public AbstractAutofillFactory {
  public:
   browser_sync::AutofillDataTypeController* CreateDataTypeController(
       ProfileSyncFactory* factory,
       ProfileMock* profile,
       ProfileSyncService* service) {
-    return new AutofillProfileDataTypeController(factory,
-        profile);
+    return new AutofillProfileDataTypeController(factory, profile);
   }
 
   void SetExpectation(ProfileSyncFactoryMock* factory,
                       ProfileSyncService* service,
                       WebDataService* wds,
                       DataTypeController* dtc) {
     EXPECT_CALL(*factory, CreateAutofillProfileSyncComponents(_,_,_)).
         WillOnce(MakeAutofillProfileSyncComponents(service, wds, dtc));
   }
 };
 
 class PersonalDataManagerMock: public PersonalDataManager {
  public:
   static ProfileKeyedService* Build(Profile* profile) {
     return new PersonalDataManagerMock;
   }
 
   MOCK_CONST_METHOD0(IsDataLoaded, bool());
   MOCK_METHOD0(LoadProfiles, void());
   MOCK_METHOD0(LoadCreditCards, void());
   MOCK_METHOD0(Refresh, void());
 };
 template <class T> class AddAutofillTask;
 
 class ProfileSyncServiceAutofillTest : public AbstractProfileSyncServiceTest {
  protected:
-  ProfileSyncServiceAutofillTest() {}
+  ProfileSyncServiceAutofillTest() {
+  }
 
   AutofillProfileFactory profile_factory_;
   AutofillEntryFactory entry_factory_;
 
   AbstractAutofillFactory* GetFactory(syncable::ModelType type) {
     if (type == syncable::AUTOFILL) {
       return &entry_factory_;
     } else if (type == syncable::AUTOFILL_PROFILE) {
       return &profile_factory_;
     } else {
@@ skipping 15 matching lines @@
     EXPECT_CALL(profile_, GetWebDataService(_)).
         // TokenService::Initialize
         // AutofillDataTypeController::StartModels()
         // In some tests:
         // AutofillProfileSyncableService::AutofillProfileSyncableService()
         WillRepeatedly(Return(web_data_service_.get()));
     personal_data_manager_->Init(&profile_);
 
     notification_service_ = new ThreadNotificationService(&db_thread_);
     notification_service_->Init();
+
+    // Note: This must be called *after* the notification service is created.
+    web_data_service_->StartSyncableService();
   }
 
   virtual void TearDown() {
+    // Note: The tear down order is important.
     service_.reset();
+    web_data_service_->ShutdownSyncableService();
     notification_service_->TearDown();
     profile_.ResetRequestContext();
     AbstractProfileSyncServiceTest::TearDown();
   }
 
   void StartSyncService(Task* task,
                         bool will_fail_association,
                         syncable::ModelType type) {
     AbstractAutofillFactory* factory = GetFactory(type);
     service_.reset(
@@ skipping 13 matching lines @@
                             web_data_service_.get(),
                             data_type_controller);
 
     EXPECT_CALL(factory_, CreateDataTypeManager(_, _)).
         WillOnce(ReturnNewDataTypeManager());
 
     EXPECT_CALL(*personal_data_manager_, IsDataLoaded()).
         WillRepeatedly(Return(true));
 
      // We need tokens to get the tests going
-    token_service_->IssueAuthTokenForTest(
-        GaiaConstants::kSyncService, "token");
+    token_service_->IssueAuthTokenForTest(GaiaConstants::kSyncService, "token");
 
     EXPECT_CALL(profile_, GetTokenService()).
         WillRepeatedly(Return(token_service_.get()));
 
     service_->RegisterDataTypeController(data_type_controller);
     service_->Initialize();
     MessageLoop::current()->Run();
   }
 
   bool AddAutofillSyncNode(const AutofillEntry& entry) {
     sync_api::WriteTransaction trans(FROM_HERE, service_->GetUserShare());
     sync_api::ReadNode autofill_root(&trans);
     if (!autofill_root.InitByTagLookup(browser_sync::kAutofillTag))
       return false;
 
     sync_api::WriteNode node(&trans);
     std::string tag = AutofillModelAssociator::KeyToTag(entry.key().name(),
                                                         entry.key().value());
     if (!node.InitUniqueByCreation(syncable::AUTOFILL, autofill_root, tag))
       return false;
 
     AutofillChangeProcessor::WriteAutofillEntry(entry, &node);
     return true;
   }
 
   bool AddAutofillSyncNode(const AutofillProfile& profile) {
     sync_api::WriteTransaction trans(FROM_HERE, service_->GetUserShare());
     sync_api::ReadNode autofill_root(&trans);
-    if (!autofill_root.InitByTagLookup(browser_sync::kAutofillProfileTag))
+    if (!autofill_root.InitByTagLookup(kAutofillProfileTag))
       return false;
     sync_api::WriteNode node(&trans);
     std::string tag = profile.guid();
     if (!node.InitUniqueByCreation(syncable::AUTOFILL_PROFILE,
         autofill_root, tag))
       return false;
     sync_pb::EntitySpecifics specifics;
     AutofillProfileSyncableService::WriteAutofillProfile(profile, &specifics);
     sync_pb::AutofillProfileSpecifics* profile_specifics =
         specifics.MutableExtension(sync_pb::autofill_profile);
@@ skipping 35 matching lines @@
       }
       child_id = child_node.GetSuccessorId();
     }
     return true;
   }
 
   bool GetAutofillProfilesFromSyncDBUnderProfileNode(
       std::vector<AutofillProfile>* profiles) {
     sync_api::ReadTransaction trans(FROM_HERE, service_->GetUserShare());
     sync_api::ReadNode autofill_root(&trans);
-    if (!autofill_root.InitByTagLookup(browser_sync::kAutofillProfileTag))
+    if (!autofill_root.InitByTagLookup(kAutofillProfileTag))
       return false;
 
     int64 child_id = autofill_root.GetFirstChildId();
     while (child_id != sync_api::kInvalidId) {
       sync_api::ReadNode child_node(&trans);
       if (!child_node.InitByIdLookup(child_id))
         return false;
 
       const sync_pb::AutofillProfileSpecifics& autofill(
           child_node.GetAutofillProfileSpecifics());
@@ skipping 34 matching lines @@
 
   friend class AddAutofillTask<AutofillEntry>;
   friend class AddAutofillTask<AutofillProfile>;
   friend class FakeServerUpdater;
 
   scoped_refptr<ThreadNotificationService> notification_service_;
 
   ProfileMock profile_;
   AutofillTableMock autofill_table_;
   scoped_ptr<WebDatabaseFake> web_database_;
-  scoped_refptr<WebDataService> web_data_service_;
+  scoped_refptr<WebDataServiceFake> web_data_service_;
   PersonalDataManagerMock* personal_data_manager_;
 };
 
 template <class T>
 class AddAutofillTask : public Task {
  public:
   AddAutofillTask(ProfileSyncServiceAutofillTest* test,
-                         const std::vector<T>& entries)
+                  const std::vector<T>& entries)
       : test_(test), entries_(entries), success_(false) {
   }
 
   virtual void Run() {
     if (!test_->CreateRoot(GetModelType<T>()))
       return;
     for (size_t i = 0; i < entries_.size(); ++i) {
       if (!test_->AddAutofillSyncNode(entries_[i]))
         return;
     }
@@ skipping 595 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++) {
     VLOG(1) << "Entry " << i << ": " << sync_entries[i].key().name()
             << ", " << sync_entries[i].key().value();
   }
 }