1 // Copyright (c) 2012 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/profile_sync_components_factory_impl.h"
6
7 #include <utility>
8
9 #include "base/bind.h"
10 #include "base/feature_list.h"
11 #include "base/memory/ref_counted.h"
12 #include "base/task/task_traits.h"
13 #include "base/task/thread_pool.h"
14 #include "build/build_config.h"
15 #include "components/autofill/core/browser/payments/autofill_wallet_model_type_controller.h"
16 #include "components/autofill/core/browser/webdata/autocomplete_sync_bridge.h"
17 #include "components/autofill/core/browser/webdata/autofill_profile_model_type_controller.h"
18 #include "components/autofill/core/browser/webdata/autofill_profile_sync_bridge.h"
19 #include "components/autofill/core/browser/webdata/autofill_wallet_metadata_sync_bridge.h"
20 #include "components/autofill/core/browser/webdata/autofill_wallet_offer_sync_bridge.h"
21 #include "components/autofill/core/browser/webdata/autofill_wallet_sync_bridge.h"
22 #include "components/autofill/core/browser/webdata/autofill_webdata_service.h"
23 #include "components/browser_sync/active_devices_provider_impl.h"
24 #include "components/browser_sync/browser_sync_client.h"
25 #include "components/history/core/browser/sync/history_delete_directives_model_type_controller.h"
26 #include "components/history/core/browser/sync/typed_url_model_type_controller.h"
27 #include "components/password_manager/core/browser/password_store.h"
28 #include "components/password_manager/core/browser/sync/password_model_type_controller.h"
29 #include "components/prefs/pref_service.h"
30 #include "components/reading_list/features/reading_list_switches.h"
31 #include "components/send_tab_to_self/features.h"
32 #include "components/send_tab_to_self/send_tab_to_self_model_type_controller.h"
33 #include "components/send_tab_to_self/send_tab_to_self_sync_service.h"
34 #include "components/sync/base/legacy_directory_deletion.h"
35 #include "components/sync/base/report_unrecoverable_error.h"
36 #include "components/sync/base/sync_base_switches.h"
37 #include "components/sync/driver/data_type_manager_impl.h"
38 #include "components/sync/driver/glue/sync_engine_impl.h"
39 #include "components/sync/driver/model_type_controller.h"
40 #include "components/sync/driver/sync_driver_switches.h"
41 #include "components/sync/driver/syncable_service_based_model_type_controller.h"
42 #include "components/sync/engine/sync_engine.h"
43 #include "components/sync/invalidations/sync_invalidations_service.h"
44 #include "components/sync/model/model_type_store_service.h"
45 #include "components/sync/model_impl/forwarding_model_type_controller_delegate.h"
46 #include "components/sync/model_impl/proxy_model_type_controller_delegate.h"
47 #include "components/sync_bookmarks/bookmark_sync_service.h"
48 #include "components/sync_device_info/device_info_sync_service.h"
49 #include "components/sync_preferences/pref_service_syncable.h"
50 #include "components/sync_sessions/proxy_tabs_data_type_controller.h"
51 #include "components/sync_sessions/session_model_type_controller.h"
52 #include "components/sync_sessions/session_sync_service.h"
53 #include "components/sync_user_events/user_event_model_type_controller.h"
54
55 #if defined(OS_CHROMEOS)
56 #include "chromeos/constants/chromeos_features.h"
57 #endif
58
59 using syncer::DataTypeController;
60 using syncer::DataTypeManager;
61 using syncer::DataTypeManagerImpl;
62 using syncer::DataTypeManagerObserver;
63 using syncer::ModelTypeController;
64 using syncer::SyncableServiceBasedModelTypeController;
65
66 namespace browser_sync {
67
68 namespace {
69
70 // These helper functions only wrap the factory functions of the bridges. This
71 // way, it simplifies life for the compiler which cannot directly cast
72 // "WeakPtr<ModelTypeSyncBridge> (AutofillWebDataService*)" to
73 // "WeakPtr<ModelTypeControllerDelegate> (AutofillWebDataService*)".
74 base::WeakPtr<syncer::ModelTypeControllerDelegate>
AutocompleteDelegateFromDataService(autofill::AutofillWebDataService * service)75 AutocompleteDelegateFromDataService(autofill::AutofillWebDataService* service) {
76 return autofill::AutocompleteSyncBridge::FromWebDataService(service)
77 ->change_processor()
78 ->GetControllerDelegate();
79 }
80
81 base::WeakPtr<syncer::ModelTypeControllerDelegate>
AutofillProfileDelegateFromDataService(autofill::AutofillWebDataService * service)82 AutofillProfileDelegateFromDataService(
83 autofill::AutofillWebDataService* service) {
84 return autofill::AutofillProfileSyncBridge::FromWebDataService(service)
85 ->change_processor()
86 ->GetControllerDelegate();
87 }
88
89 base::WeakPtr<syncer::ModelTypeControllerDelegate>
AutofillWalletDelegateFromDataService(autofill::AutofillWebDataService * service)90 AutofillWalletDelegateFromDataService(
91 autofill::AutofillWebDataService* service) {
92 return autofill::AutofillWalletSyncBridge::FromWebDataService(service)
93 ->change_processor()
94 ->GetControllerDelegate();
95 }
96
97 base::WeakPtr<syncer::ModelTypeControllerDelegate>
AutofillWalletMetadataDelegateFromDataService(autofill::AutofillWebDataService * service)98 AutofillWalletMetadataDelegateFromDataService(
99 autofill::AutofillWebDataService* service) {
100 return autofill::AutofillWalletMetadataSyncBridge::FromWebDataService(service)
101 ->change_processor()
102 ->GetControllerDelegate();
103 }
104
105 base::WeakPtr<syncer::ModelTypeControllerDelegate>
AutofillWalletOfferDelegateFromDataService(autofill::AutofillWebDataService * service)106 AutofillWalletOfferDelegateFromDataService(
107 autofill::AutofillWebDataService* service) {
108 return autofill::AutofillWalletOfferSyncBridge::FromWebDataService(service)
109 ->change_processor()
110 ->GetControllerDelegate();
111 }
112
113 // Helper function that deals will null (e.g. tests, iOS webview).
SyncableServiceForPrefs(sync_preferences::PrefServiceSyncable * prefs_service,syncer::ModelType type)114 base::WeakPtr<syncer::SyncableService> SyncableServiceForPrefs(
115 sync_preferences::PrefServiceSyncable* prefs_service,
116 syncer::ModelType type) {
117 return prefs_service ? prefs_service->GetSyncableService(type)->AsWeakPtr()
118 : nullptr;
119 }
120
121 } // namespace
122
ProfileSyncComponentsFactoryImpl(browser_sync::BrowserSyncClient * sync_client,version_info::Channel channel,const char * history_disabled_pref,const scoped_refptr<base::SequencedTaskRunner> & ui_thread,const scoped_refptr<base::SequencedTaskRunner> & db_thread,const scoped_refptr<autofill::AutofillWebDataService> & web_data_service_on_disk,const scoped_refptr<autofill::AutofillWebDataService> & web_data_service_in_memory,const scoped_refptr<password_manager::PasswordStore> & profile_password_store,const scoped_refptr<password_manager::PasswordStore> & account_password_store,sync_bookmarks::BookmarkSyncService * bookmark_sync_service)123 ProfileSyncComponentsFactoryImpl::ProfileSyncComponentsFactoryImpl(
124 browser_sync::BrowserSyncClient* sync_client,
125 version_info::Channel channel,
126 const char* history_disabled_pref,
127 const scoped_refptr<base::SequencedTaskRunner>& ui_thread,
128 const scoped_refptr<base::SequencedTaskRunner>& db_thread,
129 const scoped_refptr<autofill::AutofillWebDataService>&
130 web_data_service_on_disk,
131 const scoped_refptr<autofill::AutofillWebDataService>&
132 web_data_service_in_memory,
133 const scoped_refptr<password_manager::PasswordStore>&
134 profile_password_store,
135 const scoped_refptr<password_manager::PasswordStore>&
136 account_password_store,
137 sync_bookmarks::BookmarkSyncService* bookmark_sync_service)
138 : sync_client_(sync_client),
139 channel_(channel),
140 history_disabled_pref_(history_disabled_pref),
141 ui_thread_(ui_thread),
142 db_thread_(db_thread),
143 engines_and_directory_deletion_thread_(
144 base::ThreadPool::CreateSequencedTaskRunner(
145 {base::MayBlock(), base::TaskPriority::USER_VISIBLE,
146 base::TaskShutdownBehavior::BLOCK_SHUTDOWN})),
147 web_data_service_on_disk_(web_data_service_on_disk),
148 web_data_service_in_memory_(web_data_service_in_memory),
149 profile_password_store_(profile_password_store),
150 account_password_store_(account_password_store),
151 bookmark_sync_service_(bookmark_sync_service) {
152 DCHECK(sync_client_);
153 }
154
155 ProfileSyncComponentsFactoryImpl::~ProfileSyncComponentsFactoryImpl() = default;
156
157 syncer::DataTypeController::TypeVector
CreateCommonDataTypeControllers(syncer::ModelTypeSet disabled_types,syncer::SyncService * sync_service)158 ProfileSyncComponentsFactoryImpl::CreateCommonDataTypeControllers(
159 syncer::ModelTypeSet disabled_types,
160 syncer::SyncService* sync_service) {
161 syncer::DataTypeController::TypeVector controllers;
162
163 const base::RepeatingClosure dump_stack =
164 base::BindRepeating(&syncer::ReportUnrecoverableError, channel_);
165
166 syncer::ModelTypeStoreService* model_type_store_service =
167 sync_client_->GetModelTypeStoreService();
168 DCHECK(model_type_store_service);
169 syncer::RepeatingModelTypeStoreFactory model_type_store_factory =
170 model_type_store_service->GetStoreFactory();
171
172 // TODO(crbug.com/1005651): Consider using a separate delegate for
173 // transport-only.
174 controllers.push_back(std::make_unique<ModelTypeController>(
175 syncer::DEVICE_INFO,
176 /*delegate_for_full_sync_mode=*/
177 std::make_unique<syncer::ForwardingModelTypeControllerDelegate>(
178 sync_client_->GetDeviceInfoSyncService()
179 ->GetControllerDelegate()
180 .get()),
181 /*delegate_for_transport_mode=*/
182 std::make_unique<syncer::ForwardingModelTypeControllerDelegate>(
183 sync_client_->GetDeviceInfoSyncService()
184 ->GetControllerDelegate()
185 .get())));
186
187 // These features are enabled only if there's a DB thread to post tasks to.
188 if (db_thread_) {
189 // Autocomplete sync is enabled by default. Register unless explicitly
190 // disabled.
191 if (!disabled_types.Has(syncer::AUTOFILL)) {
192 controllers.push_back(std::make_unique<ModelTypeController>(
193 syncer::AUTOFILL,
194 std::make_unique<syncer::ProxyModelTypeControllerDelegate>(
195 db_thread_, base::BindRepeating(
196 &AutocompleteDelegateFromDataService,
197 base::RetainedRef(web_data_service_on_disk_)))));
198 }
199
200 // Autofill sync is enabled by default. Register unless explicitly
201 // disabled.
202 if (!disabled_types.Has(syncer::AUTOFILL_PROFILE)) {
203 controllers.push_back(
204 std::make_unique<AutofillProfileModelTypeController>(
205 std::make_unique<syncer::ProxyModelTypeControllerDelegate>(
206 db_thread_,
207 base::BindRepeating(
208 &AutofillProfileDelegateFromDataService,
209 base::RetainedRef(web_data_service_on_disk_))),
210 sync_client_->GetPrefService(), sync_service));
211 }
212
213 // Wallet data sync is enabled by default. Register unless explicitly
214 // disabled.
215 if (!disabled_types.Has(syncer::AUTOFILL_WALLET_DATA)) {
216 controllers.push_back(CreateWalletModelTypeControllerWithInMemorySupport(
217 syncer::AUTOFILL_WALLET_DATA,
218 base::BindRepeating(&AutofillWalletDelegateFromDataService),
219 sync_service));
220 }
221
222 // Wallet metadata sync depends on Wallet data sync. Register if neither
223 // Wallet data nor Wallet metadata sync is explicitly disabled.
224 if (!disabled_types.Has(syncer::AUTOFILL_WALLET_DATA) &&
225 !disabled_types.Has(syncer::AUTOFILL_WALLET_METADATA)) {
226 controllers.push_back(CreateWalletModelTypeController(
227 syncer::AUTOFILL_WALLET_METADATA,
228 base::BindRepeating(&AutofillWalletMetadataDelegateFromDataService),
229 sync_service));
230 }
231
232 // Wallet offer data is enabled by default. Register unless explicitly
233 // disabled.
234 // TODO(crbug.com/1112095): Currently the offer data depends on Wallet data
235 // sync, but revisit after other offer types are implemented.
236 if (base::FeatureList::IsEnabled(switches::kSyncAutofillWalletOfferData) &&
237 !disabled_types.Has(syncer::AUTOFILL_WALLET_DATA) &&
238 !disabled_types.Has(syncer::AUTOFILL_WALLET_OFFER)) {
239 controllers.push_back(CreateWalletModelTypeController(
240 syncer::AUTOFILL_WALLET_OFFER,
241 base::BindRepeating(&AutofillWalletOfferDelegateFromDataService),
242 sync_service));
243 }
244 }
245
246 // Bookmark sync is enabled by default. Register unless explicitly
247 // disabled.
248 if (!disabled_types.Has(syncer::BOOKMARKS)) {
249 favicon::FaviconService* favicon_service =
250 sync_client_->GetFaviconService();
251 // Services can be null in tests.
252 if (bookmark_sync_service_ && favicon_service) {
253 controllers.push_back(std::make_unique<ModelTypeController>(
254 syncer::BOOKMARKS,
255 std::make_unique<syncer::ForwardingModelTypeControllerDelegate>(
256 bookmark_sync_service_
257 ->GetBookmarkSyncControllerDelegate(favicon_service)
258 .get())));
259 }
260 }
261
262 // These features are enabled only if history is not disabled.
263 if (!sync_client_->GetPrefService()->GetBoolean(history_disabled_pref_)) {
264 // TypedUrl sync is enabled by default. Register unless explicitly
265 // disabled.
266 if (!disabled_types.Has(syncer::TYPED_URLS)) {
267 // TypedURLModelTypeController uses a proxy delegate internally, as
268 // provided by HistoryService.
269 controllers.push_back(
270 std::make_unique<history::TypedURLModelTypeController>(
271 sync_client_->GetHistoryService(), sync_client_->GetPrefService(),
272 history_disabled_pref_));
273 }
274
275 // Delete directive sync is enabled by default.
276 if (!disabled_types.Has(syncer::HISTORY_DELETE_DIRECTIVES)) {
277 controllers.push_back(
278 std::make_unique<history::HistoryDeleteDirectivesModelTypeController>(
279 dump_stack, sync_service,
280 sync_client_->GetModelTypeStoreService(),
281 sync_client_->GetHistoryService()));
282 }
283
284 // Session sync is enabled by default. This is disabled if history is
285 // disabled because the tab sync data is added to the web history on the
286 // server.
287 if (!disabled_types.Has(syncer::PROXY_TABS)) {
288 controllers.push_back(
289 std::make_unique<sync_sessions::ProxyTabsDataTypeController>(
290 base::BindRepeating(
291 &sync_sessions::SessionSyncService::ProxyTabsStateChanged,
292 base::Unretained(sync_client_->GetSessionSyncService()))));
293 controllers.push_back(
294 std::make_unique<sync_sessions::SessionModelTypeController>(
295 sync_service, sync_client_->GetPrefService(),
296 std::make_unique<syncer::ForwardingModelTypeControllerDelegate>(
297 sync_client_->GetSessionSyncService()
298 ->GetControllerDelegate()
299 .get()),
300 history_disabled_pref_));
301 }
302 }
303
304 // Password sync is enabled by default. Register unless explicitly
305 // disabled.
306 if (!disabled_types.Has(syncer::PASSWORDS)) {
307 if (profile_password_store_) {
308 // |profile_password_store_| can be null in tests.
309 controllers.push_back(
310 std::make_unique<password_manager::PasswordModelTypeController>(
311 profile_password_store_->CreateSyncControllerDelegate(),
312 account_password_store_
313 ? account_password_store_->CreateSyncControllerDelegate()
314 : nullptr,
315 account_password_store_, sync_client_->GetPrefService(),
316 sync_client_->GetIdentityManager(), sync_service,
317 sync_client_->GetPasswordStateChangedCallback()));
318 }
319 }
320
321 if (!disabled_types.Has(syncer::PREFERENCES)) {
322 controllers.push_back(
323 std::make_unique<SyncableServiceBasedModelTypeController>(
324 syncer::PREFERENCES,
325 sync_client_->GetModelTypeStoreService()->GetStoreFactory(),
326 SyncableServiceForPrefs(sync_client_->GetPrefServiceSyncable(),
327 syncer::PREFERENCES),
328 dump_stack));
329 }
330
331 if (!disabled_types.Has(syncer::PRIORITY_PREFERENCES)) {
332 controllers.push_back(
333 std::make_unique<SyncableServiceBasedModelTypeController>(
334 syncer::PRIORITY_PREFERENCES,
335 sync_client_->GetModelTypeStoreService()->GetStoreFactory(),
336 SyncableServiceForPrefs(sync_client_->GetPrefServiceSyncable(),
337 syncer::PRIORITY_PREFERENCES),
338 dump_stack));
339 }
340
341 #if defined(OS_CHROMEOS)
342 // When SplitSettingsSync is enabled the controller is created in
343 // ChromeSyncClient.
344 if (!disabled_types.Has(syncer::PRINTERS) &&
345 !chromeos::features::IsSplitSettingsSyncEnabled()) {
346 controllers.push_back(
347 CreateModelTypeControllerForModelRunningOnUIThread(syncer::PRINTERS));
348 }
349 #endif // defined(OS_CHROMEOS)
350
351 // Reading list sync is enabled by default only on iOS. Register unless
352 // Reading List or Reading List Sync is explicitly disabled.
353 if (!disabled_types.Has(syncer::READING_LIST) &&
354 reading_list::switches::IsReadingListEnabled()) {
355 controllers.push_back(CreateModelTypeControllerForModelRunningOnUIThread(
356 syncer::READING_LIST));
357 }
358
359 if (!disabled_types.Has(syncer::USER_EVENTS)) {
360 controllers.push_back(
361 std::make_unique<syncer::UserEventModelTypeController>(
362 sync_service,
363 CreateForwardingControllerDelegate(syncer::USER_EVENTS)));
364 }
365
366 if (!disabled_types.Has(syncer::SEND_TAB_TO_SELF)) {
367 syncer::ModelTypeControllerDelegate* delegate =
368 sync_client_->GetSendTabToSelfSyncService()
369 ->GetControllerDelegate()
370 .get();
371 controllers.push_back(
372 std::make_unique<send_tab_to_self::SendTabToSelfModelTypeController>(
373 sync_service,
374 /*delegate_for_full_sync_mode=*/
375 std::make_unique<syncer::ForwardingModelTypeControllerDelegate>(
376 delegate),
377 /*delegate_for_transport_mode=*/
378 base::FeatureList::IsEnabled(
379 send_tab_to_self::kSendTabToSelfWhenSignedIn)
380 ? std::make_unique<
381 syncer::ForwardingModelTypeControllerDelegate>(delegate)
382 : nullptr));
383 }
384
385 if (!disabled_types.Has(syncer::USER_CONSENTS)) {
386 // Forward both full-sync and transport-only modes to the same delegate,
387 // since behavior for USER_CONSENTS does not differ (they are always
388 // persisted).
389 controllers.push_back(std::make_unique<ModelTypeController>(
390 syncer::USER_CONSENTS,
391 /*delegate_for_full_sync_mode=*/
392 CreateForwardingControllerDelegate(syncer::USER_CONSENTS),
393 /*delegate_for_transport_mode=*/
394 CreateForwardingControllerDelegate(syncer::USER_CONSENTS)));
395 }
396
397 return controllers;
398 }
399
400 std::unique_ptr<DataTypeManager>
CreateDataTypeManager(syncer::ModelTypeSet initial_types,const syncer::WeakHandle<syncer::DataTypeDebugInfoListener> & debug_info_listener,const DataTypeController::TypeMap * controllers,const syncer::DataTypeEncryptionHandler * encryption_handler,syncer::ModelTypeConfigurer * configurer,DataTypeManagerObserver * observer)401 ProfileSyncComponentsFactoryImpl::CreateDataTypeManager(
402 syncer::ModelTypeSet initial_types,
403 const syncer::WeakHandle<syncer::DataTypeDebugInfoListener>&
404 debug_info_listener,
405 const DataTypeController::TypeMap* controllers,
406 const syncer::DataTypeEncryptionHandler* encryption_handler,
407 syncer::ModelTypeConfigurer* configurer,
408 DataTypeManagerObserver* observer) {
409 return std::make_unique<DataTypeManagerImpl>(
410 initial_types, debug_info_listener, controllers, encryption_handler,
411 configurer, observer);
412 }
413
414 std::unique_ptr<syncer::SyncEngine>
CreateSyncEngine(const std::string & name,invalidation::InvalidationService * invalidator,syncer::SyncInvalidationsService * sync_invalidation_service,const base::WeakPtr<syncer::SyncPrefs> & sync_prefs)415 ProfileSyncComponentsFactoryImpl::CreateSyncEngine(
416 const std::string& name,
417 invalidation::InvalidationService* invalidator,
418 syncer::SyncInvalidationsService* sync_invalidation_service,
419 const base::WeakPtr<syncer::SyncPrefs>& sync_prefs) {
420 return std::make_unique<syncer::SyncEngineImpl>(
421 name, invalidator, sync_invalidation_service,
422 std::make_unique<browser_sync::ActiveDevicesProviderImpl>(
423 sync_client_->GetDeviceInfoSyncService()->GetDeviceInfoTracker(),
424 base::DefaultClock::GetInstance()),
425 sync_prefs, sync_client_->GetModelTypeStoreService()->GetSyncDataPath(),
426 engines_and_directory_deletion_thread_);
427 }
428
429 void ProfileSyncComponentsFactoryImpl::
DeleteLegacyDirectoryFilesAndNigoriStorage()430 DeleteLegacyDirectoryFilesAndNigoriStorage() {
431 engines_and_directory_deletion_thread_->PostTask(
432 FROM_HERE,
433 base::BindOnce(
434 &syncer::DeleteLegacyDirectoryFilesAndNigoriStorage,
435 sync_client_->GetModelTypeStoreService()->GetSyncDataPath()));
436 }
437
438 std::unique_ptr<syncer::ModelTypeControllerDelegate>
CreateForwardingControllerDelegate(syncer::ModelType type)439 ProfileSyncComponentsFactoryImpl::CreateForwardingControllerDelegate(
440 syncer::ModelType type) {
441 return std::make_unique<syncer::ForwardingModelTypeControllerDelegate>(
442 sync_client_->GetControllerDelegateForModelType(type).get());
443 }
444
445 std::unique_ptr<ModelTypeController> ProfileSyncComponentsFactoryImpl::
CreateModelTypeControllerForModelRunningOnUIThread(syncer::ModelType type)446 CreateModelTypeControllerForModelRunningOnUIThread(syncer::ModelType type) {
447 return std::make_unique<ModelTypeController>(
448 type, CreateForwardingControllerDelegate(type));
449 }
450
451 std::unique_ptr<ModelTypeController>
CreateWalletModelTypeController(syncer::ModelType type,const base::RepeatingCallback<base::WeakPtr<syncer::ModelTypeControllerDelegate> (autofill::AutofillWebDataService *)> & delegate_from_web_data,syncer::SyncService * sync_service)452 ProfileSyncComponentsFactoryImpl::CreateWalletModelTypeController(
453 syncer::ModelType type,
454 const base::RepeatingCallback<
455 base::WeakPtr<syncer::ModelTypeControllerDelegate>(
456 autofill::AutofillWebDataService*)>& delegate_from_web_data,
457 syncer::SyncService* sync_service) {
458 return std::make_unique<AutofillWalletModelTypeController>(
459 type,
460 std::make_unique<syncer::ProxyModelTypeControllerDelegate>(
461 db_thread_,
462 base::BindRepeating(delegate_from_web_data,
463 base::RetainedRef(web_data_service_on_disk_))),
464 sync_client_->GetPrefService(), sync_service);
465 }
466
467 std::unique_ptr<ModelTypeController> ProfileSyncComponentsFactoryImpl::
CreateWalletModelTypeControllerWithInMemorySupport(syncer::ModelType type,const base::RepeatingCallback<base::WeakPtr<syncer::ModelTypeControllerDelegate> (autofill::AutofillWebDataService *)> & delegate_from_web_data,syncer::SyncService * sync_service)468 CreateWalletModelTypeControllerWithInMemorySupport(
469 syncer::ModelType type,
470 const base::RepeatingCallback<
471 base::WeakPtr<syncer::ModelTypeControllerDelegate>(
472 autofill::AutofillWebDataService*)>& delegate_from_web_data,
473 syncer::SyncService* sync_service) {
474 return std::make_unique<AutofillWalletModelTypeController>(
475 type, /*delegate_for_full_sync_mode=*/
476 std::make_unique<syncer::ProxyModelTypeControllerDelegate>(
477 db_thread_,
478 base::BindRepeating(delegate_from_web_data,
479 base::RetainedRef(web_data_service_on_disk_))),
480 /*delegate_for_transport_mode=*/
481 std::make_unique<syncer::ProxyModelTypeControllerDelegate>(
482 db_thread_,
483 base::BindRepeating(delegate_from_web_data,
484 base::RetainedRef(web_data_service_in_memory_))),
485 sync_client_->GetPrefService(), sync_service);
486 }
487
488 } // namespace browser_sync
489