Add API to sync_driver::SyncService for iOS

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 14 matching lines @@
 #include "chrome/browser/sync/backend_unrecoverable_error_handler.h"
 #include "chrome/browser/sync/backup_rollback_controller.h"
 #include "chrome/browser/sync/glue/sync_backend_host.h"
 #include "chrome/browser/sync/protocol_event_observer.h"
 #include "chrome/browser/sync/sessions/sessions_sync_manager.h"
 #include "chrome/browser/sync/startup_controller.h"
 #include "chrome/browser/sync/sync_stopped_reporter.h"
 #include "components/keyed_service/core/keyed_service.h"
 #include "components/signin/core/browser/signin_manager_base.h"
 #include "components/sync_driver/data_type_controller.h"
-#include "components/sync_driver/data_type_encryption_handler.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/device_info_sync_service.h"
 #include "components/sync_driver/local_device_info_provider.h"
 #include "components/sync_driver/non_blocking_data_type_manager.h"
 #include "components/sync_driver/sync_frontend.h"
 #include "components/sync_driver/sync_prefs.h"
 #include "components/sync_driver/sync_service.h"
 #include "google_apis/gaia/google_service_auth_error.h"
@@ skipping 133 matching lines @@
 //   SetSyncSetupCompleted() followed by SetSetupInProgress(false) - this will
 //   tell the sync engine that setup is completed and it can begin downloading
 //   data from the sync server.
 //
 class ProfileSyncService : public sync_driver::SyncService,
                            public sync_driver::SyncFrontend,
                            public sync_driver::SyncPrefObserver,
                            public sync_driver::DataTypeManagerObserver,
                            public syncer::UnrecoverableErrorHandler,
                            public KeyedService,
-                           public sync_driver::DataTypeEncryptionHandler,
                            public OAuth2TokenService::Consumer,
                            public OAuth2TokenService::Observer,
                            public SigninManagerBase::Observer {
  public:
   typedef browser_sync::SyncBackendHost::Status Status;
 
   // Status of sync server connection, sync token and token request.
   struct SyncTokenStatus {
     SyncTokenStatus();
     ~SyncTokenStatus();
@@ skipping 31 matching lines @@
                                             // types and clicking OK.
     // Events resulting in the stoppage of sync service.
     STOP_FROM_OPTIONS = 20,  // Sync was stopped from Wrench->Options.
     STOP_FROM_ADVANCED_DIALOG = 21,  // Sync was stopped via advanced settings.
 
     // Miscellaneous events caused by sync service.
 
     MAX_SYNC_EVENT_CODE
   };
 
-  // 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.
-  };
-
   enum SyncStatusSummary {
     UNRECOVERABLE_ERROR,
     NOT_ENABLED,
     SETUP_INCOMPLETE,
     DATATYPES_NOT_INITIALIZED,
     INITIALIZED,
     BACKUP_USER_DATA,
     ROLLBACK_USER_DATA,
     UNKNOWN_ERROR,
   };
@@ skipping 16 matching lines @@
       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();
 
-  void SetSyncSetupCompleted();
-
   // sync_driver::SyncService implementation
   bool HasSyncSetupCompleted() const override;
   bool SyncActive() const override;
+  bool IsSyncEnabledAndLoggedIn() override;
+  void DisableForUser() override;
+  void StopAndSuppress() override;
+  void UnsuppressAndStart() override;
   syncer::ModelTypeSet GetActiveDataTypes() const override;
+  syncer::ModelTypeSet GetPreferredDataTypes() const override;
+  void OnUserChoseDatatypes(bool sync_everything,
+                            syncer::ModelTypeSet chosen_types) 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;
+  bool IsPassphraseRequiredForDecryption() const override;
+  base::Time GetExplicitPassphraseTime() const override;
+  bool IsUsingSecondaryPassphrase() const override;
+  void EnableEncryptEverything() override;
+  void SetEncryptionPassphrase(const std::string& passphrase,
+                               PassphraseType type) override;
+  bool SetDecryptionPassphrase(const std::string& passphrase) override
+      WARN_UNUSED_RESULT;
   void AddObserver(sync_driver::SyncServiceObserver* observer) override;
   void RemoveObserver(sync_driver::SyncServiceObserver* observer) override;
   bool HasObserver(
       const sync_driver::SyncServiceObserver* observer) const override;
 
   void AddProtocolEventObserver(browser_sync::ProtocolEventObserver* observer);
   void RemoveProtocolEventObserver(
       browser_sync::ProtocolEventObserver* observer);
 
   void AddTypeDebugInfoObserver(syncer::TypeDebugInfoObserver* observer);
