[Sync] Split encryption state and logic out of PSS and SBHI.

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>
 #include <vector>
 
 #include "base/compiler_specific.h"
 #include "base/files/file_path.h"
 #include "base/gtest_prod_util.h"
 #include "base/location.h"
 #include "base/macros.h"
 #include "base/memory/memory_pressure_listener.h"
 #include "base/memory/weak_ptr.h"
 #include "base/message_loop/message_loop.h"
 #include "base/observer_list.h"
 #include "base/strings/string16.h"
 #include "base/threading/thread.h"
-#include "base/threading/thread_checker.h"
 #include "base/time/time.h"
 #include "base/timer/timer.h"
 #include "build/build_config.h"
 #include "components/keyed_service/core/keyed_service.h"
 #include "components/signin/core/browser/gaia_cookie_manager_service.h"
 #include "components/signin/core/browser/signin_manager_base.h"
 #include "components/sync/base/experiments.h"
 #include "components/sync/base/model_type.h"
 #include "components/sync/base/sync_prefs.h"
 #include "components/sync/base/unrecoverable_error_handler.h"
@@ skipping 19 matching lines @@
 #include "components/version_info/version_info.h"
 #include "google_apis/gaia/google_service_auth_error.h"
 #include "google_apis/gaia/oauth2_token_service.h"
 #include "net/base/backoff_entry.h"
 #include "url/gurl.h"
 
 class Profile;
 class ProfileOAuth2TokenService;
 class SigninManagerWrapper;
 
