Refactor SyncBackendHost

chrome/browser/sync/glue/sync_backend_host_core.h

+// Copyright 2013 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef CHROME_BROWSER_SYNC_GLUE_SYNC_BACKEND_HOST_CORE_H_
+#define CHROME_BROWSER_SYNC_GLUE_SYNC_BACKEND_HOST_CORE_H_
+
+#include "base/memory/ref_counted.h"
+
+#include "base/timer/timer.h"
+#include "chrome/browser/sync/glue/chrome_encryptor.h"
+#include "chrome/browser/sync/glue/sync_backend_host_impl.h"
+#include "sync/internal_api/public/base/cancelation_signal.h"
+#include "sync/internal_api/public/sync_encryption_handler.h"
+#include "url/gurl.h"
+
+namespace browser_sync {
+
+class SyncBackendHostImpl;
+
+// Utility struct for holding initialization options.
+struct DoInitializeOptions {

[Nicolas Zea, 2013/11/06 18:03:21]

can forward declare this I think

[rlarocque, 2013/11/06 21:48:47]

Yes and no.

This could be forward declared, but these definitions need to be put in a .h
file somewhere.  The right solution might be to put it in
do_initialize_options.h.  However, I think these definitions are special.

These structs exist because we've reached the limit of the number of parameters
we can bind to a function.  They're part of an extended function definition.  It
makes sense to have them defined in the same location as the functions they help
define.  That way, the functions that want to call DoInitialize() can get
everything they need (SyncBackendHostCore::DoInitialize and DoInitializeOptions)
just by including this header.

+  DoInitializeOptions(
+      base::MessageLoop* sync_loop,
+      SyncBackendRegistrar* registrar,
+      const syncer::ModelSafeRoutingInfo& routing_info,
+      const std::vector<syncer::ModelSafeWorker*>& workers,
+      const scoped_refptr<syncer::ExtensionsActivity>& extensions_activity,
+      const syncer::WeakHandle<syncer::JsEventHandler>& event_handler,
+      const GURL& service_url,
+      scoped_ptr<syncer::HttpPostProviderFactory> http_bridge_factory,
+      const syncer::SyncCredentials& credentials,
+      const std::string& invalidator_client_id,
+      scoped_ptr<syncer::SyncManagerFactory> sync_manager_factory,
+      bool delete_sync_data_folder,
+      const std::string& restored_key_for_bootstrapping,
+      const std::string& restored_keystore_key_for_bootstrapping,
+      scoped_ptr<syncer::InternalComponentsFactory>
+          internal_components_factory,
+      scoped_ptr<syncer::UnrecoverableErrorHandler>
+          unrecoverable_error_handler,
+      syncer::ReportUnrecoverableErrorFunction
+          report_unrecoverable_error_function);
+  ~DoInitializeOptions();
+
+  base::MessageLoop* sync_loop;
+  SyncBackendRegistrar* registrar;
+  syncer::ModelSafeRoutingInfo routing_info;
+  std::vector<syncer::ModelSafeWorker*> workers;
+  scoped_refptr<syncer::ExtensionsActivity> extensions_activity;
+  syncer::WeakHandle<syncer::JsEventHandler> event_handler;
+  GURL service_url;
+  // Overridden by tests.
+  scoped_ptr<syncer::HttpPostProviderFactory> http_bridge_factory;
+  syncer::SyncCredentials credentials;
+  const std::string invalidator_client_id;
+  scoped_ptr<syncer::SyncManagerFactory> sync_manager_factory;
+  std::string lsid;
+  bool delete_sync_data_folder;
+  std::string restored_key_for_bootstrapping;
+  std::string restored_keystore_key_for_bootstrapping;
+  scoped_ptr<syncer::InternalComponentsFactory> internal_components_factory;
+  scoped_ptr<syncer::UnrecoverableErrorHandler> unrecoverable_error_handler;
+  syncer::ReportUnrecoverableErrorFunction
+      report_unrecoverable_error_function;
+};
+
+// Helper struct to handle currying params to
+// SyncBackendHost::Core::DoConfigureSyncer.
+struct DoConfigureSyncerTypes {

[Nicolas Zea, 2013/11/06 18:03:21]

this too

+  DoConfigureSyncerTypes();
+  ~DoConfigureSyncerTypes();
+  syncer::ModelTypeSet to_download;
+  syncer::ModelTypeSet to_purge;
+  syncer::ModelTypeSet to_journal;
+  syncer::ModelTypeSet to_unapply;
+};
+
+class SyncBackendHostCore
+    : public base::RefCountedThreadSafe<SyncBackendHostCore>,
+      public syncer::SyncEncryptionHandler::Observer,
+      public syncer::SyncManager::Observer {
+ public:
+  SyncBackendHostCore(const std::string& name,
+       const base::FilePath& sync_data_folder_path,
+       bool has_sync_setup_completed,
+       const base::WeakPtr<SyncBackendHostImpl>& backend);
+
+  // SyncManager::Observer implementation.  The Core just acts like an air
+  // traffic controller here, forwarding incoming messages to appropriate
+  // landing threads.
+  virtual void OnSyncCycleCompleted(
+      const syncer::sessions::SyncSessionSnapshot& snapshot) OVERRIDE;
+  virtual void OnInitializationComplete(
+      const syncer::WeakHandle<syncer::JsBackend>& js_backend,
+      const syncer::WeakHandle<syncer::DataTypeDebugInfoListener>&
+          debug_info_listener,
+      bool success,
+      syncer::ModelTypeSet restored_types) OVERRIDE;
+  virtual void OnConnectionStatusChange(
+      syncer::ConnectionStatus status) OVERRIDE;
+  virtual void OnStopSyncingPermanently() OVERRIDE;
+  virtual void OnActionableError(
+      const syncer::SyncProtocolError& sync_error) OVERRIDE;
+
+  // SyncEncryptionHandler::Observer implementation.
+  virtual void OnPassphraseRequired(
+      syncer::PassphraseRequiredReason reason,
+      const sync_pb::EncryptedData& pending_keys) OVERRIDE;
+  virtual void OnPassphraseAccepted() OVERRIDE;
+  virtual void OnBootstrapTokenUpdated(
+      const std::string& bootstrap_token,
+      syncer::BootstrapTokenType type) OVERRIDE;
+  virtual void OnEncryptedTypesChanged(
+      syncer::ModelTypeSet encrypted_types,
+      bool encrypt_everything) OVERRIDE;
+  virtual void OnEncryptionComplete() OVERRIDE;
+  virtual void OnCryptographerStateChanged(
+      syncer::Cryptographer* cryptographer) OVERRIDE;
+  virtual void OnPassphraseTypeChanged(syncer::PassphraseType type,
+                                       base::Time passphrase_time) OVERRIDE;
+
+  // Forwards an invalidation state change to the sync manager.
+  void DoOnInvalidatorStateChange(syncer::InvalidatorState state);
+
+  // Forwards an invalidation to the sync manager.
+  void DoOnIncomingInvalidation(
+      syncer::ObjectIdInvalidationMap invalidation_map);
+
+  // Note:
+  //
+  // The Do* methods are the various entry points from our
+  // SyncBackendHost.  They are all called on the sync thread to
+  // actually perform synchronous (and potentially blocking) syncapi
+  // operations.
+  //
+  // Called to perform initialization of the syncapi on behalf of
+  // SyncBackendHost::Initialize.
+  void DoInitialize(scoped_ptr<DoInitializeOptions> options);
+
+  // Called to perform credential update on behalf of
+  // SyncBackendHost::UpdateCredentials.
+  void DoUpdateCredentials(const syncer::SyncCredentials& credentials);
+
+  // Called to tell the syncapi to start syncing (generally after
+  // initialization and authentication).
+  void DoStartSyncing(const syncer::ModelSafeRoutingInfo& routing_info);
+
+  // Called to set the passphrase for encryption.
+  void DoSetEncryptionPassphrase(const std::string& passphrase,
+                                 bool is_explicit);
+
+  // Called to decrypt the pending keys.
+  void DoSetDecryptionPassphrase(const std::string& passphrase);
+
+  // Called to turn on encryption of all sync data as well as
+  // reencrypt everything.
+  void DoEnableEncryptEverything();
+
+  // Ask the syncer to check for updates for the specified types.
+  void DoRefreshTypes(syncer::ModelTypeSet types);
+
+  // Invoked if we failed to download the necessary control types at startup.
+  // Invokes SyncBackendHost::HandleControlTypesDownloadRetry.
+  void OnControlTypesDownloadRetry();
+
+  // Called to perform tasks which require the control data to be downloaded.
+  // This includes refreshing encryption, setting up the device info change
+  // processor, etc.
+  void DoInitialProcessControlTypes();
+
+  // Some parts of DoInitialProcessControlTypes() may be executed on a different
+  // thread.  This function asynchronously continues the work started in
+  // DoInitialProcessControlTypes() once that other thread gets back to us.
+  void DoFinishInitialProcessControlTypes();
+
+  // The shutdown order is a bit complicated:
+  // 1) Call ShutdownOnUIThread() from |frontend_loop_| to request sync manager
+  //    to stop as soon as possible.
+  // 2) Post DoShutdown() to sync loop to clean up backend state, save
+  //    directory and destroy sync manager.
+  void ShutdownOnUIThread();
+  void DoShutdown(bool sync_disabled);
+  void DoDestroySyncManager();
+
+  // Configuration methods that must execute on sync loop.
+  void DoConfigureSyncer(
+      syncer::ConfigureReason reason,
+      const DoConfigureSyncerTypes& config_types,
+      const syncer::ModelSafeRoutingInfo routing_info,
+      const base::Callback<void(syncer::ModelTypeSet,
+                                syncer::ModelTypeSet)>& ready_task,
+      const base::Closure& retry_callback);
+  void DoFinishConfigureDataTypes(
+      syncer::ModelTypeSet types_to_config,
+      const base::Callback<void(syncer::ModelTypeSet,
+                                syncer::ModelTypeSet)>& ready_task);
+  void DoRetryConfiguration(
+      const base::Closure& retry_callback);
+
+  // Set the base request context to use when making HTTP calls.
+  // This method will add a reference to the context to persist it
+  // on the IO thread. Must be removed from IO thread.
+
+  syncer::SyncManager* sync_manager() { return sync_manager_.get(); }
+
+  SyncedDeviceTracker* synced_device_tracker() {
+    return synced_device_tracker_.get();
+  }
+
+  // Delete the sync data folder to cleanup backend data.  Happens the first
+  // time sync is enabled for a user (to prevent accidentally reusing old
+  // sync databases), as well as shutdown when you're no longer syncing.
+  void DeleteSyncDataFolder();
+
+  // We expose this member because it's required in the construction of the
+  // HttpBridgeFactory.
+  syncer::CancelationSignal* GetRequestContextCancelationSignal() {
+    return &release_request_context_signal_;
+  }
+
+ private:
+  friend class base::RefCountedThreadSafe<SyncBackendHostCore>;
+  friend class SyncBackendHostForProfileSyncTest;
+
+  virtual ~SyncBackendHostCore();
+
+  // Invoked when initialization of syncapi is complete and we can start
+  // our timer.
+  // This must be called from the thread on which SaveChanges is intended to
+  // be run on; the host's |registrar_->sync_thread()|.
+  void StartSavingChanges();
+
+  // Invoked periodically to tell the syncapi to persist its state
+  // by writing to disk.
+  // This is called from the thread we were created on (which is sync thread),
+  // using a repeating timer that is kicked off as soon as the SyncManager
+  // tells us it completed initialization.
+  void SaveChanges();
+
+  // Name used for debugging.
+  const std::string name_;
+
+  // Path of the folder that stores the sync data files.
+  const base::FilePath sync_data_folder_path_;
+
+  // Our parent SyncBackendHost.
+  syncer::WeakHandle<SyncBackendHostImpl> host_;
+
+  // The loop where all the sync backend operations happen.
+  // Non-NULL only between calls to DoInitialize() and ~Core().
+  base::MessageLoop* sync_loop_;
+
+  // Our parent's registrar (not owned).  Non-NULL only between
+  // calls to DoInitialize() and DoShutdown().
+  SyncBackendRegistrar* registrar_;
+
+  // The timer used to periodically call SaveChanges.
+  scoped_ptr<base::RepeatingTimer<SyncBackendHostCore> > save_changes_timer_;
+
+  // Our encryptor, which uses Chrome's encryption functions.
+  ChromeEncryptor encryptor_;
+
+  // A special ChangeProcessor that tracks the DEVICE_INFO type for us.
+  scoped_ptr<SyncedDeviceTracker> synced_device_tracker_;
+
+  // The top-level syncapi entry point.  Lives on the sync thread.
+  scoped_ptr<syncer::SyncManager> sync_manager_;
+
+  // Temporary holder of sync manager's initialization results. Set by
+  // OnInitializeComplete, and consumed when we pass it via OnBackendInitialized
+  // in the final state of HandleInitializationSuccessOnFrontendLoop.
+  syncer::WeakHandle<syncer::JsBackend> js_backend_;
+  syncer::WeakHandle<syncer::DataTypeDebugInfoListener> debug_info_listener_;
+
+  // These signals allow us to send requests to shut down the HttpBridgeFactory
+  // and ServerConnectionManager without having to wait for those classes to
+  // finish initializing first.
+  //
+  // See comments in SyncBackendHostCore::ShutdownOnUIThread() for more details.
+  syncer::CancelationSignal release_request_context_signal_;
+  syncer::CancelationSignal stop_syncing_signal_;
+
+  // Matches the value of SyncPref's HasSyncSetupCompleted() flag at init time.
+  // Should not be used for anything except for UMAs and logging.
+  const bool has_sync_setup_completed_;
+
+  base::WeakPtrFactory<SyncBackendHostCore> weak_ptr_factory_;
+
+  DISALLOW_COPY_AND_ASSIGN(SyncBackendHostCore);
+};
+
+}  // namespace browser_sync
+
+#endif  // CHROME_BROWSER_SYNC_GLUE_SYNC_BACKEND_HOST_CORE_H_