[Sync] SyncEngine 1.5: Fix all backend references in PSS.

components/browser_sync/profile_sync_service.h

 // Copyright (c) 2012 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_BROWSER_SYNC_PROFILE_SYNC_SERVICE_H_
 #define COMPONENTS_BROWSER_SYNC_PROFILE_SYNC_SERVICE_H_
 
 #include <memory>
 #include <set>
 #include <string>
@@ skipping 75 matching lines @@
 struct CommitCounters;
 struct StatusCounters;
 struct SyncCredentials;
 struct UpdateCounters;
 struct UserShare;
 }  // namespace syncer
 
 namespace browser_sync {
 
 // ProfileSyncService is the layer between browser subsystems like bookmarks,
-// and the sync backend.  Each subsystem is logically thought of as being
-// a sync datatype.
-//
-// Individual datatypes can, at any point, be in a variety of stages of being
-// "enabled".  Here are some specific terms for concepts used in this class:
+// and the sync engine. Each subsystem is logically thought of as being a sync
+// datatype. Individual datatypes can, at any point, be in a variety of stages
+// of being "enabled". Here are some specific terms for concepts used in this
+// class:
 //
 //   'Registered' (feature suppression for a datatype)
 //
 //      When a datatype is registered, the user has the option of syncing it.
 //      The sync opt-in UI will show only registered types; a checkbox should
 //      never be shown for an unregistered type, and nor should it ever be
 //      synced.
 //
 //      A datatype is considered registered once RegisterDataTypeController
 //      has been called with that datatype's DataTypeController.
 //
 //   'Preferred' (user preferences and opt-out for a datatype)
 //
 //      This means the user's opt-in or opt-out preference on a per-datatype
 //      basis.  The sync service will try to make active exactly these types.
 //      If a user has opted out of syncing a particular datatype, it will
 //      be registered, but not preferred.
 //
 //      This state is controlled by the ConfigurePreferredDataTypes and
 //      GetPreferredDataTypes.  They are stored in the preferences system,
 //      and persist; though if a datatype is not registered, it cannot
 //      be a preferred datatype.
 //
 //   'Active' (run-time initialization of sync system for a datatype)
 //
 //      An active datatype is a preferred datatype that is actively being
 //      synchronized: the syncer has been instructed to querying the server
 //      for this datatype, first-time merges have finished, and there is an
 //      actively installed ChangeProcessor that listens for changes to this
-//      datatype, propagating such changes into and out of the sync backend
+//      datatype, propagating such changes into and out of the sync engine
 //      as necessary.
 //
 //      When a datatype is in the process of becoming active, it may be
 //      in some intermediate state.  Those finer-grained intermediate states
 //      are differentiated by the DataTypeController state.
 //
 // Sync Configuration:
 //
 //   Sync configuration is accomplished via the following APIs:
 //    * OnUserChoseDatatypes(): Set the data types the user wants to sync.
@@ skipping 134 matching lines @@
   void OnUserChoseDatatypes(bool sync_everything,
                             syncer::ModelTypeSet chosen_types) override;
   void SetFirstSetupComplete() override;
   bool IsFirstSetupInProgress() const override;
   std::unique_ptr<syncer::SyncSetupInProgressHandle> GetSetupInProgressHandle()
       override;
   bool IsSetupInProgress() const override;
   bool ConfigurationDone() const override;
   const GoogleServiceAuthError& GetAuthError() const override;
   bool HasUnrecoverableError() const override;
-  bool IsBackendInitialized() const override;
+  bool IsEngineInitialized() const override;
   sync_sessions::OpenTabsUIDelegate* GetOpenTabsUIDelegate() override;
   bool IsPassphraseRequiredForDecryption() const override;
   base::Time GetExplicitPassphraseTime() const override;
   bool IsUsingSecondaryPassphrase() const override;
   void EnableEncryptEverything() override;
   bool IsEncryptEverythingEnabled() const override;
   void SetEncryptionPassphrase(const std::string& passphrase,
                                PassphraseType type) override;
   bool SetDecryptionPassphrase(const std::string& passphrase) override
       WARN_UNUSED_RESULT;
   bool IsCryptographerReady(
       const syncer::BaseTransaction* trans) const override;
   syncer::UserShare* GetUserShare() const override;
   syncer::LocalDeviceInfoProvider* GetLocalDeviceInfoProvider() const override;
   void AddObserver(syncer::SyncServiceObserver* observer) override;
   void RemoveObserver(syncer::SyncServiceObserver* observer) override;
   bool HasObserver(const syncer::SyncServiceObserver* observer) const override;
   void RegisterDataTypeController(std::unique_ptr<syncer::DataTypeController>
                                       data_type_controller) override;
   void ReenableDatatype(syncer::ModelType type) override;
   SyncTokenStatus GetSyncTokenStatus() const override;
   std::string QuerySyncStatusSummaryString() override;
   bool QueryDetailedSyncStatus(syncer::SyncStatus* result) override;
   base::string16 GetLastSyncedTimeString() const override;
-  std::string GetBackendInitializationStateString() const override;
+  std::string GetEngineInitializationStateString() const override;
   syncer::SyncCycleSnapshot GetLastCycleSnapshot() const override;
   std::unique_ptr<base::Value> GetTypeStatusMap() override;
   const GURL& sync_service_url() const override;
   std::string unrecoverable_error_message() const override;
   tracked_objects::Location unrecoverable_error_location() const override;
   void AddProtocolEventObserver(
       syncer::ProtocolEventObserver* observer) override;
   void RemoveProtocolEventObserver(
       syncer::ProtocolEventObserver* observer) override;
   void AddTypeDebugInfoObserver(
@@ skipping 31 matching lines @@
 
   // Fills state_map with a map of current data types that are possible to
   // sync, as well as their states.
   void GetDataTypeControllerStates(
       syncer::DataTypeController::StateMap* state_map) const;
 
   // Called when asynchronous session restore has completed.
   void OnSessionRestoreComplete();
 
   // SyncEngineHost implementation.
-  void OnBackendInitialized(
+  void OnEngineInitialized(
       const syncer::WeakHandle<syncer::JsBackend>& js_backend,

[skym, 2016/12/05 19:38:56]

And this gets less ambiguous! Woooo!

[maxbogue, 2016/12/05 22:17:11]

:D

       const syncer::WeakHandle<syncer::DataTypeDebugInfoListener>&
           debug_info_listener,
       const std::string& cache_guid,
       bool success) override;
   void OnSyncCycleCompleted() override;
   void OnProtocolEvent(const syncer::ProtocolEvent& event) override;
   void OnDirectoryTypeCommitCounterUpdated(
       syncer::ModelType type,
       const syncer::CommitCounters& counters) override;
   void OnDirectoryTypeUpdateCounterUpdated(
@@ skipping 35 matching lines @@
   // GaiaCookieManagerService::Observer implementation.
   void OnGaiaAccountsInCookieUpdated(
       const std::vector<gaia::ListedAccount>& accounts,
       const std::vector<gaia::ListedAccount>& signed_out_accounts,
       const GoogleServiceAuthError& error) override;
 
   // Get the sync status code.
   SyncStatusSummary QuerySyncStatusSummary();
 
   // Reconfigures the data type manager with the latest enabled types.
-  // Note: Does not initialize the backend if it is not already initialized.
+  // Note: Does not initialize the engine if it is not already initialized.
   // This function needs to be called only after sync has been initialized
   // (i.e.,only for reconfigurations). The reason we don't initialize the
-  // backend is because if we had encountered an unrecoverable error we don't
+  // engine is because if we had encountered an unrecoverable error we don't
   // want to startup once more.
   // This function is called by |SetSetupInProgress|.
   virtual void ReconfigureDatatypeManager();
 
   syncer::PassphraseRequiredReason passphrase_required_reason() const {
     return passphrase_required_reason_;
   }
 
   // Returns true if sync is requested to be running by the user.
   // Note that this does not mean that sync WILL be running; e.g. if
@@ skipping 16 matching lines @@
 
   // Returns whether sync is managed, i.e. controlled by configuration
   // management. If so, the user is not allowed to configure sync.
   virtual bool IsManaged() const;
 
   // syncer::UnrecoverableErrorHandler implementation.
   void OnUnrecoverableError(const tracked_objects::Location& from_here,
                             const std::string& message) override;
 
   // The functions below (until ActivateDataType()) should only be
-  // called if IsBackendInitialized() is true.
+  // called if IsEngineInitialized() is true.
 
   // TODO(akalin): These two functions are used only by
   // ProfileSyncServiceHarness.  Figure out a different way to expose
   // this info to that class, and remove these functions.
 
   // Returns whether or not the underlying sync engine has made any
   // local changes to items that have not yet been synced with the
   // server.
   bool HasUnsyncedItems() const;
 
   // Used by ProfileSyncServiceHarness.  May return null.
   syncer::BackendMigrator* GetBackendMigratorForTest();

[skym, 2016/12/05 19:38:56]

Does this need to be renamed? What does the BackendMigrator even do? Do we need
to worry about USS migration happening at the same time as this thing?

[maxbogue, 2016/12/05 22:17:11]

I don't know, I'm ignoring it for now.

 
   // Used by tests to inspect interaction with OAuth2TokenService.
   bool IsRetryingAccessTokenFetchForTest() const;
 
   // Used by tests to inspect the OAuth2 access tokens used by PSS.
   std::string GetAccessTokenForTest() const;
 
   // TODO(sync): This is only used in tests.  Can we remove it?
   void GetModelSafeRoutingInfo(syncer::ModelSafeRoutingInfo* out) const;
 
   // SyncPrefObserver implementation.
   void OnSyncManagedPrefChange(bool is_sync_managed) override;
 
   // Changes which data types we're going to be syncing to |preferred_types|.
   // If it is running, the DataTypeManager will be instructed to reconfigure
-  // the sync backend so that exactly these datatypes are actively synced.  See
+  // the sync engine so that exactly these datatypes are actively synced. See
   // class comment for more on what it means for a datatype to be Preferred.
   virtual void ChangePreferredDataTypes(syncer::ModelTypeSet preferred_types);
 
   // Returns the set of types which are enforced programmatically and can not
   // be disabled by the user.
   virtual syncer::ModelTypeSet GetForcedDataTypes() const;
 
   // Gets the set of all data types that could be allowed (the set that
   // should be advertised to the user).  These will typically only change
   // via a command-line option.  See class comment for more on what it means
@@ skipping 87 matching lines @@
   // Sometimes we need to wait for tasks on the sync thread in tests.
   base::MessageLoop* GetSyncLoopForTest() const;
 
   // Triggers sync cycle with request to update specified |types|.
   void RefreshTypesForTest(syncer::ModelTypeSet types);
 
  private:
   enum UnrecoverableErrorReason {
     ERROR_REASON_UNSET,
     ERROR_REASON_SYNCER,
-    ERROR_REASON_BACKEND_INIT_FAILURE,
+    ERROR_REASON_ENGINE_INIT_FAILURE,
     ERROR_REASON_CONFIGURATION_RETRY,
     ERROR_REASON_CONFIGURATION_FAILURE,
     ERROR_REASON_ACTIONABLE_ERROR,
     ERROR_REASON_LIMIT
   };
 
   enum AuthErrorMetric {
     AUTH_ERROR_ENCOUNTERED,
     AUTH_ERROR_FIXED,
     AUTH_ERROR_LIMIT
@@ skipping 14 matching lines @@
     IS_MANAGED,               // Sync is disallowed by enterprise policy.
     NOT_ALLOWED_BY_PLATFORM,  // Sync is disallowed by the platform.
     SYNC_INITIAL_STATE_LIMIT
   };
 
   friend class TestProfileSyncService;
 
   // Helper to install and configure a data type manager.
   void ConfigureDataTypeManager();
 
-  // Shuts down the backend sync components.
+  // Shuts down the engine sync components.
   // |reason| dictates if syncing is being disabled or not, and whether
-  // to claim ownership of sync thread from backend.
+  // to claim ownership of sync thread from engine.
   void ShutdownImpl(syncer::ShutdownReason reason);
 
   // Return SyncCredentials from the OAuth2TokenService.
   syncer::SyncCredentials GetCredentials();
 
   virtual syncer::WeakHandle<syncer::JsEventHandler> GetJsEventHandler();
 
   // Helper method for managing encryption UI.
   bool IsEncryptedDatatypeEnabled() const;
 
   // Helper for OnUnrecoverableError.
   // TODO(tim): Use an enum for |delete_sync_database| here, in ShutdownImpl,
   // and in SyncEngine::Shutdown.
   void OnUnrecoverableErrorImpl(const tracked_objects::Location& from_here,
                                 const std::string& message,
                                 bool delete_sync_database);
 
   // Stops the sync engine. Does NOT set IsSyncRequested to false. Use
   // RequestStop for that. |data_fate| controls whether the local sync data is
   // deleted or kept when the engine shuts down.
   void StopImpl(SyncStopDataFate data_fate);
 
   // Update the last auth error and notify observers of error state.
   void UpdateAuthErrorState(const GoogleServiceAuthError& error);
 
-  // Puts the backend's sync scheduler into NORMAL mode.
+  // Puts the engine's sync scheduler into NORMAL mode.
   // Called when configuration is complete.
   void StartSyncingWithServer();
 
   // During initial signin, ProfileSyncService caches the user's signin
   // passphrase so it can be used to encrypt/decrypt data after sync starts up.
-  // This routine is invoked once the backend has started up to use the
+  // This routine is invoked once the engine has started up to use the
   // cached passphrase and clear it out when it is done.
   void ConsumeCachedPassphraseIfPossible();
 
   // RequestAccessToken initiates RPC to request downscoped access token from
   // refresh token. This happens when a new OAuth2 login token is loaded and
   // when sync server returns AUTH_ERROR which indicates it is time to refresh
   // token.
   void RequestAccessToken();
 
-  // Return true if backend should start from a fresh sync DB.
+  // Return true if engine should start from a fresh sync DB.
   bool ShouldDeleteSyncFolder();
 
   // If |delete_sync_data_folder| is true, then this method will delete all
   // previous "Sync Data" folders. (useful if the folder is partial/corrupt).
-  void InitializeBackend(bool delete_sync_data_folder);
+  void InitializeEngine(bool delete_sync_data_folder);
 
   // Sets the last synced time to the current time.
   void UpdateLastSyncedTime();
 
   void NotifyObservers();
   void NotifySyncCycleCompleted();
   void NotifyForeignSessionUpdated();
 
   void ClearStaleErrors();
 
   void ClearUnrecoverableError();
 
-  // Starts up the backend sync components.
-  void StartUpSlowBackendComponents();
+  // Starts up the engine sync components.
+  virtual void StartUpSlowEngineComponents();
 
   // Collects preferred sync data types from |preference_providers_|.
   syncer::ModelTypeSet GetDataTypesFromPreferenceProviders() const;
 
   // Called when the user changes the sync configuration, to update the UMA
   // stats.
   void UpdateSelectedTypesHistogram(
       bool sync_everything,
       const syncer::ModelTypeSet chosen_types) const;
 
 #if defined(OS_CHROMEOS)
   // Refresh spare sync bootstrap token for re-enabling the sync service.
   // Called on successful sign-in notifications.
   void RefreshSpareBootstrapToken(const std::string& passphrase);
 #endif
 
   // Internal unrecoverable error handler. Used to track error reason via
   // Sync.UnrecoverableErrors histogram.
   void OnInternalUnrecoverableError(const tracked_objects::Location& from_here,
                                     const std::string& message,
                                     bool delete_sync_database,
                                     UnrecoverableErrorReason reason);
 
-  // Update UMA for syncing backend.
-  void UpdateBackendInitUMA(bool success);
+  // Update UMA for syncing engine.
+  void UpdateEngineInitUMA(bool success);
 
-  // Various setup following backend initialization, mostly for syncing backend.
-  void PostBackendInitialization();
+  // Various setup following engine initialization, mostly for syncing engine.
+  void PostEngineInitialization();
 
   // Whether sync has been authenticated with an account ID.
   bool IsSignedIn() const;
 
-  // The backend can only start if sync can start and has an auth token. This is
-  // different fron CanSyncStart because it represents whether the backend can
+  // The engine can only start if sync can start and has an auth token. This is
+  // different fron CanSyncStart because it represents whether the engine can
   // be started at this moment, whereas CanSyncStart represents whether sync can
   // conceptually start without further user action (acquiring a token is an
   // automatic process).
-  bool CanBackendStart() const;
+  bool CanEngineStart() const;
 
-  // True if a syncing backend exists.
-  bool HasSyncingBackend() const;
+  // True if a syncing engine exists.
+  bool HasSyncingEngine() const;
 
   // Update first sync time stored in preferences
   void UpdateFirstSyncTimePref();
 
   // Tell the sync server that this client has disabled sync.
   void RemoveClientFromServer() const;
 
   // Called when the system is under memory pressure.
   void OnMemoryPressure(
       base::MemoryPressureListener::MemoryPressureLevel memory_pressure_level);
 
   // Check if previous shutdown is shutdown cleanly.
   void ReportPreviousSessionMemoryWarningCount();
 
   // After user switches to custom passphrase encryption a set of steps needs to
   // be performed:
   // - Download all latest updates from server (catch up configure).
   // - Clear user data on server.
   // - Clear directory so that data is merged from model types and encrypted.
   // Following three functions perform these steps.
 
   // Calls data type manager to start catch up configure.
   void BeginConfigureCatchUpBeforeClear();
 
-  // Calls sync backend to send ClearServerDataMessage to server.
+  // Calls sync engine to send ClearServerDataMessage to server.
   void ClearAndRestartSyncForPassphraseEncryption();
 
   // Restarts sync clearing directory in the process.
   void OnClearServerDataDone();
 
   // True if setup has been completed at least once and is not in progress.
   bool CanConfigureDataTypes() const;
 
   // Called when a SetupInProgressHandle issued by this instance is destroyed.
   virtual void OnSetupInProgressHandleDestroyed();
 
   // This is a cache of the last authentication response we received from the
   // sync server. The UI queries this to display appropriate messaging to the
   // user.
   GoogleServiceAuthError last_auth_error_;
 
-  // Our asynchronous backend to communicate with sync components living on
+  // Our asynchronous engine to communicate with sync components living on
   // other threads.
-  std::unique_ptr<syncer::SyncEngine> backend_;
+  std::unique_ptr<syncer::SyncEngine> engine_;
 
   // Was the last SYNC_PASSPHRASE_REQUIRED notification sent because it
   // was required for encryption, decryption with a cached passphrase, or
   // because a new passphrase is required?
   syncer::PassphraseRequiredReason passphrase_required_reason_;
 
   // This profile's SyncClient, which abstracts away non-Sync dependencies and
   // the Sync API component factory.
   std::unique_ptr<syncer::SyncClient> sync_client_;
 
   // The class that handles getting, setting, and persisting sync
   // preferences.
   syncer::SyncPrefs sync_prefs_;
 
   // TODO(ncarter): Put this in a profile, once there is UI for it.
   // This specifies where to find the sync server.
   const GURL sync_service_url_;
 
   // The time that OnConfigureStart is called. This member is zero if
   // OnConfigureStart has not yet been called, and is reset to zero once
   // OnConfigureDone is called.
   base::Time sync_configure_start_time_;
 
-  // Callback to update the network time; used for initializing the backend.
+  // Callback to update the network time; used for initializing the engine.
   syncer::NetworkTimeUpdateCallback network_time_update_callback_;
 
   // The path to the base directory under which sync should store its
   // information.
   base::FilePath base_directory_;
 
   // The request context in which sync should operate.
   scoped_refptr<net::URLRequestContextGetter> url_request_context_;
 
   // An identifier representing this instance for debugging purposes.
   std::string debug_identifier_;
 
   // The product channel of the embedder.
   version_info::Channel channel_;
 
   // Threading context.
   base::SequencedWorkerPool* blocking_pool_;
 
   // Indicates if this is the first time sync is being configured.  This value
-  // is equal to !IsFirstSetupComplete() at the time of OnBackendInitialized().
+  // is equal to !IsFirstSetupComplete() at the time of OnEngineInitialized().
   bool is_first_time_sync_configure_;
 
   // Number of UIs currently configuring the Sync service. When this number
   // is decremented back to zero, Sync setup is marked no longer in progress.
   int outstanding_setup_in_progress_handles_ = 0;
 
   // List of available data type controllers.
   syncer::DataTypeController::TypeMap data_type_controllers_;
 
   // Whether the SyncEngine has been initialized.
-  bool backend_initialized_;
+  bool engine_initialized_;
 
   // Set when sync receives DISABLED_BY_ADMIN error from server. Prevents
-  // ProfileSyncService from starting backend till browser restarted or user
+  // ProfileSyncService from starting engine till browser restarted or user
   // signed out.
   bool sync_disabled_by_admin_;
 
   // Set to true if a signin has completed but we're still waiting for the
-  // backend to refresh its credentials.
+  // engine to refresh its credentials.
   bool is_auth_in_progress_;
 
   // Encapsulates user signin - used to set/get the user's authenticated
   // email address.
   const std::unique_ptr<SigninManagerWrapper> signin_;
 
   // Information describing an unrecoverable error.
   UnrecoverableErrorReason unrecoverable_error_reason_;
   std::string unrecoverable_error_message_;
   tracked_objects::Location unrecoverable_error_location_;
 
   // Manages the start and stop of the data types.
   std::unique_ptr<syncer::DataTypeManager> data_type_manager_;
 
   base::ObserverList<syncer::SyncServiceObserver> observers_;
   base::ObserverList<syncer::ProtocolEventObserver> protocol_event_observers_;
   base::ObserverList<syncer::TypeDebugInfoObserver> type_debug_info_observers_;
 
   std::set<syncer::SyncTypePreferenceProvider*> preference_providers_;
 
   syncer::SyncJsController sync_js_controller_;
 
   // This allows us to gracefully handle an ABORTED return code from the
   // DataTypeManager in the event that the server informed us to cease and
   // desist syncing immediately.
   bool expect_sync_configuration_aborted_;
 
   // Sometimes we need to temporarily hold on to a passphrase because we don't
-  // yet have a backend to send it to.  This happens during initialization as
+  // yet have a engine to send it to.  This happens during initialization as
   // we don't StartUp until we have a valid token, which happens after valid
   // credentials were provided.
   std::string cached_passphrase_;
 
   // The current set of encrypted types.  Always a superset of
   // syncer::Cryptographer::SensitiveTypes().
   syncer::ModelTypeSet encrypted_types_;
 
   // Whether encrypting everything is allowed.
   bool encrypt_everything_allowed_;
@@ skipping 76 matching lines @@
 
   // The full path to the sync data directory.
   base::FilePath directory_path_;
 
   std::unique_ptr<syncer::SyncStoppedReporter> sync_stopped_reporter_;
 
   // Listens for the system being under memory pressure.
   std::unique_ptr<base::MemoryPressureListener> memory_pressure_listener_;
 
   // Nigori state after user switching to custom passphrase, saved until
-  // transition steps complete. It will be injected into new backend after sync
+  // transition steps complete. It will be injected into new engine after sync
   // restart.
   std::unique_ptr<syncer::SyncEncryptionHandler::NigoriState>
       saved_nigori_state_;
 
   // When BeginConfigureCatchUpBeforeClear is called it will set
   // catch_up_configure_in_progress_ to true. This is needed to detect that call
   // to OnConfigureDone originated from BeginConfigureCatchUpBeforeClear and
   // needs to be followed by ClearAndRestartSyncForPassphraseEncryption().
   bool catch_up_configure_in_progress_;
 
@@ skipping 17 matching lines @@
   base::WeakPtrFactory<ProfileSyncService> weak_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(ProfileSyncService);
 };
 
 bool ShouldShowActionOnUI(const syncer::SyncProtocolError& error);
 
 }  // namespace browser_sync
 
 #endif  // COMPONENTS_BROWSER_SYNC_PROFILE_SYNC_SERVICE_H_