-namespace sync_pb {
-class EncryptedData;
-}  // namespace sync_pb
-
 namespace sync_sessions {
 class FaviconCache;
 class OpenTabsUIDelegate;
 class SessionsSyncManager;
 }  // namespace sync_sessions
 
 namespace syncer {
 class BackendMigrator;
 class BaseTransaction;
 class DataTypeManager;
@@ skipping 213 matching lines @@
   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 GetEngineInitializationStateString() const override;
   syncer::SyncCycleSnapshot GetLastCycleSnapshot() const override;
   std::unique_ptr<base::Value> GetTypeStatusMap() override;
@@ skipping 58 matching lines @@
   void OnDirectoryTypeCommitCounterUpdated(
       syncer::ModelType type,
       const syncer::CommitCounters& counters) override;
   void OnDirectoryTypeUpdateCounterUpdated(
       syncer::ModelType type,
       const syncer::UpdateCounters& counters) override;
   void OnDatatypeStatusCounterUpdated(
       syncer::ModelType type,
       const syncer::StatusCounters& counters) override;
   void OnConnectionStatusChange(syncer::ConnectionStatus status) override;
-  void OnPassphraseRequired(
-      syncer::PassphraseRequiredReason reason,
-      const sync_pb::EncryptedData& pending_keys) override;
-  void OnPassphraseAccepted() override;
-  void OnEncryptedTypesChanged(syncer::ModelTypeSet encrypted_types,
-                               bool encrypt_everything) override;
-  void OnEncryptionComplete() override;
   void OnMigrationNeededForTypes(syncer::ModelTypeSet types) override;
   void OnExperimentsChanged(const syncer::Experiments& experiments) override;
   void OnActionableError(const syncer::SyncProtocolError& error) override;
-  void OnLocalSetPassphraseEncryption(
-      const syncer::SyncEncryptionHandler::NigoriState& nigori_state) override;
 
   // DataTypeManagerObserver implementation.
   void OnConfigureDone(
       const syncer::DataTypeManager::ConfigureResult& result) override;
   void OnConfigureStart() override;
 
   // DataTypeEncryptionHandler implementation.
   bool IsPassphraseRequired() const override;
   syncer::ModelTypeSet GetEncryptedDataTypes() const override;
 
@@ skipping 16 matching lines @@
   // Reconfigures the data type manager with the latest enabled types.
   // 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
   // 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_;
+    return crypto_->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
   // IsSyncAllowed() is false then sync won't start, and if the user
   // doesn't confirm their settings (IsFirstSetupComplete), sync will
   // never become active. Use IsSyncActive to see if sync is running.
   virtual bool IsSyncRequested() const;
 
   // Record stats on various events.
@@ skipping 52 matching lines @@
   // 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;
 
-  // Returns the actual passphrase type being used for encryption.
+  // See the SyncServiceCrypto header.
   virtual syncer::PassphraseType GetPassphraseType() 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.
-
-  // Returns true if encrypting all the sync data is allowed. If this method
-  // returns false, EnableEncryptEverything() should not be called.
   virtual bool IsEncryptEverythingAllowed() const;
-
-  // Sets whether encrypting all the sync data is allowed or not.
   virtual void SetEncryptEverythingAllowed(bool allowed);
 
   // Returns true if the syncer is waiting for new datatypes to be encrypted.
   virtual bool encryption_pending() const;
 
   SigninManagerBase* signin() const;
 
   syncer::SyncErrorController* sync_error_controller() {
     return sync_error_controller_.get();
   }
@@ skipping 57 matching lines @@
   // the sync LevelDB backend.
   syncer::ModelTypeStoreFactory GetModelTypeStoreFactory(
       syncer::ModelType type);
 
   // 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;
 
+  // Some tests rely on injecting calls to the encryption observer.
+  syncer::SyncEncryptionHandler::Observer* GetEncryptionObserverForTest() 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,
@@ skipping 49 matching lines @@
   // 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 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 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();
 
   // Sets the last synced time to the current time.
   void UpdateLastSyncedTime();
 
-  void NotifyObservers();
   void NotifySyncCycleCompleted();
   void NotifyForeignSessionUpdated();
 
   void ClearStaleErrors();
 
   void ClearUnrecoverableError();
 
   // Starts up the engine sync components.
   virtual void StartUpSlowEngineComponents();
 
@@ skipping 43 matching lines @@
 
   // 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();
+  //
+  // SyncServiceCrypto::BeginConfigureCatchUpBeforeClear() and the following two
+  // functions perform these steps.
 
   // 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_;
 
   // Cache of the last SyncCycleSnapshot received from the sync engine.
   syncer::SyncCycleSnapshot last_snapshot_;
 
-  // 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_;
-
   // 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.
@@ skipping 32 matching lines @@
   base::FilePath local_sync_backend_folder_;
 
   // 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 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_;
-
-  // Whether we want to encrypt everything.
-  bool encrypt_everything_;
-
-  // Whether we're waiting for an attempt to encryption all sync data to
-  // complete. We track this at this layer in order to allow the user to cancel
-  // if they e.g. don't remember their explicit passphrase.
-  bool encryption_pending_;
-
   std::unique_ptr<syncer::BackendMigrator> migrator_;
 
   // This is the last |SyncProtocolError| we received from the server that had
   // an action set on it.
   syncer::SyncProtocolError last_actionable_error_;
 
   // Exposes sync errors to the UI.
   std::unique_ptr<syncer::SyncErrorController> sync_error_controller_;
 
   // Tracks the set of failed data types (those that encounter an error
@@ skipping 47 matching lines @@
   std::unique_ptr<syncer::NetworkResources> network_resources_;
 
   StartBehavior start_behavior_;
   std::unique_ptr<syncer::StartupController> startup_controller_;
 
   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_;
-
   // Whether the major version has changed since the last time Chrome ran,
   // and therefore a passphrase required state should result in prompting
   // the user. This logic is only enabled on platforms that consume the
   // IsPassphrasePrompted sync preference.
   bool passphrase_prompt_triggered_by_version_;
 
   // An object that lets us check whether sync is currently allowed on this
   // platform.
   PlatformSyncAllowedProvider platform_sync_allowed_provider_;
 
-  // Used to ensure that certain operations are performed on the thread that
-  // this object was created on.
-  base::ThreadChecker thread_checker_;
-
   // This weak factory invalidates its issued pointers when Sync is disabled.
   base::WeakPtrFactory<ProfileSyncService> sync_enabled_weak_factory_;
 
   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_