OLD | NEW |
1 // Copyright 2014 The Chromium Authors. All rights reserved. | 1 // Copyright 2014 The Chromium Authors. All rights reserved. |
2 // Use of this source code is governed by a BSD-style license that can be | 2 // Use of this source code is governed by a BSD-style license that can be |
3 // found in the LICENSE file. | 3 // found in the LICENSE file. |
4 | 4 |
5 #ifndef COMPONENTS_SYNC_DRIVER_SYNC_API_COMPONENT_FACTORY_H_ | 5 #ifndef COMPONENTS_SYNC_DRIVER_SYNC_API_COMPONENT_FACTORY_H_ |
6 #define COMPONENTS_SYNC_DRIVER_SYNC_API_COMPONENT_FACTORY_H_ | 6 #define COMPONENTS_SYNC_DRIVER_SYNC_API_COMPONENT_FACTORY_H_ |
7 | 7 |
8 #include <memory> | 8 #include <memory> |
9 #include <string> | 9 #include <string> |
10 | 10 |
11 #include "base/memory/weak_ptr.h" | 11 #include "base/memory/weak_ptr.h" |
12 #include "components/sync/api/data_type_error_handler.h" | 12 #include "components/sync/api/data_type_error_handler.h" |
13 #include "components/sync/api/syncable_service.h" | 13 #include "components/sync/api/syncable_service.h" |
14 #include "components/sync/base/model_type.h" | 14 #include "components/sync/base/model_type.h" |
15 #include "components/sync/core/attachments/attachment_service.h" | 15 #include "components/sync/core/attachments/attachment_service.h" |
16 #include "components/sync/driver/data_type_controller.h" | 16 #include "components/sync/driver/data_type_controller.h" |
17 | 17 |
18 namespace base { | 18 namespace base { |
19 class FilePath; | 19 class FilePath; |
20 } // namespace base | 20 } // namespace base |
21 | 21 |
22 namespace browser_sync { | |
23 class SyncBackendHost; | |
24 } // namespace browser_sync | |
25 | |
26 namespace history { | 22 namespace history { |
27 class HistoryBackend; | 23 class HistoryBackend; |
28 } | 24 } |
29 | 25 |
30 namespace invalidation { | 26 namespace invalidation { |
31 class InvalidationService; | 27 class InvalidationService; |
32 } // namespace invalidation | 28 } // namespace invalidation |
33 | 29 |
34 namespace syncer { | 30 namespace syncer { |
35 class DataTypeDebugInfoListener; | |
36 class SyncableService; | |
37 | |
38 struct UserShare; | |
39 } // namespace syncer | |
40 | |
41 namespace sync_driver { | |
42 | 31 |
43 class AssociatorInterface; | 32 class AssociatorInterface; |
44 class ChangeProcessor; | 33 class ChangeProcessor; |
| 34 class DataTypeDebugInfoListener; |
45 class DataTypeEncryptionHandler; | 35 class DataTypeEncryptionHandler; |
46 class DataTypeManager; | 36 class DataTypeManager; |
47 class DataTypeManagerObserver; | 37 class DataTypeManagerObserver; |
48 class DataTypeStatusTable; | 38 class DataTypeStatusTable; |
49 class GenericChangeProcessor; | 39 class GenericChangeProcessor; |
50 class LocalDeviceInfoProvider; | 40 class LocalDeviceInfoProvider; |
| 41 class SyncBackendHost; |
| 42 class SyncClient; |
51 class SyncPrefs; | 43 class SyncPrefs; |
52 class SyncClient; | |
53 class SyncService; | 44 class SyncService; |
| 45 class SyncableService; |
| 46 struct UserShare; |
54 | 47 |
55 // This factory provides sync driver code with the model type specific sync/api | 48 // This factory provides sync driver code with the model type specific sync/api |
56 // service (like SyncableService) implementations. | 49 // service (like SyncableService) implementations. |
57 class SyncApiComponentFactory { | 50 class SyncApiComponentFactory { |
58 public: | 51 public: |
59 virtual ~SyncApiComponentFactory() {} | 52 virtual ~SyncApiComponentFactory() {} |
60 // Callback to allow platform-specific datatypes to register themselves as | 53 // Callback to allow platform-specific datatypes to register themselves as |
61 // data type controllers. | 54 // data type controllers. |
62 // |disabled_types| and |enabled_types| control the disable/enable state of | 55 // |disabled_types| and |enabled_types| control the disable/enable state of |
63 // types that are on or off by default (respectively). | 56 // types that are on or off by default (respectively). |
64 typedef base::Callback<void(sync_driver::SyncService* sync_service, | 57 typedef base::Callback<void(SyncService* sync_service, |
65 syncer::ModelTypeSet disabled_types, | 58 ModelTypeSet disabled_types, |
66 syncer::ModelTypeSet enabled_types)> | 59 ModelTypeSet enabled_types)> |
67 RegisterDataTypesMethod; | 60 RegisterDataTypesMethod; |
68 | 61 |
69 // The various factory methods for the data type model associators | 62 // The various factory methods for the data type model associators |
70 // and change processors all return this struct. This is needed | 63 // and change processors all return this struct. This is needed |
71 // because the change processors typically require a type-specific | 64 // because the change processors typically require a type-specific |
72 // model associator at construction time. | 65 // model associator at construction time. |
73 // | 66 // |
74 // Note: This interface is deprecated in favor of the SyncableService API. | 67 // Note: This interface is deprecated in favor of the SyncableService API. |
75 // New datatypes that do not live on the UI thread should directly return a | 68 // New datatypes that do not live on the UI thread should directly return a |
76 // weak pointer to a syncer::SyncableService. All others continue to return | 69 // weak pointer to a SyncableService. All others continue to return |
77 // SyncComponents. It is safe to assume that the factory methods below are | 70 // SyncComponents. It is safe to assume that the factory methods below are |
78 // called on the same thread in which the datatype resides. | 71 // called on the same thread in which the datatype resides. |
79 // | 72 // |
80 // TODO(zea): Have all datatypes using the new API switch to returning | 73 // TODO(zea): Have all datatypes using the new API switch to returning |
81 // SyncableService weak pointers instead of SyncComponents (crbug.com/100114). | 74 // SyncableService weak pointers instead of SyncComponents (crbug.com/100114). |
82 struct SyncComponents { | 75 struct SyncComponents { |
83 sync_driver::AssociatorInterface* model_associator; | 76 AssociatorInterface* model_associator; |
84 sync_driver::ChangeProcessor* change_processor; | 77 ChangeProcessor* change_processor; |
85 SyncComponents(sync_driver::AssociatorInterface* ma, | 78 SyncComponents(AssociatorInterface* ma, ChangeProcessor* cp) |
86 sync_driver::ChangeProcessor* cp) | |
87 : model_associator(ma), change_processor(cp) {} | 79 : model_associator(ma), change_processor(cp) {} |
88 }; | 80 }; |
89 | 81 |
90 // Creates and registers enabled datatypes with the provided SyncClient. | 82 // Creates and registers enabled datatypes with the provided SyncClient. |
91 virtual void RegisterDataTypes( | 83 virtual void RegisterDataTypes( |
92 sync_driver::SyncService* sync_service, | 84 SyncService* sync_service, |
93 const RegisterDataTypesMethod& register_platform_types_method) = 0; | 85 const RegisterDataTypesMethod& register_platform_types_method) = 0; |
94 | 86 |
95 // Instantiates a new DataTypeManager with a SyncBackendHost, a list of data | 87 // Instantiates a new DataTypeManager with a SyncBackendHost, a list of data |
96 // type controllers and a DataTypeManagerObserver. The return pointer is | 88 // type controllers and a DataTypeManagerObserver. The return pointer is |
97 // owned by the caller. | 89 // owned by the caller. |
98 virtual sync_driver::DataTypeManager* CreateDataTypeManager( | 90 virtual DataTypeManager* CreateDataTypeManager( |
99 const syncer::WeakHandle<syncer::DataTypeDebugInfoListener>& | 91 const WeakHandle<DataTypeDebugInfoListener>& debug_info_listener, |
100 debug_info_listener, | 92 const DataTypeController::TypeMap* controllers, |
101 const sync_driver::DataTypeController::TypeMap* controllers, | 93 const DataTypeEncryptionHandler* encryption_handler, |
102 const sync_driver::DataTypeEncryptionHandler* encryption_handler, | 94 SyncBackendHost* backend, |
103 browser_sync::SyncBackendHost* backend, | 95 DataTypeManagerObserver* observer) = 0; |
104 sync_driver::DataTypeManagerObserver* observer) = 0; | |
105 | 96 |
106 // Creating this in the factory helps us mock it out in testing. | 97 // Creating this in the factory helps us mock it out in testing. |
107 virtual browser_sync::SyncBackendHost* CreateSyncBackendHost( | 98 virtual SyncBackendHost* CreateSyncBackendHost( |
108 const std::string& name, | 99 const std::string& name, |
109 invalidation::InvalidationService* invalidator, | 100 invalidation::InvalidationService* invalidator, |
110 const base::WeakPtr<sync_driver::SyncPrefs>& sync_prefs, | 101 const base::WeakPtr<SyncPrefs>& sync_prefs, |
111 const base::FilePath& sync_folder) = 0; | 102 const base::FilePath& sync_folder) = 0; |
112 | 103 |
113 // Creating this in the factory helps us mock it out in testing. | 104 // Creating this in the factory helps us mock it out in testing. |
114 virtual std::unique_ptr<sync_driver::LocalDeviceInfoProvider> | 105 virtual std::unique_ptr<LocalDeviceInfoProvider> |
115 CreateLocalDeviceInfoProvider() = 0; | 106 CreateLocalDeviceInfoProvider() = 0; |
116 | 107 |
117 // Legacy datatypes that need to be converted to the SyncableService API. | 108 // Legacy datatypes that need to be converted to the SyncableService API. |
118 virtual SyncComponents CreateBookmarkSyncComponents( | 109 virtual SyncComponents CreateBookmarkSyncComponents( |
119 sync_driver::SyncService* sync_service, | 110 SyncService* sync_service, |
120 std::unique_ptr<syncer::DataTypeErrorHandler> error_handler) = 0; | 111 std::unique_ptr<DataTypeErrorHandler> error_handler) = 0; |
121 | 112 |
122 // Creates attachment service. | 113 // Creates attachment service. |
123 // Note: Should only be called from the model type thread. | 114 // Note: Should only be called from the model type thread. |
124 // | 115 // |
125 // |store_birthday| is the store birthday. Must not be empty. | 116 // |store_birthday| is the store birthday. Must not be empty. |
126 // | 117 // |
127 // |model_type| is the model type this AttachmentService will be used with. | 118 // |model_type| is the model type this AttachmentService will be used with. |
128 // | 119 // |
129 // |delegate| is optional delegate for AttachmentService to notify about | 120 // |delegate| is optional delegate for AttachmentService to notify about |
130 // asynchronous events (AttachmentUploaded). Pass NULL if delegate is not | 121 // asynchronous events (AttachmentUploaded). Pass NULL if delegate is not |
131 // provided. AttachmentService doesn't take ownership of delegate, the pointer | 122 // provided. AttachmentService doesn't take ownership of delegate, the pointer |
132 // must be valid throughout AttachmentService lifetime. | 123 // must be valid throughout AttachmentService lifetime. |
133 virtual std::unique_ptr<syncer::AttachmentService> CreateAttachmentService( | 124 virtual std::unique_ptr<AttachmentService> CreateAttachmentService( |
134 std::unique_ptr<syncer::AttachmentStoreForSync> attachment_store, | 125 std::unique_ptr<AttachmentStoreForSync> attachment_store, |
135 const syncer::UserShare& user_share, | 126 const UserShare& user_share, |
136 const std::string& store_birthday, | 127 const std::string& store_birthday, |
137 syncer::ModelType model_type, | 128 ModelType model_type, |
138 syncer::AttachmentService::Delegate* delegate) = 0; | 129 AttachmentService::Delegate* delegate) = 0; |
139 }; | 130 }; |
140 | 131 |
141 } // namespace sync_driver | 132 } // namespace syncer |
142 | 133 |
143 #endif // COMPONENTS_SYNC_DRIVER_SYNC_API_COMPONENT_FACTORY_H_ | 134 #endif // COMPONENTS_SYNC_DRIVER_SYNC_API_COMPONENT_FACTORY_H_ |
OLD | NEW |