[Sync] Replace ProfileSyncComponentsFactory with SyncClient

components/sync_driver/sync_service.h

 // Copyright 2015 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_SYNC_SERVICE_H_
 #define COMPONENTS_SYNC_DRIVER_SYNC_SERVICE_H_
 
 #include <string>
 
 #include "base/macros.h"
 #include "base/time/time.h"
 #include "components/sync_driver/data_type_encryption_handler.h"
 #include "components/sync_driver/sync_service_observer.h"
 #include "sync/internal_api/public/base/model_type.h"
 
 class GoogleServiceAuthError;
 
 namespace syncer {
 class BaseTransaction;
 struct UserShare;
 }
 
 namespace sync_driver {
 
+class DataTypeController;
+class LocalDeviceInfoProvider;
 class OpenTabsUIDelegate;
 
 class SyncService : public DataTypeEncryptionHandler {
  public:
   // Used to specify the kind of passphrase with which sync data is encrypted.
   enum PassphraseType {
     IMPLICIT,  // The user did not provide a custom passphrase for encryption.
                // We implicitly use the GAIA password in such cases.
     EXPLICIT,  // The user selected the "use custom passphrase" radio button
                // during sync setup and provided a passphrase.
@@ skipping 76 matching lines @@
   virtual syncer::ModelTypeSet GetPreferredDataTypes() const = 0;
 
   // Called when a user chooses which data types to sync as part of the sync
   // setup wizard.  |sync_everything| represents whether they chose the
   // "keep everything synced" option; if true, |chosen_types| will be ignored
   // and all data types will be synced.  |sync_everything| means "sync all
   // current and future data types."
   virtual void OnUserChoseDatatypes(bool sync_everything,
                                     syncer::ModelTypeSet chosen_types) = 0;
 
-  // Overridden by tests.
-  // TODO(zea): Remove these and have the dtc's call directly into the SBH.
-  virtual void DeactivateDataType(syncer::ModelType type) = 0;
-
   // Called whe Sync has been setup by the user and can be started.
   virtual void SetSyncSetupCompleted() = 0;
 
   // Returns true if initial sync setup is in progress (does not return true
   // if the user is customizing sync after already completing setup once).
   // SyncService uses this to determine if it's OK to start syncing, or if the
   // user is still setting up the initial sync configuration.
   virtual bool FirstSetupInProgress() const = 0;
 
   // Called by the UI to notify the SyncService that UI is visible so it will
@@ skipping 35 matching lines @@
   virtual base::Time GetExplicitPassphraseTime() const = 0;
 
   // Returns true if a secondary (explicit) passphrase is being used. It is not
   // legal to call this method before the backend is initialized.
   virtual bool IsUsingSecondaryPassphrase() const = 0;
 
   // Turns on encryption for all data. Callers must call OnUserChoseDatatypes()
   // after calling this to force the encryption to occur.
   virtual void EnableEncryptEverything() = 0;
 
+  // Returns true if we are currently set to encrypt all the sync data.
+  virtual bool EncryptEverythingEnabled() const = 0;
+
   // Asynchronously sets the passphrase to |passphrase| for encryption. |type|
   // specifies whether the passphrase is a custom passphrase or the GAIA
   // password being reused as a passphrase.
   // TODO(atwilson): Change this so external callers can only set an EXPLICIT
   // passphrase with this API.
   virtual void SetEncryptionPassphrase(const std::string& passphrase,
                                        PassphraseType type) = 0;
 
   // Asynchronously decrypts pending keys using |passphrase|. Returns false
   // immediately if the passphrase could not be used to decrypt a locally cached
   // copy of encrypted keys; returns true otherwise.
   virtual bool SetDecryptionPassphrase(const std::string& passphrase)
       WARN_UNUSED_RESULT = 0;
 
   // Checks whether the Cryptographer is ready to encrypt and decrypt updates
   // for sensitive data types. Caller must be holding a
   // syncapi::BaseTransaction to ensure thread safety.
   virtual bool IsCryptographerReady(
       const syncer::BaseTransaction* trans) const = 0;
 
   // TODO(akalin): This is called mostly by ModelAssociators and
   // tests.  Figure out how to pass the handle to the ModelAssociators
   // directly, figure out how to expose this to tests, and remove this
   // function.
   virtual syncer::UserShare* GetUserShare() const = 0;
 
+  // Returns DeviceInfo provider for the local device.
+  virtual LocalDeviceInfoProvider* GetLocalDeviceInfoProvider() const = 0;
+
+  // 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.
+  virtual void RegisterDataTypeController(
+      DataTypeController* data_type_controller) = 0;
+
+  // 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.
+  virtual void ReenableDatatype(syncer::ModelType type) = 0;
+
+  // TODO(zea): Remove these and have the dtc's call directly into the SBH.
+  virtual void DeactivateDataType(syncer::ModelType type) = 0;
+
  protected:
   SyncService() {}
 
  private:
   DISALLOW_COPY_AND_ASSIGN(SyncService);
 };
 
 }  // namespace sync_driver
 
 #endif  // COMPONENTS_SYNC_DRIVER_SYNC_SERVICE_H_