[Sync] SyncEngine refactor part 2: SyncServiceBase.

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 21 matching lines @@
 #include "components/sync/base/model_type.h"
 #include "components/sync/base/sync_prefs.h"
 #include "components/sync/base/unrecoverable_error_handler.h"
 #include "components/sync/device_info/local_device_info_provider.h"
 #include "components/sync/driver/data_type_controller.h"
 #include "components/sync/driver/data_type_manager.h"
 #include "components/sync/driver/data_type_manager_observer.h"
 #include "components/sync/driver/data_type_status_table.h"
 #include "components/sync/driver/startup_controller.h"
 #include "components/sync/driver/sync_client.h"
-#include "components/sync/driver/sync_service.h"
+#include "components/sync/driver/sync_service_base.h"
 #include "components/sync/driver/sync_stopped_reporter.h"
 #include "components/sync/engine/events/protocol_event_observer.h"
 #include "components/sync/engine/model_safe_worker.h"
 #include "components/sync/engine/net/network_time_update_callback.h"
 #include "components/sync/engine/shutdown_reason.h"
 #include "components/sync/engine/sync_engine.h"
 #include "components/sync/engine/sync_engine_host.h"
 #include "components/sync/engine/sync_manager_factory.h"
 #include "components/sync/js/sync_js_controller.h"
 #include "components/sync/syncable/user_share.h"
@@ skipping 110 matching lines @@
 //    * GetSetupInProgressHandle()
 //
 //   SetFirstSetupComplete() should be called once the user has finished setting
 //   up sync at least once on their account. GetSetupInProgressHandle() should
 //   be called while the user is actively configuring their account. The handle
 //   should be deleted once configuration is complete.
 //
 //   Once first setup has completed and there are no outstanding
 //   setup-in-progress handles, CanConfigureDataTypes() will return true and
 //   datatype configuration can begin.
-class ProfileSyncService : public syncer::SyncService,
-                           public syncer::SyncEngineHost,
+class ProfileSyncService : public syncer::SyncServiceBase,
                            public syncer::SyncPrefObserver,
                            public syncer::DataTypeManagerObserver,
                            public syncer::UnrecoverableErrorHandler,
                            public KeyedService,
                            public OAuth2TokenService::Consumer,
                            public OAuth2TokenService::Observer,
                            public SigninManagerBase::Observer,
                            public GaiaCookieManagerService::Observer {
  public:
   typedef syncer::SyncEngine::Status Status;
@@ skipping 40 matching lines @@
     AUTO_START,
     MANUAL_START,
   };
 
   // Bundles the arguments for ProfileSyncService construction. This is a
   // movable struct. Because of the non-POD data members, it needs out-of-line
   // constructors, so in particular the move constructor needs to be
   // explicitly defined.
   struct InitParams {
     InitParams();
+    InitParams(InitParams&& other);
     ~InitParams();
-    InitParams(InitParams&& other);  // NOLINT
 
     std::unique_ptr<syncer::SyncClient> sync_client;
     std::unique_ptr<SigninManagerWrapper> signin_wrapper;
     ProfileOAuth2TokenService* oauth2_token_service = nullptr;
     GaiaCookieManagerService* gaia_cookie_manager_service = nullptr;
     StartBehavior start_behavior = MANUAL_START;
     syncer::NetworkTimeUpdateCallback network_time_update_callback;
     base::FilePath base_directory;
     scoped_refptr<net::URLRequestContextGetter> url_request_context;
     std::string debug_identifier;
@@ skipping 334 matching lines @@
 
   // Needed to test whether the directory is deleted properly.
   base::FilePath GetDirectoryPathForTest() const;
 
   // 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);
 
+ protected:
+  // SyncServiceBase implementation.
+  syncer::SyncCredentials GetCredentials() override;
+  syncer::WeakHandle<syncer::JsEventHandler> GetJsEventHandler() override;
+  syncer::SyncEngine::HttpPostProviderFactoryGetter
+  MakeHttpPostProviderFactoryGetter() override;
+  std::unique_ptr<syncer::SyncEncryptionHandler::NigoriState>
+  MoveSavedNigoriState() override;
+  syncer::WeakHandle<syncer::UnrecoverableErrorHandler>
+  GetUnrecoverableErrorHandler() override;
+
  private:
   enum UnrecoverableErrorReason {
     ERROR_REASON_UNSET,
     ERROR_REASON_SYNCER,
     ERROR_REASON_ENGINE_INIT_FAILURE,
     ERROR_REASON_CONFIGURATION_RETRY,
     ERROR_REASON_CONFIGURATION_FAILURE,
     ERROR_REASON_ACTIONABLE_ERROR,
     ERROR_REASON_LIMIT
   };
@@ skipping 24 matching lines @@
   friend class TestProfileSyncService;
 
   // Helper to install and configure a data type manager.
   void ConfigureDataTypeManager();
 
   // Shuts down the engine sync components.
   // |reason| dictates if syncing is being disabled or not, and whether
   // 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);
 
@@ skipping 14 matching lines @@
   // 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 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 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();
@@ skipping 72 matching lines @@
   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 engine to communicate with sync components living on
-  // other threads.
-  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 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 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 engine_initialized_;
 
   // Set when sync receives DISABLED_BY_ADMIN error from server. Prevents
   // 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
   // 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_;
@@ skipping 44 matching lines @@
 
   syncer::DataTypeManager::ConfigureStatus configure_status_;
 
   // The set of currently enabled sync experiments.
   syncer::Experiments current_experiments_;
 
   // Sync's internal debug info listener. Used to record datatype configuration
   // and association information.
   syncer::WeakHandle<syncer::DataTypeDebugInfoListener> debug_info_listener_;
 
-  // The thread where all the sync operations happen. This thread is kept alive
-  // until browser shutdown and reused if sync is turned off and on again. It is
-  // joined during the shutdown process, but there is an abort mechanism in
-  // place to prevent slow HTTP requests from blocking browser shutdown.
-  std::unique_ptr<base::Thread> sync_thread_;
-
   // ProfileSyncService uses this service to get access tokens.
   ProfileOAuth2TokenService* const oauth2_token_service_;
 
   // ProfileSyncService needs to remember access token in order to invalidate it
   // with OAuth2TokenService.
   std::string access_token_;
 
   // ProfileSyncService needs to hold reference to access_token_request_ for
   // the duration of request in order to receive callbacks.
   std::unique_ptr<OAuth2TokenService::Request> access_token_request_;
@@ skipping 20 matching lines @@
   // Locally owned SyncableService and ModelTypeSyncBridge implementations.
   std::unique_ptr<sync_sessions::SessionsSyncManager> sessions_sync_manager_;
   std::unique_ptr<syncer::DeviceInfoSyncService> device_info_sync_service_;
   std::unique_ptr<syncer::DeviceInfoSyncBridge> device_info_service_;
 
   std::unique_ptr<syncer::NetworkResources> network_resources_;
 
   StartBehavior start_behavior_;
   std::unique_ptr<syncer::StartupController> startup_controller_;
 
-  // 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 engine after sync
   // restart.
   std::unique_ptr<syncer::SyncEncryptionHandler::NigoriState>
       saved_nigori_state_;
@@ skipping 24 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_