diff options
Diffstat (limited to 'components/browser_sync/browser')
| -rw-r--r-- | components/browser_sync/browser/BUILD.gn | 3 | ||||
| -rw-r--r-- | components/browser_sync/browser/profile_sync_test_util.cc | 225 | ||||
| -rw-r--r-- | components/browser_sync/browser/profile_sync_test_util.h | 71 |
3 files changed, 268 insertions, 31 deletions
diff --git a/components/browser_sync/browser/BUILD.gn b/components/browser_sync/browser/BUILD.gn index 683b1fc..d77b676 100644 --- a/components/browser_sync/browser/BUILD.gn +++ b/components/browser_sync/browser/BUILD.gn @@ -95,6 +95,9 @@ source_set("test_support") { ":browser", "//base", "//base/test:test_support", + "//components/history/core/browser:browser", + "//components/invalidation/impl", + "//components/invalidation/impl:test_support", "//components/pref_registry", "//components/signin/core/browser:browser", "//components/signin/core/browser:test_support", diff --git a/components/browser_sync/browser/profile_sync_test_util.cc b/components/browser_sync/browser/profile_sync_test_util.cc index c8c02d5..fd6d916 100644 --- a/components/browser_sync/browser/profile_sync_test_util.cc +++ b/components/browser_sync/browser/profile_sync_test_util.cc @@ -4,11 +4,15 @@ #include "components/browser_sync/browser/profile_sync_test_util.h" +#include "components/history/core/browser/history_model_worker.h" #include "components/pref_registry/pref_registry_syncable.h" #include "components/signin/core/browser/signin_manager_base.h" +#include "components/sync_driver/glue/browser_thread_model_worker.h" +#include "components/sync_driver/glue/ui_model_worker.h" #include "components/sync_driver/signin_manager_wrapper.h" #include "components/sync_driver/sync_prefs.h" #include "net/url_request/url_request_test_util.h" +#include "sync/internal_api/public/engine/passive_model_worker.h" using sync_driver::ClearBrowsingDataCallback; @@ -18,32 +22,75 @@ namespace { class BundleSyncClient : public sync_driver::FakeSyncClient { public: - BundleSyncClient(sync_driver::SyncApiComponentFactory* factory, - PrefService* pref_service, - ClearBrowsingDataCallback clear_browsing_data_callback, - sync_sessions::SyncSessionsClient* sync_sessions_client); + BundleSyncClient( + sync_driver::SyncApiComponentFactory* factory, + PrefService* pref_service, + const ClearBrowsingDataCallback& clear_browsing_data_callback, + sync_sessions::SyncSessionsClient* sync_sessions_client, + autofill::PersonalDataManager* personal_data_manager, + const base::Callback<base::WeakPtr<syncer::SyncableService>( + syncer::ModelType type)>& get_syncable_service_callback, + const base::Callback<sync_driver::SyncService*(void)>& + get_sync_service_callback, + scoped_refptr<base::SingleThreadTaskRunner> db_thread, + scoped_refptr<base::SingleThreadTaskRunner> file_thread, + history::HistoryService* history_service); ~BundleSyncClient() override; PrefService* GetPrefService() override; ClearBrowsingDataCallback GetClearBrowsingDataCallback() override; sync_sessions::SyncSessionsClient* GetSyncSessionsClient() override; + autofill::PersonalDataManager* GetPersonalDataManager() override; + base::WeakPtr<syncer::SyncableService> GetSyncableServiceForType( + syncer::ModelType type) override; + sync_driver::SyncService* GetSyncService() override; + scoped_refptr<syncer::ModelSafeWorker> CreateModelWorkerForGroup( + syncer::ModelSafeGroup group, + syncer::WorkerLoopDestructionObserver* observer) override; + history::HistoryService* GetHistoryService() override; private: PrefService* const pref_service_; const ClearBrowsingDataCallback clear_browsing_data_callback_; sync_sessions::SyncSessionsClient* const sync_sessions_client_; + autofill::PersonalDataManager* const personal_data_manager_; + const base::Callback<base::WeakPtr<syncer::SyncableService>( + syncer::ModelType type)> + get_syncable_service_callback_; + const base::Callback<sync_driver::SyncService*(void)> + get_sync_service_callback_; + // These task runners, if not null, are used in CreateModelWorkerForGroup. + const scoped_refptr<base::SingleThreadTaskRunner> db_thread_; + const scoped_refptr<base::SingleThreadTaskRunner> file_thread_; + history::HistoryService* history_service_; }; BundleSyncClient::BundleSyncClient( sync_driver::SyncApiComponentFactory* factory, PrefService* pref_service, - ClearBrowsingDataCallback clear_browsing_data_callback, - sync_sessions::SyncSessionsClient* sync_sessions_client) + const ClearBrowsingDataCallback& clear_browsing_data_callback, + sync_sessions::SyncSessionsClient* sync_sessions_client, + autofill::PersonalDataManager* personal_data_manager, + const base::Callback<base::WeakPtr<syncer::SyncableService>( + syncer::ModelType type)>& get_syncable_service_callback, + const base::Callback<sync_driver::SyncService*(void)>& + get_sync_service_callback, + scoped_refptr<base::SingleThreadTaskRunner> db_thread, + scoped_refptr<base::SingleThreadTaskRunner> file_thread, + history::HistoryService* history_service) : sync_driver::FakeSyncClient(factory), pref_service_(pref_service), clear_browsing_data_callback_(clear_browsing_data_callback), - sync_sessions_client_(sync_sessions_client) {} + sync_sessions_client_(sync_sessions_client), + personal_data_manager_(personal_data_manager), + get_syncable_service_callback_(get_syncable_service_callback), + get_sync_service_callback_(get_sync_service_callback), + db_thread_(db_thread), + file_thread_(file_thread), + history_service_(history_service) { + DCHECK_EQ(!!db_thread_, !!file_thread_); +} BundleSyncClient::~BundleSyncClient() = default; @@ -59,6 +106,60 @@ sync_sessions::SyncSessionsClient* BundleSyncClient::GetSyncSessionsClient() { return sync_sessions_client_; } +autofill::PersonalDataManager* BundleSyncClient::GetPersonalDataManager() { + return personal_data_manager_; +} + +base::WeakPtr<syncer::SyncableService> +BundleSyncClient::GetSyncableServiceForType(syncer::ModelType type) { + if (get_syncable_service_callback_.is_null()) + return sync_driver::FakeSyncClient::GetSyncableServiceForType(type); + return get_syncable_service_callback_.Run(type); +} + +sync_driver::SyncService* BundleSyncClient::GetSyncService() { + if (get_sync_service_callback_.is_null()) + return sync_driver::FakeSyncClient::GetSyncService(); + return get_sync_service_callback_.Run(); +} + +scoped_refptr<syncer::ModelSafeWorker> +BundleSyncClient::CreateModelWorkerForGroup( + syncer::ModelSafeGroup group, + syncer::WorkerLoopDestructionObserver* observer) { + if (!db_thread_) + return FakeSyncClient::CreateModelWorkerForGroup(group, observer); + DCHECK(file_thread_) << "DB thread was specified but FILE thread was not."; + switch (group) { + case syncer::GROUP_DB: + return new BrowserThreadModelWorker(db_thread_, syncer::GROUP_DB, + observer); + case syncer::GROUP_FILE: + return new BrowserThreadModelWorker(file_thread_, syncer::GROUP_FILE, + observer); + case syncer::GROUP_UI: + return new UIModelWorker(base::ThreadTaskRunnerHandle::Get(), observer); + case syncer::GROUP_PASSIVE: + return new syncer::PassiveModelWorker(observer); + case syncer::GROUP_HISTORY: { + history::HistoryService* history_service = GetHistoryService(); + if (!history_service) + return nullptr; + return new HistoryModelWorker(history_service->AsWeakPtr(), + base::ThreadTaskRunnerHandle::Get(), + observer); + } + default: + return nullptr; + } +} + +history::HistoryService* BundleSyncClient::GetHistoryService() { + if (history_service_) + return history_service_; + return FakeSyncClient::GetHistoryService(); +} + } // namespace void EmptyNetworkTimeUpdate(const base::Time&, @@ -84,37 +185,75 @@ void ProfileSyncServiceBundle::SyncClientBuilder::SetClearBrowsingDataCallback( clear_browsing_data_callback_ = clear_browsing_data_callback; } +void ProfileSyncServiceBundle::SyncClientBuilder::SetPersonalDataManager( + autofill::PersonalDataManager* personal_data_manager) { + personal_data_manager_ = personal_data_manager; +} + +// The client will call this callback to produce the service. +void ProfileSyncServiceBundle::SyncClientBuilder::SetSyncableServiceCallback( + const base::Callback<base::WeakPtr<syncer::SyncableService>( + syncer::ModelType type)>& get_syncable_service_callback) { + get_syncable_service_callback_ = get_syncable_service_callback; +} + +// The client will call this callback to produce the service. +void ProfileSyncServiceBundle::SyncClientBuilder::SetSyncServiceCallback( + const base::Callback<sync_driver::SyncService*(void)>& + get_sync_service_callback) { + get_sync_service_callback_ = get_sync_service_callback; +} + +void ProfileSyncServiceBundle::SyncClientBuilder::SetHistoryService( + history::HistoryService* history_service) { + history_service_ = history_service; +} + scoped_ptr<sync_driver::FakeSyncClient> ProfileSyncServiceBundle::SyncClientBuilder::Build() { return make_scoped_ptr(new BundleSyncClient( bundle_->component_factory(), bundle_->pref_service(), - clear_browsing_data_callback_, bundle_->sync_sessions_client())); + clear_browsing_data_callback_, bundle_->sync_sessions_client(), + personal_data_manager_, get_syncable_service_callback_, + get_sync_service_callback_, + activate_model_creation_ ? bundle_->db_thread() : nullptr, + activate_model_creation_ ? bundle_->file_thread() : nullptr, + history_service_)); } +struct ProfileSyncServiceBundle::ThreadProvider { + public: + ThreadProvider() : worker_pool_owner_(2, "sync test worker pool") { + DCHECK(base::MessageLoop::current()) + << "The test including the bundle also needs to include a MessageLoop"; + } + ~ThreadProvider() = default; + + base::SequencedWorkerPoolOwner worker_pool_owner_; + + private: + DISALLOW_COPY_AND_ASSIGN(ThreadProvider); +}; + ProfileSyncServiceBundle::ProfileSyncServiceBundle() - : worker_pool_owner_(2, "sync test worker pool"), - signin_client_(&pref_service_), -#if defined(OS_CHROMEOS) - signin_manager_(&signin_client_, &account_tracker_), -#else - signin_manager_(&signin_client_, - &auth_service_, - &account_tracker_, - nullptr), -#endif - url_request_context_(new net::TestURLRequestContextGetter( - base::ThreadTaskRunnerHandle::Get())) { - browser_sync::RegisterPrefsForProfileSyncService(pref_service_.registry()); - auth_service_.set_auto_post_fetch_response_on_message_loop(true); - account_tracker_.Initialize(&signin_client_); - signin_manager_.Initialize(&pref_service_); -} + : ProfileSyncServiceBundle(make_scoped_ptr(new ThreadProvider), + nullptr, + nullptr, + nullptr) {} + +ProfileSyncServiceBundle::ProfileSyncServiceBundle( + const scoped_refptr<base::SingleThreadTaskRunner>& db_thread, + const scoped_refptr<base::SingleThreadTaskRunner>& file_thread, + base::SequencedWorkerPool* worker_pool) + : ProfileSyncServiceBundle(nullptr, db_thread, file_thread, worker_pool) {} ProfileSyncServiceBundle::~ProfileSyncServiceBundle() {} ProfileSyncService::InitParams ProfileSyncServiceBundle::CreateBasicInitParams( browser_sync::ProfileSyncServiceStartBehavior start_behavior, scoped_ptr<sync_driver::SyncClient> sync_client) { + DCHECK(worker_pool_); + ProfileSyncService::InitParams init_params; init_params.start_behavior = start_behavior; @@ -128,11 +267,41 @@ ProfileSyncService::InitParams ProfileSyncServiceBundle::CreateBasicInitParams( init_params.url_request_context = url_request_context(); init_params.debug_identifier = "dummyDebugName"; init_params.channel = version_info::Channel::UNKNOWN; - init_params.db_thread = base::ThreadTaskRunnerHandle::Get(); - init_params.file_thread = base::ThreadTaskRunnerHandle::Get(); - init_params.blocking_pool = worker_pool_owner_.pool().get(); + init_params.db_thread = db_thread_; + init_params.file_thread = file_thread_; + init_params.blocking_pool = worker_pool_; return init_params; } +ProfileSyncServiceBundle::ProfileSyncServiceBundle( + scoped_ptr<ThreadProvider> thread_provider, + scoped_refptr<base::SingleThreadTaskRunner> db_thread, + scoped_refptr<base::SingleThreadTaskRunner> file_thread, + base::SequencedWorkerPool* worker_pool) + : thread_provider_(std::move(thread_provider)), + db_thread_(thread_provider_ ? base::ThreadTaskRunnerHandle::Get() + : db_thread), + file_thread_(thread_provider_ ? base::ThreadTaskRunnerHandle::Get() + : file_thread), + worker_pool_(thread_provider_ + ? thread_provider_->worker_pool_owner_.pool().get() + : worker_pool), + signin_client_(&pref_service_), +#if defined(OS_CHROMEOS) + signin_manager_(&signin_client_, &account_tracker_), +#else + signin_manager_(&signin_client_, + &auth_service_, + &account_tracker_, + nullptr), +#endif + url_request_context_(new net::TestURLRequestContextGetter( + base::ThreadTaskRunnerHandle::Get())) { + browser_sync::RegisterPrefsForProfileSyncService(pref_service_.registry()); + auth_service_.set_auto_post_fetch_response_on_message_loop(true); + account_tracker_.Initialize(&signin_client_); + signin_manager_.Initialize(&pref_service_); +} + } // namespace browser_sync diff --git a/components/browser_sync/browser/profile_sync_test_util.h b/components/browser_sync/browser/profile_sync_test_util.h index b6bf4e7..485e7dd 100644 --- a/components/browser_sync/browser/profile_sync_test_util.h +++ b/components/browser_sync/browser/profile_sync_test_util.h @@ -5,12 +5,15 @@ #ifndef COMPONENTS_BROWSER_SYNC_BROWSER_PROFILE_SYNC_TEST_UTIL_H_ #define COMPONENTS_BROWSER_SYNC_BROWSER_PROFILE_SYNC_TEST_UTIL_H_ +#include "base/callback.h" #include "base/macros.h" #include "base/memory/ref_counted.h" #include "base/memory/scoped_ptr.h" +#include "base/message_loop/message_loop.h" #include "base/test/sequenced_worker_pool_owner.h" #include "base/time/time.h" #include "components/browser_sync/browser/profile_sync_service.h" +#include "components/invalidation/impl/fake_invalidation_service.h" #include "components/signin/core/browser/account_tracker_service.h" #include "components/signin/core/browser/fake_profile_oauth2_token_service.h" #include "components/signin/core/browser/fake_signin_manager.h" @@ -25,6 +28,10 @@ class Time; class TimeDelta; } +namespace history { +class HistoryService; +} + namespace net { class URLRequestContextGetter; } @@ -46,7 +53,8 @@ void RegisterPrefsForProfileSyncService( user_prefs::PrefRegistrySyncable* registry); // Aggregate this class to get all necessary support for creating a -// ProfileSyncService in tests. +// ProfileSyncService in tests. The test still needs to have its own +// MessageLoop, though. class ProfileSyncServiceBundle { public: #if defined(OS_CHROMEOS) @@ -55,7 +63,15 @@ class ProfileSyncServiceBundle { typedef FakeSigninManager FakeSigninManagerType; #endif + // Use this if you don't care about threads. ProfileSyncServiceBundle(); + + // Use this to inject threads directly. + ProfileSyncServiceBundle( + const scoped_refptr<base::SingleThreadTaskRunner>& db_thread, + const scoped_refptr<base::SingleThreadTaskRunner>& file_thread, + base::SequencedWorkerPool* worker_pool); + ~ProfileSyncServiceBundle(); // Builders @@ -70,10 +86,28 @@ class ProfileSyncServiceBundle { ~SyncClientBuilder(); - // Set the clear browsing data callback for the client to return. + // Setters for the various additional data for the client to return. void SetClearBrowsingDataCallback( sync_driver::ClearBrowsingDataCallback clear_browsing_data_callback); + void SetPersonalDataManager( + autofill::PersonalDataManager* personal_data_manager); + + // The client will call this callback to produce the SyncableService + // specific to |type|. + void SetSyncableServiceCallback( + const base::Callback<base::WeakPtr<syncer::SyncableService>( + syncer::ModelType type)>& get_syncable_service_callback); + + // The client will call this callback to produce the SyncService for the + // current Profile. + void SetSyncServiceCallback(const base::Callback<sync_driver::SyncService*( + void)>& get_sync_service_callback); + + void SetHistoryService(history::HistoryService* history_service); + + void set_activate_model_creation() { activate_model_creation_ = true; } + scoped_ptr<sync_driver::FakeSyncClient> Build(); private: @@ -81,6 +115,15 @@ class ProfileSyncServiceBundle { ProfileSyncServiceBundle* const bundle_; sync_driver::ClearBrowsingDataCallback clear_browsing_data_callback_; + autofill::PersonalDataManager* personal_data_manager_; + base::Callback<base::WeakPtr<syncer::SyncableService>( + syncer::ModelType type)> + get_syncable_service_callback_; + base::Callback<sync_driver::SyncService*(void)> get_sync_service_callback_; + history::HistoryService* history_service_ = nullptr; + // If set, the built client will be able to build some ModelSafeWorker + // instances. + bool activate_model_creation_ = false; DISALLOW_COPY_AND_ASSIGN(SyncClientBuilder); }; @@ -116,8 +159,29 @@ class ProfileSyncServiceBundle { return &sync_sessions_client_; } + invalidation::FakeInvalidationService* fake_invalidation_service() { + return &fake_invalidation_service_; + } + + base::SingleThreadTaskRunner* db_thread() { return db_thread_.get(); } + + base::SingleThreadTaskRunner* file_thread() { return file_thread_.get(); } + private: - base::SequencedWorkerPoolOwner worker_pool_owner_; + struct ThreadProvider; // Helper to create threads and worker pool. + + // Either |thread_provider| must be null and or the other arguments non-null, + // or vice versa. + ProfileSyncServiceBundle( + scoped_ptr<ThreadProvider> thread_provider, + scoped_refptr<base::SingleThreadTaskRunner> db_thread, + scoped_refptr<base::SingleThreadTaskRunner> file_thread, + base::SequencedWorkerPool* worker_pool); + + scoped_ptr<ThreadProvider> thread_provider_; + const scoped_refptr<base::SingleThreadTaskRunner> db_thread_; + const scoped_refptr<base::SingleThreadTaskRunner> file_thread_; + base::SequencedWorkerPool* const worker_pool_; syncable_prefs::TestingPrefServiceSyncable pref_service_; TestSigninClient signin_client_; AccountTrackerService account_tracker_; @@ -125,6 +189,7 @@ class ProfileSyncServiceBundle { FakeProfileOAuth2TokenService auth_service_; SyncApiComponentFactoryMock component_factory_; sync_sessions::FakeSyncSessionsClient sync_sessions_client_; + invalidation::FakeInvalidationService fake_invalidation_service_; scoped_refptr<net::URLRequestContextGetter> url_request_context_; DISALLOW_COPY_AND_ASSIGN(ProfileSyncServiceBundle); |