@@ skipping 13 matching lines @@
   //
   // These requests can live a long time and return when you least expect it.
   // For safety, the callback should be bound to some sort of WeakPtr<> or
   // scoped_refptr<>.
   void GetAllNodes(
       const base::Callback<void(scoped_ptr<base::ListValue>)>& callback);
 
   void RegisterAuthNotifications();
   void UnregisterAuthNotifications();
 
-  // Returns true if sync is enabled/not suppressed and the user is logged in.
-  // (being logged in does not mean that tokens are available - tokens may
-  // be missing because they have not loaded yet, or because they were deleted
-  // due to http://crbug.com/121755).
-  // Virtual to enable mocking in tests.
-  // TODO(tim): Remove this? Nothing in ProfileSyncService uses it, and outside
-  // callers use a seemingly arbitrary / redundant / bug prone combination of
-  // this method, IsSyncAccessible, and others.
-  virtual bool IsSyncEnabledAndLoggedIn();
-
   // 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);
@@ skipping 34 matching lines @@
   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;
 
-  // Disables sync for user. Use ShowLoginDialog to enable.
-  virtual void DisableForUser();
-
   // Disables sync for the user and prevents it from starting on next restart.
   virtual void StopSyncingPermanently();
 
   // SyncFrontend implementation.
   void OnBackendInitialized(
       const syncer::WeakHandle<syncer::JsBackend>& js_backend,
       const syncer::WeakHandle<syncer::DataTypeDebugInfoListener>&
           debug_info_listener,
       const std::string& cache_guid,
       bool success) override;
@@ skipping 29 matching lines @@
   bool IsPassphraseRequired() const override;
   syncer::ModelTypeSet GetEncryptedDataTypes() const override;
 
   // SigninManagerBase::Observer implementation.
   void GoogleSigninSucceeded(const std::string& account_id,
                              const std::string& username,
                              const std::string& password) override;
   void GoogleSignedOut(const std::string& account_id,
                        const std::string& username) override;
 
-  // 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);
-
   // Get the sync status code.
   SyncStatusSummary QuerySyncStatusSummary();
 
   // Get a description of the sync status for displaying in the user interface.
   std::string QuerySyncStatusSummaryString();
 
   // Initializes a struct of status indicators with data from the backend.
   // Returns false if the backend was not available for querying; in that case
   // the struct will be filled with default data.
   virtual bool QueryDetailedSyncStatus(
       browser_sync::SyncBackendHost::Status* result);
 
-  virtual const GoogleServiceAuthError& GetAuthError() const;
-
-  // Returns true if initial sync setup is in progress (does not return true
-  // if the user is customizing sync after already completing setup once).
-  // ProfileSyncService 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;
-
-  // Called by the UI to notify the ProfileSyncService that UI is visible so it
-  // will not start syncing. This tells sync whether it's safe to start
-  // downloading data types yet (we don't start syncing until after sync setup
-  // is complete). The UI calls this as soon as any part of the signin wizard is
-  // displayed (even just the login UI).
-  // If |setup_in_progress| is false, this also kicks the sync engine to ensure
-  // that data download starts. In this case, |ReconfigureDatatypeManager| will
-  // get triggered.
-  virtual void SetSetupInProgress(bool setup_in_progress);
-
   // Reconfigures the data type manager with the latest enabled types.
   // Note: Does not initialize the backend 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
   // want to startup once more.
   // This function is called by |SetSetupInProgress|.
   virtual void ReconfigureDatatypeManager();
 
-  virtual bool HasUnrecoverableError() const;
   const std::string& unrecoverable_error_message() {
     return unrecoverable_error_message_;
   }
   tracked_objects::Location unrecoverable_error_location() {
     return unrecoverable_error_location_;
   }
 
