[Sync] SyncEngine refactor part 1: interfaces.

components/sync/driver/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 COMPONENTS_SYNC_DRIVER_GLUE_SYNC_BACKEND_HOST_CORE_H_
 #define COMPONENTS_SYNC_DRIVER_GLUE_SYNC_BACKEND_HOST_CORE_H_
 
 #include <stdint.h>
 
 #include <map>
@@ skipping 65 matching lines @@
   std::string restored_key_for_bootstrapping;
   std::string restored_keystore_key_for_bootstrapping;
   std::unique_ptr<EngineComponentsFactory> engine_components_factory;
   const WeakHandle<UnrecoverableErrorHandler> unrecoverable_error_handler;
   base::Closure report_unrecoverable_error_function;
   std::unique_ptr<SyncEncryptionHandler::NigoriState> saved_nigori_state;
   const std::map<ModelType, int64_t> invalidation_versions;
 };
 
 // Helper struct to handle currying params to
-// SyncBackendHost::Core::DoConfigureSyncer.
+// SyncBackendHostCore::DoConfigureSyncer.
 struct DoConfigureSyncerTypes {
   DoConfigureSyncerTypes();
   DoConfigureSyncerTypes(const DoConfigureSyncerTypes& other);
   ~DoConfigureSyncerTypes();
   ModelTypeSet to_download;
   ModelTypeSet to_purge;
   ModelTypeSet to_journal;
   ModelTypeSet to_unapply;
 };
 
@@ skipping 52 matching lines @@
 
   // Forwards an invalidation state change to the sync manager.
   void DoOnInvalidatorStateChange(InvalidatorState state);
 
   // Forwards an invalidation to the sync manager.
   void DoOnIncomingInvalidation(
       const 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.
+  // The Do* methods are the various entry points from our SyncBackendHostImpl.
+  // 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.
+  // SyncEngine::Initialize.
   void DoInitialize(std::unique_ptr<DoInitializeOptions> options);
 
   // Called to perform credential update on behalf of
-  // SyncBackendHost::UpdateCredentials.
+  // SyncEngine::UpdateCredentials.
   void DoUpdateCredentials(const SyncCredentials& credentials);
 
   // Called to tell the syncapi to start syncing (generally after
   // initialization and authentication).
   void DoStartSyncing(const ModelSafeRoutingInfo& routing_info,
                       base::Time last_poll_time);
 
   // 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(ModelTypeSet types);
 
   // Invoked if we failed to download the necessary control types at startup.
-  // Invokes SyncBackendHost::HandleControlTypesDownloadRetry.
+  // Invokes SyncEngine::HandleControlTypesDownloadRetry.
   void OnControlTypesDownloadRetry();
 
   // Called to perform tasks which require the control data to be downloaded.
   // This includes refreshing encryption, etc.
   void DoInitialProcessControlTypes();
 
   // 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
@@ skipping 16 matching lines @@
 
   // 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.
 
   SyncManager* sync_manager() { return sync_manager_.get(); }
 
   void SendBufferedProtocolEventsAndEnableForwarding();
   void DisableProtocolEventForwarding();
 
-  // Enables the forwarding of directory type debug counters to the
-  // SyncBackendHost.  Also requests that updates to all counters be
-  // emitted right away to initialize any new listeners' states.
+  // Enables the forwarding of directory type debug counters to the SyncEngine.

[skym, 2016/12/02 20:54:54]

But, this class, SyncBackxendHostCore, is part of what constitutes sync's
engine. Everything on the sync thread is part of our engine, right? This
interface name doesn't make sense for anything that's actually in the engine to
refer to. Maybe it'd be better we had left hand and right hand side interfaces
the SyncBackendHostImpl.

[maxbogue, 2016/12/02 23:59:27]

Fixed to SyncEngineHost (the thing listening to the sync engine).

And your last sentence is what this entire refactoring project is allll about :)

+  // Also requests that updates to all counters be emitted right away to
+  // initialize any new listeners' states.
   void EnableDirectoryTypeDebugInfoForwarding();
 
   // Disables forwarding of directory type debug counters.
   void DisableDirectoryTypeDebugInfoForwarding();
 
   // 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();
 
@@ skipping 26 matching lines @@
   void StartSavingChanges();
 
   void ClearServerDataDone(const base::Closure& frontend_callback);
 
   // 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.
+  // Our parent SyncBackendHostImpl.
   WeakHandle<SyncBackendHostImpl> host_;
 
   // Our parent's registrar (not owned).  Non-null only between
   // calls to DoInitialize() and DoShutdown().
   SyncBackendRegistrar* registrar_ = nullptr;
 
   // The timer used to periodically call SaveChanges.
   std::unique_ptr<base::RepeatingTimer> save_changes_timer_;
 
   // Our encryptor, which uses Chrome's encryption functions.
@@ skipping 32 matching lines @@
   base::ThreadChecker thread_checker_;
 
   base::WeakPtrFactory<SyncBackendHostCore> weak_ptr_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(SyncBackendHostCore);
 };
 
 }  // namespace syncer
 
 #endif  // COMPONENTS_SYNC_DRIVER_GLUE_SYNC_BACKEND_HOST_CORE_H_