OLD | NEW |
| (Empty) |
1 // Copyright 2016 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 "components/browser_sync/browser/profile_sync_test_util.h" | |
6 | |
7 #include "base/memory/ptr_util.h" | |
8 #include "components/bookmarks/browser/bookmark_model.h" | |
9 #include "components/history/core/browser/history_model_worker.h" | |
10 #include "components/pref_registry/pref_registry_syncable.h" | |
11 #include "components/signin/core/browser/signin_manager_base.h" | |
12 #include "components/sync/driver/glue/browser_thread_model_worker.h" | |
13 #include "components/sync/driver/glue/ui_model_worker.h" | |
14 #include "components/sync/driver/signin_manager_wrapper.h" | |
15 #include "components/sync/driver/sync_prefs.h" | |
16 #include "components/sync/engine/passive_model_worker.h" | |
17 #include "net/url_request/url_request_test_util.h" | |
18 | |
19 namespace browser_sync { | |
20 | |
21 namespace { | |
22 | |
23 class BundleSyncClient : public sync_driver::FakeSyncClient { | |
24 public: | |
25 BundleSyncClient( | |
26 sync_driver::SyncApiComponentFactory* factory, | |
27 PrefService* pref_service, | |
28 sync_sessions::SyncSessionsClient* sync_sessions_client, | |
29 autofill::PersonalDataManager* personal_data_manager, | |
30 const base::Callback<base::WeakPtr<syncer::SyncableService>( | |
31 syncer::ModelType type)>& get_syncable_service_callback, | |
32 const base::Callback<sync_driver::SyncService*(void)>& | |
33 get_sync_service_callback, | |
34 const base::Callback<bookmarks::BookmarkModel*(void)>& | |
35 get_bookmark_model_callback, | |
36 scoped_refptr<base::SingleThreadTaskRunner> db_thread, | |
37 scoped_refptr<base::SingleThreadTaskRunner> file_thread, | |
38 history::HistoryService* history_service); | |
39 | |
40 ~BundleSyncClient() override; | |
41 | |
42 PrefService* GetPrefService() override; | |
43 sync_sessions::SyncSessionsClient* GetSyncSessionsClient() override; | |
44 autofill::PersonalDataManager* GetPersonalDataManager() override; | |
45 base::WeakPtr<syncer::SyncableService> GetSyncableServiceForType( | |
46 syncer::ModelType type) override; | |
47 sync_driver::SyncService* GetSyncService() override; | |
48 scoped_refptr<syncer::ModelSafeWorker> CreateModelWorkerForGroup( | |
49 syncer::ModelSafeGroup group, | |
50 syncer::WorkerLoopDestructionObserver* observer) override; | |
51 history::HistoryService* GetHistoryService() override; | |
52 bookmarks::BookmarkModel* GetBookmarkModel() override; | |
53 | |
54 private: | |
55 PrefService* const pref_service_; | |
56 sync_sessions::SyncSessionsClient* const sync_sessions_client_; | |
57 autofill::PersonalDataManager* const personal_data_manager_; | |
58 const base::Callback<base::WeakPtr<syncer::SyncableService>( | |
59 syncer::ModelType type)> | |
60 get_syncable_service_callback_; | |
61 const base::Callback<sync_driver::SyncService*(void)> | |
62 get_sync_service_callback_; | |
63 const base::Callback<bookmarks::BookmarkModel*(void)> | |
64 get_bookmark_model_callback_; | |
65 // These task runners, if not null, are used in CreateModelWorkerForGroup. | |
66 const scoped_refptr<base::SingleThreadTaskRunner> db_thread_; | |
67 const scoped_refptr<base::SingleThreadTaskRunner> file_thread_; | |
68 history::HistoryService* history_service_; | |
69 }; | |
70 | |
71 BundleSyncClient::BundleSyncClient( | |
72 sync_driver::SyncApiComponentFactory* factory, | |
73 PrefService* pref_service, | |
74 sync_sessions::SyncSessionsClient* sync_sessions_client, | |
75 autofill::PersonalDataManager* personal_data_manager, | |
76 const base::Callback<base::WeakPtr<syncer::SyncableService>( | |
77 syncer::ModelType type)>& get_syncable_service_callback, | |
78 const base::Callback<sync_driver::SyncService*(void)>& | |
79 get_sync_service_callback, | |
80 const base::Callback<bookmarks::BookmarkModel*(void)>& | |
81 get_bookmark_model_callback, | |
82 scoped_refptr<base::SingleThreadTaskRunner> db_thread, | |
83 scoped_refptr<base::SingleThreadTaskRunner> file_thread, | |
84 history::HistoryService* history_service) | |
85 : sync_driver::FakeSyncClient(factory), | |
86 pref_service_(pref_service), | |
87 sync_sessions_client_(sync_sessions_client), | |
88 personal_data_manager_(personal_data_manager), | |
89 get_syncable_service_callback_(get_syncable_service_callback), | |
90 get_sync_service_callback_(get_sync_service_callback), | |
91 get_bookmark_model_callback_(get_bookmark_model_callback), | |
92 db_thread_(db_thread), | |
93 file_thread_(file_thread), | |
94 history_service_(history_service) { | |
95 DCHECK_EQ(!!db_thread_, !!file_thread_); | |
96 } | |
97 | |
98 BundleSyncClient::~BundleSyncClient() = default; | |
99 | |
100 PrefService* BundleSyncClient::GetPrefService() { | |
101 return pref_service_; | |
102 } | |
103 | |
104 sync_sessions::SyncSessionsClient* BundleSyncClient::GetSyncSessionsClient() { | |
105 return sync_sessions_client_; | |
106 } | |
107 | |
108 autofill::PersonalDataManager* BundleSyncClient::GetPersonalDataManager() { | |
109 return personal_data_manager_; | |
110 } | |
111 | |
112 base::WeakPtr<syncer::SyncableService> | |
113 BundleSyncClient::GetSyncableServiceForType(syncer::ModelType type) { | |
114 if (get_syncable_service_callback_.is_null()) | |
115 return sync_driver::FakeSyncClient::GetSyncableServiceForType(type); | |
116 return get_syncable_service_callback_.Run(type); | |
117 } | |
118 | |
119 sync_driver::SyncService* BundleSyncClient::GetSyncService() { | |
120 if (get_sync_service_callback_.is_null()) | |
121 return sync_driver::FakeSyncClient::GetSyncService(); | |
122 return get_sync_service_callback_.Run(); | |
123 } | |
124 | |
125 scoped_refptr<syncer::ModelSafeWorker> | |
126 BundleSyncClient::CreateModelWorkerForGroup( | |
127 syncer::ModelSafeGroup group, | |
128 syncer::WorkerLoopDestructionObserver* observer) { | |
129 if (!db_thread_) | |
130 return FakeSyncClient::CreateModelWorkerForGroup(group, observer); | |
131 DCHECK(file_thread_) << "DB thread was specified but FILE thread was not."; | |
132 switch (group) { | |
133 case syncer::GROUP_DB: | |
134 return new BrowserThreadModelWorker(db_thread_, syncer::GROUP_DB, | |
135 observer); | |
136 case syncer::GROUP_FILE: | |
137 return new BrowserThreadModelWorker(file_thread_, syncer::GROUP_FILE, | |
138 observer); | |
139 case syncer::GROUP_UI: | |
140 return new UIModelWorker(base::ThreadTaskRunnerHandle::Get(), observer); | |
141 case syncer::GROUP_PASSIVE: | |
142 return new syncer::PassiveModelWorker(observer); | |
143 case syncer::GROUP_HISTORY: { | |
144 history::HistoryService* history_service = GetHistoryService(); | |
145 if (!history_service) | |
146 return nullptr; | |
147 return new HistoryModelWorker(history_service->AsWeakPtr(), | |
148 base::ThreadTaskRunnerHandle::Get(), | |
149 observer); | |
150 } | |
151 default: | |
152 return nullptr; | |
153 } | |
154 } | |
155 | |
156 history::HistoryService* BundleSyncClient::GetHistoryService() { | |
157 if (history_service_) | |
158 return history_service_; | |
159 return FakeSyncClient::GetHistoryService(); | |
160 } | |
161 | |
162 bookmarks::BookmarkModel* BundleSyncClient::GetBookmarkModel() { | |
163 if (get_bookmark_model_callback_.is_null()) | |
164 return FakeSyncClient::GetBookmarkModel(); | |
165 return get_bookmark_model_callback_.Run(); | |
166 } | |
167 | |
168 } // namespace | |
169 | |
170 void EmptyNetworkTimeUpdate(const base::Time&, | |
171 const base::TimeDelta&, | |
172 const base::TimeDelta&) {} | |
173 | |
174 void RegisterPrefsForProfileSyncService( | |
175 user_prefs::PrefRegistrySyncable* registry) { | |
176 sync_driver::SyncPrefs::RegisterProfilePrefs(registry); | |
177 AccountTrackerService::RegisterPrefs(registry); | |
178 SigninManagerBase::RegisterProfilePrefs(registry); | |
179 SigninManagerBase::RegisterPrefs(registry); | |
180 } | |
181 | |
182 ProfileSyncServiceBundle::SyncClientBuilder::~SyncClientBuilder() = default; | |
183 | |
184 ProfileSyncServiceBundle::SyncClientBuilder::SyncClientBuilder( | |
185 ProfileSyncServiceBundle* bundle) | |
186 : bundle_(bundle) {} | |
187 | |
188 void ProfileSyncServiceBundle::SyncClientBuilder::SetPersonalDataManager( | |
189 autofill::PersonalDataManager* personal_data_manager) { | |
190 personal_data_manager_ = personal_data_manager; | |
191 } | |
192 | |
193 // The client will call this callback to produce the service. | |
194 void ProfileSyncServiceBundle::SyncClientBuilder::SetSyncableServiceCallback( | |
195 const base::Callback<base::WeakPtr<syncer::SyncableService>( | |
196 syncer::ModelType type)>& get_syncable_service_callback) { | |
197 get_syncable_service_callback_ = get_syncable_service_callback; | |
198 } | |
199 | |
200 // The client will call this callback to produce the service. | |
201 void ProfileSyncServiceBundle::SyncClientBuilder::SetSyncServiceCallback( | |
202 const base::Callback<sync_driver::SyncService*(void)>& | |
203 get_sync_service_callback) { | |
204 get_sync_service_callback_ = get_sync_service_callback; | |
205 } | |
206 | |
207 void ProfileSyncServiceBundle::SyncClientBuilder::SetHistoryService( | |
208 history::HistoryService* history_service) { | |
209 history_service_ = history_service; | |
210 } | |
211 | |
212 void ProfileSyncServiceBundle::SyncClientBuilder::SetBookmarkModelCallback( | |
213 const base::Callback<bookmarks::BookmarkModel*(void)>& | |
214 get_bookmark_model_callback) { | |
215 get_bookmark_model_callback_ = get_bookmark_model_callback; | |
216 } | |
217 | |
218 std::unique_ptr<sync_driver::FakeSyncClient> | |
219 ProfileSyncServiceBundle::SyncClientBuilder::Build() { | |
220 return base::MakeUnique<BundleSyncClient>( | |
221 bundle_->component_factory(), bundle_->pref_service(), | |
222 bundle_->sync_sessions_client(), personal_data_manager_, | |
223 get_syncable_service_callback_, get_sync_service_callback_, | |
224 get_bookmark_model_callback_, | |
225 activate_model_creation_ ? bundle_->db_thread() : nullptr, | |
226 activate_model_creation_ ? base::ThreadTaskRunnerHandle::Get() : nullptr, | |
227 history_service_); | |
228 } | |
229 | |
230 ProfileSyncServiceBundle::ProfileSyncServiceBundle() | |
231 : db_thread_(base::ThreadTaskRunnerHandle::Get()), | |
232 worker_pool_owner_(2, "sync test worker pool"), | |
233 signin_client_(&pref_service_), | |
234 #if defined(OS_CHROMEOS) | |
235 signin_manager_(&signin_client_, &account_tracker_), | |
236 #else | |
237 signin_manager_(&signin_client_, | |
238 &auth_service_, | |
239 &account_tracker_, | |
240 nullptr), | |
241 #endif | |
242 url_request_context_(new net::TestURLRequestContextGetter( | |
243 base::ThreadTaskRunnerHandle::Get())) { | |
244 browser_sync::RegisterPrefsForProfileSyncService(pref_service_.registry()); | |
245 auth_service_.set_auto_post_fetch_response_on_message_loop(true); | |
246 account_tracker_.Initialize(&signin_client_); | |
247 signin_manager_.Initialize(&pref_service_); | |
248 } | |
249 | |
250 ProfileSyncServiceBundle::~ProfileSyncServiceBundle() {} | |
251 | |
252 ProfileSyncService::InitParams ProfileSyncServiceBundle::CreateBasicInitParams( | |
253 ProfileSyncService::StartBehavior start_behavior, | |
254 std::unique_ptr<sync_driver::SyncClient> sync_client) { | |
255 ProfileSyncService::InitParams init_params; | |
256 | |
257 init_params.start_behavior = start_behavior; | |
258 init_params.sync_client = std::move(sync_client); | |
259 init_params.signin_wrapper = | |
260 base::MakeUnique<SigninManagerWrapper>(signin_manager()); | |
261 init_params.oauth2_token_service = auth_service(); | |
262 init_params.network_time_update_callback = | |
263 base::Bind(&EmptyNetworkTimeUpdate); | |
264 init_params.base_directory = base::FilePath(FILE_PATH_LITERAL("dummyPath")); | |
265 init_params.url_request_context = url_request_context(); | |
266 init_params.debug_identifier = "dummyDebugName"; | |
267 init_params.channel = version_info::Channel::UNKNOWN; | |
268 init_params.db_thread = db_thread_; | |
269 init_params.file_thread = base::ThreadTaskRunnerHandle::Get(); | |
270 init_params.blocking_pool = worker_pool_owner_.pool().get(); | |
271 | |
272 return init_params; | |
273 } | |
274 | |
275 } // namespace browser_sync | |
OLD | NEW |