-  // Returns true if OnPassphraseRequired has been called for decryption and
-  // we have an encrypted data type enabled.
-  virtual bool IsPassphraseRequiredForDecryption() const;
-
   syncer::PassphraseRequiredReason passphrase_required_reason() const {
     return passphrase_required_reason_;
   }
 
   // Returns a user-friendly string form of last synced time (in minutes).
   virtual base::string16 GetLastSyncedTimeString() const;
 
   // Returns a human readable string describing backend initialization state.
   std::string GetBackendInitializationStateString() const;
 
@@ skipping 87 matching lines @@
   // 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
   // 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 preferred for enabling. This is a
-  // superset of the active types (see GetActiveDataTypes()).
-  virtual syncer::ModelTypeSet GetPreferredDataTypes() const;
-
   // Returns the set of directory types which are preferred for enabling.
   virtual syncer::ModelTypeSet GetPreferredDirectoryDataTypes() const;
 
   // Returns the set of off-thread types which are preferred for enabling.
   virtual syncer::ModelTypeSet GetPreferredNonBlockingDataTypes() const;
 
   // 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
   // for a datatype to be Registered.
   virtual syncer::ModelTypeSet GetRegisteredDataTypes() const;
 
   // Gets the set of directory types which could be allowed.
   virtual syncer::ModelTypeSet GetRegisteredDirectoryDataTypes() const;
 
   // Gets the set of off-thread types which could be allowed.
   virtual syncer::ModelTypeSet GetRegisteredNonBlockingDataTypes() const;
 
   // 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;
 
-  // 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;
-
   // Returns the actual passphrase type being used for encryption.
   virtual syncer::PassphraseType GetPassphraseType() const;
 
-  // Returns the time the current explicit passphrase (if any), was set.
-  // If no secondary passphrase is in use, or no time is available, returns an
-  // unset base::Time.
-  virtual base::Time GetExplicitPassphraseTime() const;
-
   // Note about setting passphrases: There are different scenarios under which
   // we might want to apply a passphrase. It could be for first-time encryption,
   // re-encryption, or for decryption by clients that sign in at a later time.
   // In addition, encryption can either be done using a custom passphrase, or by
   // reusing the GAIA password. Depending on what is happening in the system,
   // callers should determine which of the two methods below must be used.
 
-  // 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);
-
-  // 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;
-
   // 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);
 
-  // Turns on encryption for all data. Callers must call OnUserChoseDatatypes()
-  // after calling this to force the encryption to occur.
-  virtual void EnableEncryptEverything();
-
   // 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;
-  bool setup_in_progress() const;
-
-  // Stops the sync backend and sets the flag for suppressing sync startup.
-  void StopAndSuppress();
-
-  // Resets the flag for suppressing sync startup and starts the sync backend.
-  virtual void UnsuppressAndStart();
 
   SyncErrorController* sync_error_controller() {
     return sync_error_controller_.get();
   }
 
   // TODO(sync): This is only used in tests.  Can we remove it?
   const sync_driver::DataTypeStatusTable& data_type_status_table() const;
 
   sync_driver::DataTypeManager::ConfigureStatus configure_status() {
     return configure_status_;
@@ skipping 36 matching lines @@
 
   browser_sync::FaviconCache* GetFaviconCache();
 
   // Overrides the NetworkResources used for Sync connections.
   // This function takes ownership of |network_resources|.
   void OverrideNetworkResourcesForTest(
       scoped_ptr<syncer::NetworkResources> network_resources);
 
   virtual bool IsDataTypeControllerRunning(syncer::ModelType type) const;
 
-  // Returns true if the SyncBackendHost has told us it's ready to accept
-  // changes. This should only be used for sync's internal configuration logic
-  // (such as deciding when to prompt for an encryption passphrase).
-  virtual bool backend_initialized() const;
-
   // Returns the current mode the backend is in.
   BackendMode backend_mode() const;
 
-  // Whether the data types active for the current mode have finished
-  // configuration.
-  bool ConfigurationDone() const;
-
   // Helpers for testing rollback.
   void SetBrowsingDataRemoverObserverForTesting(
       BrowsingDataRemover::Observer* observer);
   void SetClearingBrowseringDataForTesting(base::Callback<
       void(BrowsingDataRemover::Observer*, Profile*, base::Time, base::Time)>
                                                c);
 
   // Return the base URL of the Sync Server.
   static GURL GetSyncServiceURL(const base::CommandLine& command_line);
 
@@ skipping 380 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_