1 // Copyright 2013 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.
5 #ifndef CHROME_BROWSER_SYNC_GLUE_SYNC_BACKEND_HOST_CORE_H_
6 #define CHROME_BROWSER_SYNC_GLUE_SYNC_BACKEND_HOST_CORE_H_
8 #include "base/memory/ref_counted.h"
10 #include "base/timer/timer.h"
11 #include "chrome/browser/sync/glue/sync_backend_host_impl.h"
12 #include "components/sync_driver/system_encryptor.h"
13 #include "sync/internal_api/public/base/cancelation_signal.h"
14 #include "sync/internal_api/public/sessions/type_debug_info_observer.h"
15 #include "sync/internal_api/public/shutdown_reason.h"
16 #include "sync/internal_api/public/sync_encryption_handler.h"
19 namespace browser_sync {
21 class SyncBackendHostImpl;
23 // Utility struct for holding initialization options.
24 struct DoInitializeOptions {
26 base::MessageLoop* sync_loop,
27 SyncBackendRegistrar* registrar,
28 const syncer::ModelSafeRoutingInfo& routing_info,
29 const std::vector<scoped_refptr<syncer::ModelSafeWorker> >& workers,
30 const scoped_refptr<syncer::ExtensionsActivity>& extensions_activity,
31 const syncer::WeakHandle<syncer::JsEventHandler>& event_handler,
32 const GURL& service_url,
33 scoped_ptr<syncer::HttpPostProviderFactory> http_bridge_factory,
34 const syncer::SyncCredentials& credentials,
35 const std::string& invalidator_client_id,
36 scoped_ptr<syncer::SyncManagerFactory> sync_manager_factory,
37 bool delete_sync_data_folder,
38 const std::string& restored_key_for_bootstrapping,
39 const std::string& restored_keystore_key_for_bootstrapping,
40 scoped_ptr<syncer::InternalComponentsFactory> internal_components_factory,
41 scoped_ptr<syncer::UnrecoverableErrorHandler> unrecoverable_error_handler,
42 syncer::ReportUnrecoverableErrorFunction
43 report_unrecoverable_error_function);
44 ~DoInitializeOptions();
46 base::MessageLoop* sync_loop;
47 SyncBackendRegistrar* registrar;
48 syncer::ModelSafeRoutingInfo routing_info;
49 std::vector<scoped_refptr<syncer::ModelSafeWorker> > workers;
50 scoped_refptr<syncer::ExtensionsActivity> extensions_activity;
51 syncer::WeakHandle<syncer::JsEventHandler> event_handler;
53 // Overridden by tests.
54 scoped_ptr<syncer::HttpPostProviderFactory> http_bridge_factory;
55 syncer::SyncCredentials credentials;
56 const std::string invalidator_client_id;
57 scoped_ptr<syncer::SyncManagerFactory> sync_manager_factory;
59 bool delete_sync_data_folder;
60 std::string restored_key_for_bootstrapping;
61 std::string restored_keystore_key_for_bootstrapping;
62 scoped_ptr<syncer::InternalComponentsFactory> internal_components_factory;
63 scoped_ptr<syncer::UnrecoverableErrorHandler> unrecoverable_error_handler;
64 syncer::ReportUnrecoverableErrorFunction
65 report_unrecoverable_error_function;
68 // Helper struct to handle currying params to
69 // SyncBackendHost::Core::DoConfigureSyncer.
70 struct DoConfigureSyncerTypes {
71 DoConfigureSyncerTypes();
72 ~DoConfigureSyncerTypes();
73 syncer::ModelTypeSet to_download;
74 syncer::ModelTypeSet to_purge;
75 syncer::ModelTypeSet to_journal;
76 syncer::ModelTypeSet to_unapply;
79 class SyncBackendHostCore
80 : public base::RefCountedThreadSafe<SyncBackendHostCore>,
81 public syncer::SyncEncryptionHandler::Observer,
82 public syncer::SyncManager::Observer,
83 public syncer::TypeDebugInfoObserver {
85 SyncBackendHostCore(const std::string& name,
86 const base::FilePath& sync_data_folder_path,
87 bool has_sync_setup_completed,
88 const base::WeakPtr<SyncBackendHostImpl>& backend);
90 // SyncManager::Observer implementation. The Core just acts like an air
91 // traffic controller here, forwarding incoming messages to appropriate
93 virtual void OnSyncCycleCompleted(
94 const syncer::sessions::SyncSessionSnapshot& snapshot) OVERRIDE;
95 virtual void OnInitializationComplete(
96 const syncer::WeakHandle<syncer::JsBackend>& js_backend,
97 const syncer::WeakHandle<syncer::DataTypeDebugInfoListener>&
100 syncer::ModelTypeSet restored_types) OVERRIDE;
101 virtual void OnConnectionStatusChange(
102 syncer::ConnectionStatus status) OVERRIDE;
103 virtual void OnActionableError(
104 const syncer::SyncProtocolError& sync_error) OVERRIDE;
105 virtual void OnMigrationRequested(syncer::ModelTypeSet types) OVERRIDE;
106 virtual void OnProtocolEvent(const syncer::ProtocolEvent& event) OVERRIDE;
108 // SyncEncryptionHandler::Observer implementation.
109 virtual void OnPassphraseRequired(
110 syncer::PassphraseRequiredReason reason,
111 const sync_pb::EncryptedData& pending_keys) OVERRIDE;
112 virtual void OnPassphraseAccepted() OVERRIDE;
113 virtual void OnBootstrapTokenUpdated(
114 const std::string& bootstrap_token,
115 syncer::BootstrapTokenType type) OVERRIDE;
116 virtual void OnEncryptedTypesChanged(
117 syncer::ModelTypeSet encrypted_types,
118 bool encrypt_everything) OVERRIDE;
119 virtual void OnEncryptionComplete() OVERRIDE;
120 virtual void OnCryptographerStateChanged(
121 syncer::Cryptographer* cryptographer) OVERRIDE;
122 virtual void OnPassphraseTypeChanged(syncer::PassphraseType type,
123 base::Time passphrase_time) OVERRIDE;
125 // TypeDebugInfoObserver implementation
126 virtual void OnCommitCountersUpdated(
127 syncer::ModelType type,
128 const syncer::CommitCounters& counters) OVERRIDE;
129 virtual void OnUpdateCountersUpdated(
130 syncer::ModelType type,
131 const syncer::UpdateCounters& counters) OVERRIDE;
132 virtual void OnStatusCountersUpdated(
133 syncer::ModelType type,
134 const syncer::StatusCounters& counters) OVERRIDE;
136 // Forwards an invalidation state change to the sync manager.
137 void DoOnInvalidatorStateChange(syncer::InvalidatorState state);
139 // Forwards an invalidation to the sync manager.
140 void DoOnIncomingInvalidation(
141 const syncer::ObjectIdInvalidationMap& invalidation_map);
145 // The Do* methods are the various entry points from our
146 // SyncBackendHost. They are all called on the sync thread to
147 // actually perform synchronous (and potentially blocking) syncapi
150 // Called to perform initialization of the syncapi on behalf of
151 // SyncBackendHost::Initialize.
152 void DoInitialize(scoped_ptr<DoInitializeOptions> options);
154 // Called to perform credential update on behalf of
155 // SyncBackendHost::UpdateCredentials.
156 void DoUpdateCredentials(const syncer::SyncCredentials& credentials);
158 // Called to tell the syncapi to start syncing (generally after
159 // initialization and authentication).
160 void DoStartSyncing(const syncer::ModelSafeRoutingInfo& routing_info);
162 // Called to set the passphrase for encryption.
163 void DoSetEncryptionPassphrase(const std::string& passphrase,
166 // Called to decrypt the pending keys.
167 void DoSetDecryptionPassphrase(const std::string& passphrase);
169 // Called to turn on encryption of all sync data as well as
170 // reencrypt everything.
171 void DoEnableEncryptEverything();
173 // Ask the syncer to check for updates for the specified types.
174 void DoRefreshTypes(syncer::ModelTypeSet types);
176 // Invoked if we failed to download the necessary control types at startup.
177 // Invokes SyncBackendHost::HandleControlTypesDownloadRetry.
178 void OnControlTypesDownloadRetry();
180 // Called to perform tasks which require the control data to be downloaded.
181 // This includes refreshing encryption, etc.
182 void DoInitialProcessControlTypes();
184 // The shutdown order is a bit complicated:
185 // 1) Call ShutdownOnUIThread() from |frontend_loop_| to request sync manager
186 // to stop as soon as possible.
187 // 2) Post DoShutdown() to sync loop to clean up backend state, save
188 // directory and destroy sync manager.
189 void ShutdownOnUIThread();
190 void DoShutdown(syncer::ShutdownReason reason);
191 void DoDestroySyncManager(syncer::ShutdownReason reason);
193 // Configuration methods that must execute on sync loop.
194 void DoConfigureSyncer(
195 syncer::ConfigureReason reason,
196 const DoConfigureSyncerTypes& config_types,
197 const syncer::ModelSafeRoutingInfo routing_info,
198 const base::Callback<void(syncer::ModelTypeSet,
199 syncer::ModelTypeSet)>& ready_task,
200 const base::Closure& retry_callback);
201 void DoFinishConfigureDataTypes(
202 syncer::ModelTypeSet types_to_config,
203 const base::Callback<void(syncer::ModelTypeSet,
204 syncer::ModelTypeSet)>& ready_task);
205 void DoRetryConfiguration(
206 const base::Closure& retry_callback);
208 // Set the base request context to use when making HTTP calls.
209 // This method will add a reference to the context to persist it
210 // on the IO thread. Must be removed from IO thread.
212 syncer::SyncManager* sync_manager() { return sync_manager_.get(); }
214 void SendBufferedProtocolEventsAndEnableForwarding();
215 void DisableProtocolEventForwarding();
217 // Enables the forwarding of directory type debug counters to the
218 // SyncBackendHost. Also requests that updates to all counters be
219 // emitted right away to initialize any new listeners' states.
220 void EnableDirectoryTypeDebugInfoForwarding();
222 // Disables forwarding of directory type debug counters.
223 void DisableDirectoryTypeDebugInfoForwarding();
225 // Delete the sync data folder to cleanup backend data. Happens the first
226 // time sync is enabled for a user (to prevent accidentally reusing old
227 // sync databases), as well as shutdown when you're no longer syncing.
228 void DeleteSyncDataFolder();
230 // We expose this member because it's required in the construction of the
231 // HttpBridgeFactory.
232 syncer::CancelationSignal* GetRequestContextCancelationSignal() {
233 return &release_request_context_signal_;
236 void GetAllNodesForTypes(
237 syncer::ModelTypeSet types,
238 scoped_refptr<base::SequencedTaskRunner> task_runner,
239 base::Callback<void(const std::vector<syncer::ModelType>& type,
240 ScopedVector<base::ListValue>) > callback);
243 friend class base::RefCountedThreadSafe<SyncBackendHostCore>;
244 friend class SyncBackendHostForProfileSyncTest;
246 virtual ~SyncBackendHostCore();
248 // Invoked when initialization of syncapi is complete and we can start
250 // This must be called from the thread on which SaveChanges is intended to
251 // be run on; the host's |registrar_->sync_thread()|.
252 void StartSavingChanges();
254 // Invoked periodically to tell the syncapi to persist its state
255 // by writing to disk.
256 // This is called from the thread we were created on (which is sync thread),
257 // using a repeating timer that is kicked off as soon as the SyncManager
258 // tells us it completed initialization.
261 // Name used for debugging.
262 const std::string name_;
264 // Path of the folder that stores the sync data files.
265 const base::FilePath sync_data_folder_path_;
267 // Our parent SyncBackendHost.
268 syncer::WeakHandle<SyncBackendHostImpl> host_;
270 // The loop where all the sync backend operations happen.
271 // Non-NULL only between calls to DoInitialize() and ~Core().
272 base::MessageLoop* sync_loop_;
274 // Our parent's registrar (not owned). Non-NULL only between
275 // calls to DoInitialize() and DoShutdown().
276 SyncBackendRegistrar* registrar_;
278 // The timer used to periodically call SaveChanges.
279 scoped_ptr<base::RepeatingTimer<SyncBackendHostCore> > save_changes_timer_;
281 // Our encryptor, which uses Chrome's encryption functions.
282 sync_driver::SystemEncryptor encryptor_;
284 // The top-level syncapi entry point. Lives on the sync thread.
285 scoped_ptr<syncer::SyncManager> sync_manager_;
287 // Temporary holder of sync manager's initialization results. Set by
288 // OnInitializeComplete, and consumed when we pass it via OnBackendInitialized
289 // in the final state of HandleInitializationSuccessOnFrontendLoop.
290 syncer::WeakHandle<syncer::JsBackend> js_backend_;
291 syncer::WeakHandle<syncer::DataTypeDebugInfoListener> debug_info_listener_;
293 // These signals allow us to send requests to shut down the HttpBridgeFactory
294 // and ServerConnectionManager without having to wait for those classes to
295 // finish initializing first.
297 // See comments in SyncBackendHostCore::ShutdownOnUIThread() for more details.
298 syncer::CancelationSignal release_request_context_signal_;
299 syncer::CancelationSignal stop_syncing_signal_;
301 // Matches the value of SyncPref's HasSyncSetupCompleted() flag at init time.
302 // Should not be used for anything except for UMAs and logging.
303 const bool has_sync_setup_completed_;
305 // Set when we've been asked to forward sync protocol events to the frontend.
306 bool forward_protocol_events_;
308 // Set when the forwarding of per-type debug counters is enabled.
309 bool forward_type_info_;
311 base::WeakPtrFactory<SyncBackendHostCore> weak_ptr_factory_;
313 DISALLOW_COPY_AND_ASSIGN(SyncBackendHostCore);
316 } // namespace browser_sync
318 #endif // CHROME_BROWSER_SYNC_GLUE_SYNC_BACKEND_HOST_CORE_H_