[Sync] Replace ProfileSyncComponentsFactory with SyncClient

chrome/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 CHROME_BROWSER_SYNC_PROFILE_SYNC_SERVICE_H_
 #define CHROME_BROWSER_SYNC_PROFILE_SYNC_SERVICE_H_
 
 #include <set>
 #include <string>
 #include <utility>
@@ skipping 37 matching lines @@
 #include "sync/internal_api/public/shutdown_reason.h"
 #include "sync/internal_api/public/sync_manager_factory.h"
 #include "sync/internal_api/public/user_share.h"
 #include "sync/internal_api/public/util/experiments.h"
 #include "sync/internal_api/public/util/unrecoverable_error_handler.h"
 #include "sync/js/sync_js_controller.h"
 #include "url/gurl.h"
 
 class Profile;
 class ProfileOAuth2TokenService;
-class ProfileSyncComponentsFactory;
 class SupervisedUserSigninManagerWrapper;
 class SyncErrorController;
 class SyncTypePreferenceProvider;
 
 namespace base {
 class CommandLine;
 };
 
 namespace browser_sync {
 class BackendMigrator;
 class FaviconCache;
 class JsController;
 
 namespace sessions {
 class SyncSessionSnapshot;
 }  // namespace sessions
 }  // namespace browser_sync
 
 namespace sync_driver {
 class ChangeProcessor;
 class DataTypeManager;
 class DeviceInfoSyncService;
 class LocalDeviceInfoProvider;
 class OpenTabsUIDelegate;
+class SyncApiComponentFactory;
 }  // namespace sync_driver
 
 namespace syncer {
 class BaseTransaction;
 class NetworkResources;
 struct CommitCounters;
 struct StatusCounters;
 struct SyncCredentials;
 struct UpdateCounters;
 struct UserShare;
@@ skipping 156 matching lines @@
 
   enum BackendMode {
     IDLE,       // No backend.
     SYNC,       // Backend for syncing.
     BACKUP,     // Backend for backup.
     ROLLBACK    // Backend for rollback.
   };
 
   // Takes ownership of |factory| and |signin_wrapper|.
   ProfileSyncService(
-      scoped_ptr<ProfileSyncComponentsFactory> factory,
+      scoped_ptr<sync_driver::SyncApiComponentFactory> factory,
       Profile* profile,
       scoped_ptr<SupervisedUserSigninManagerWrapper> signin_wrapper,
       ProfileOAuth2TokenService* oauth2_token_service,
       browser_sync::ProfileSyncServiceStartBehavior start_behavior);
   ~ProfileSyncService() override;
 
   // Initializes the object. This must be called at most once, and
   // immediately after an object of this class is constructed.
   void Initialize();
 
   // sync_driver::SyncService implementation
   bool HasSyncSetupCompleted() const override;
   bool IsSyncAllowed() const override;
   bool IsSyncActive() const override;
   void OnDataTypeRequestsSyncStartup(syncer::ModelType type) override;
   bool CanSyncStart() const override;
   void RequestStop(SyncStopDataFate data_fate) override;
   void RequestStart() override;
   syncer::ModelTypeSet GetActiveDataTypes() const override;
   syncer::ModelTypeSet GetPreferredDataTypes() const override;
   void OnUserChoseDatatypes(bool sync_everything,
                             syncer::ModelTypeSet chosen_types) override;
-  void DeactivateDataType(syncer::ModelType type) override;
   void SetSyncSetupCompleted() override;
   bool FirstSetupInProgress() const override;
   void SetSetupInProgress(bool setup_in_progress) override;
   bool setup_in_progress() const override;
   bool ConfigurationDone() const override;
   const GoogleServiceAuthError& GetAuthError() const override;
   bool HasUnrecoverableError() const override;
   bool backend_initialized() const override;
   sync_driver::OpenTabsUIDelegate* GetOpenTabsUIDelegate() override;
   bool IsPassphraseRequiredForDecryption() const override;
   base::Time GetExplicitPassphraseTime() const override;
   bool IsUsingSecondaryPassphrase() const override;
   void EnableEncryptEverything() override;
+  bool EncryptEverythingEnabled() 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;
+  sync_driver::LocalDeviceInfoProvider* GetLocalDeviceInfoProvider()
+      const override;
   void AddObserver(sync_driver::SyncServiceObserver* observer) override;
   void RemoveObserver(sync_driver::SyncServiceObserver* observer) override;
   bool HasObserver(
       const sync_driver::SyncServiceObserver* observer) const override;
+  void RegisterDataTypeController(
+      sync_driver::DataTypeController* data_type_controller) override;
+  void ReenableDatatype(syncer::ModelType type) override;
+  void DeactivateDataType(syncer::ModelType type) override;
 
   void AddProtocolEventObserver(browser_sync::ProtocolEventObserver* observer);
   void RemoveProtocolEventObserver(
       browser_sync::ProtocolEventObserver* observer);
 
   void AddTypeDebugInfoObserver(syncer::TypeDebugInfoObserver* observer);
   void RemoveTypeDebugInfoObserver(syncer::TypeDebugInfoObserver* observer);
 
   // Add a sync type preference provider. Each provider may only be added once.
   void AddPreferenceProvider(SyncTypePreferenceProvider* provider);
@@ skipping 13 matching lines @@
   void GetAllNodes(
       const base::Callback<void(scoped_ptr<base::ListValue>)>& callback);
 
   void RegisterAuthNotifications();
   void UnregisterAuthNotifications();
 
   // Return whether OAuth2 refresh token is loaded and available for the backend
   // to start up. Virtual to enable mocking in tests.
   virtual bool IsOAuthRefreshTokenAvailable();
 
-  // Registers a data type controller with the sync service.  This
-  // makes the data type controller available for use, it does not
-  // enable or activate the synchronization of the data type (see
-  // ActivateDataType).  Takes ownership of the pointer.
-  void RegisterDataTypeController(
-      sync_driver::DataTypeController* data_type_controller);
-
   // Registers a type whose sync storage will not be managed by the
   // ProfileSyncService.  It declares that this sync type may be activated at
   // some point in the future.  This function call does not enable or activate
   // the syncing of this type
   void RegisterNonBlockingType(syncer::ModelType type);
 
   // Called by a component that supports non-blocking sync when it is ready to
   // initialize its connection to the sync backend.
   //
   // If policy allows for syncing this type (ie. it is "preferred"), then this
   // should result in a message to enable syncing for this type when the sync
   // backend is available.  If the type is not to be synced, this should result
   // in a message that allows the component to delete its local sync state.
   void InitializeNonBlockingType(
       syncer::ModelType type,
       const scoped_refptr<base::SequencedTaskRunner>& task_runner,
       const base::WeakPtr<syncer_v2::ModelTypeSyncProxyImpl>& proxy);
 
   // Returns the SyncedWindowDelegatesGetter from the embedded sessions manager.
   virtual browser_sync::SyncedWindowDelegatesGetter*
   GetSyncedWindowDelegatesGetter() const;
 
   // Returns the SyncableService for syncer::SESSIONS.
   virtual syncer::SyncableService* GetSessionsSyncableService();
 
   // Returns the SyncableService for syncer::DEVICE_INFO.
   virtual syncer::SyncableService* GetDeviceInfoSyncableService();
 
-  // Returns DeviceInfo provider for the local device.
-  virtual sync_driver::LocalDeviceInfoProvider* GetLocalDeviceInfoProvider();
-
   // Returns synced devices tracker.
   virtual sync_driver::DeviceInfoTracker* GetDeviceInfoTracker() const;
 
   // Fills state_map with a map of current data types that are possible to
   // sync, as well as their states.
   void GetDataTypeControllerStates(
       sync_driver::DataTypeController::StateMap* state_map) const;
 
   // SyncFrontend implementation.
   void OnBackendInitialized(
@@ skipping 81 matching lines @@
   // Returns a human readable string describing backend initialization state.
   std::string GetBackendInitializationStateString() const;
 
   // 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
   // IsSyncAllowed() is false then sync won't start, and if the user
   // doesn't confirm their settings (HasSyncSetupCompleted), sync will
   // never become active. Use IsSyncActive to see if sync is running.
   virtual bool IsSyncRequested() const;
 
-  ProfileSyncComponentsFactory* factory() { return factory_.get(); }
+  sync_driver::SyncApiComponentFactory* factory() const {
+    return factory_.get();
+  }
 
   // The profile we are syncing for.
   Profile* profile() const { return profile_; }
 
   // Returns a weak pointer to the service's JsController.
   // Overrideable for testing purposes.
   virtual base::WeakPtr<syncer::JsController> GetJsController();
 
   // Record stats on various events.
   static void SyncEvent(SyncEventCodes code);
 
   // Returns whether sync is allowed to run based on command-line switches.
   // Profile::IsSyncAllowed() is probably a better signal than this function.
   // This function can be called from any thread, and the implementation doesn't
   // assume it's running on the UI thread.
   static bool IsSyncAllowedByFlag();
 
   // 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;
 
-  // Called to re-enable a type disabled by DisableDatatype(..). Note, this does
-  // not change the preferred state of a datatype, and is not persisted across
-  // restarts.
-  void ReenableDatatype(syncer::ModelType type);
-
   // The functions below (until ActivateDataType()) should only be
   // called if backend_initialized() 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.
 
   virtual syncer::sessions::SyncSessionSnapshot
       GetLastSessionSnapshot() const;
 
@@ skipping 69 matching lines @@
   // reusing the GAIA password. Depending on what is happening in the system,
   // callers should determine which of the two methods below must be used.
 
   // Returns true if encrypting all the sync data is allowed. If this method
   // returns false, EnableEncryptEverything() should not be called.
   virtual bool EncryptEverythingAllowed() const;
 
   // Sets whether encrypting all the sync data is allowed or not.
   virtual void SetEncryptEverythingAllowed(bool allowed);
 
-  // Returns true if we are currently set to encrypt all the sync data. Note:
-  // this is based on the cryptographer's settings, so if the user has recently
-  // requested encryption to be turned on, this may not be true yet. For that,
-  // encryption_pending() must be checked.
-  virtual bool EncryptEverythingEnabled() const;
-
   // Returns true if the syncer is waiting for new datatypes to be encrypted.
   virtual bool encryption_pending() const;
 
   const GURL& sync_service_url() const { return sync_service_url_; }
   SigninManagerBase* signin() const;
 
   // Used by tests.
   bool auto_start_enabled() const;
 
   SyncErrorController* sync_error_controller() {
@@ skipping 273 matching lines @@
   // Calls data type manager to start catch up configure.
   void BeginConfigureCatchUpBeforeClear();
 
   // Calls sync backend to send ClearServerDataMessage to server.
   void ClearAndRestartSyncForPassphraseEncryption();
 
   // Restarts sync clearing directory in the process.
   void OnClearServerDataDone();
 
   // Factory used to create various dependent objects.
-  scoped_ptr<ProfileSyncComponentsFactory> factory_;
+  scoped_ptr<sync_driver::SyncApiComponentFactory> factory_;
 
   // The profile whose data we are synchronizing.
   Profile* profile_;
 
   // The class that handles getting, setting, and persisting sync
   // preferences.
   sync_driver::SyncPrefs sync_prefs_;
 
   // TODO(ncarter): Put this in a profile, once there is UI for it.
   // This specifies where to find the sync server.
@@ skipping 196 matching lines @@
   base::WeakPtrFactory<ProfileSyncService> startup_controller_weak_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(ProfileSyncService);
 };
 
 bool ShouldShowActionOnUI(
     const syncer::SyncProtocolError& error);
 
 
 #endif  // CHROME_BROWSER_SYNC_PROFILE_SYNC_SERVICE_H_