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

components/sync/driver/glue/sync_backend_host_impl.h

 // Copyright 2013 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_GLUE_SYNC_BACKEND_HOST_IMPL_H_
 #define COMPONENTS_SYNC_DRIVER_GLUE_SYNC_BACKEND_HOST_IMPL_H_
 
 #include <stdint.h>
 
 #include <map>
@@ skipping 46 matching lines @@
   ~SyncBackendHostImpl() override;
 
   // SyncEngine implementation.
   void Initialize(InitParams params) override;
   void TriggerRefresh(const ModelTypeSet& types) override;
   void UpdateCredentials(const SyncCredentials& credentials) override;
   void StartConfiguration() override;
   void StartSyncingWithServer() override;
   void SetEncryptionPassphrase(const std::string& passphrase,
                                bool is_explicit) override;
-  bool SetDecryptionPassphrase(const std::string& passphrase) override
-      WARN_UNUSED_RESULT;
+  void SetDecryptionPassphrase(const std::string& passphrase) override;
   void StopSyncingForShutdown() override;
   void Shutdown(ShutdownReason reason) override;
   void ConfigureDataTypes(ConfigureParams params) override;
   void RegisterDirectoryDataType(ModelType type, ModelSafeGroup group) override;
   void UnregisterDirectoryDataType(ModelType type) override;
   void ActivateDirectoryDataType(ModelType type,
                                  ModelSafeGroup group,
                                  ChangeProcessor* change_processor) override;
   void DeactivateDirectoryDataType(ModelType type) override;
   void ActivateNonBlockingDataType(ModelType type,
                                    std::unique_ptr<ActivationContext>) override;
   void DeactivateNonBlockingDataType(ModelType type) override;
   void EnableEncryptEverything() override;
   UserShare* GetUserShare() const override;
   Status GetDetailedStatus() override;
   bool HasUnsyncedItems() const override;
-  bool IsNigoriEnabled() const override;
-  PassphraseType GetPassphraseType() const override;
-  base::Time GetExplicitPassphraseTime() const override;
   bool IsCryptographerReady(const BaseTransaction* trans) const override;
   void GetModelSafeRoutingInfo(ModelSafeRoutingInfo* out) const override;
   void FlushDirectory() const override;
   void RequestBufferedProtocolEventsAndEnableForwarding() override;
   void DisableProtocolEventForwarding() override;
   void EnableDirectoryTypeDebugInfoForwarding() override;
   void DisableDirectoryTypeDebugInfoForwarding() override;
   void RefreshTypesForTest(ModelTypeSet types) override;
   void ClearServerData(
       const SyncManager::ClearServerDataCallback& callback) override;
@@ skipping 75 matching lines @@
   // Called from Core::OnSyncCycleCompleted to handle updating frontend
   // thread components.
   void HandleSyncCycleCompletedOnFrontendLoop(
       const SyncCycleSnapshot& snapshot);
 
   // Called when the syncer failed to perform a configuration and will
   // eventually retry. FinishingConfigurationOnFrontendLoop(..) will be called
   // on successful completion.
   void RetryConfigurationOnFrontendLoop(const base::Closure& retry_callback);
 
-  // Helpers to persist a token that can be used to bootstrap sync encryption
-  // across browser restart to avoid requiring the user to re-enter their
-  // passphrase.  |token| must be valid UTF-8 as we use the PrefService for
-  // storage.
-  void PersistEncryptionBootstrapToken(const std::string& token,
-                                       BootstrapTokenType token_type);
-
   // For convenience, checks if initialization state is INITIALIZED.
   bool initialized() const { return initialized_; }
 
   // Let the front end handle the actionable error event.
   void HandleActionableErrorEventOnFrontendLoop(
       const SyncProtocolError& sync_error);
 
   // Handle a migration request.
   void HandleMigrationRequestedOnFrontendLoop(const ModelTypeSet types);
 
-  // Checks if |passphrase| can be used to decrypt the cryptographer's pending
-  // keys that were cached during NotifyPassphraseRequired. Returns true if
-  // decryption was successful. Returns false otherwise. Must be called with a
-  // non-empty pending keys cache.
-  bool CheckPassphraseAgainstCachedPendingKeys(
-      const std::string& passphrase) const;
-
-  // Invoked when a passphrase is required to decrypt a set of Nigori keys,
-  // or for encrypting. |reason| denotes why the passphrase was required.
-  // |pending_keys| is a copy of the cryptographer's pending keys, that are
-  // cached by the frontend. If there are no pending keys, or if the passphrase
-  // required reason is REASON_ENCRYPTION, an empty EncryptedData object is
-  // passed.
-  void NotifyPassphraseRequired(PassphraseRequiredReason reason,
-                                sync_pb::EncryptedData pending_keys);
-
-  // Invoked when the passphrase provided by the user has been accepted.
-  void NotifyPassphraseAccepted();
-
-  // Invoked when the set of encrypted types or the encrypt
-  // everything flag changes.
-  void NotifyEncryptedTypesChanged(ModelTypeSet encrypted_types,
-                                   bool encrypt_everything);
-
-  // Invoked when sync finishes encrypting new datatypes.
-  void NotifyEncryptionComplete();
-
-  // Invoked when the passphrase state has changed. Caches the passphrase state
-  // for later use on the UI thread.
-  // If |type| is FROZEN_IMPLICIT_PASSPHRASE or CUSTOM_PASSPHRASE,
-  // |explicit_passphrase_time| is the time at which that passphrase was set
-  // (if available).
-  void HandlePassphraseTypeChangedOnFrontendLoop(
-      PassphraseType type,
-      base::Time explicit_passphrase_time);
-
-  void HandleLocalSetPassphraseEncryptionOnFrontendLoop(
-      const SyncEncryptionHandler::NigoriState& nigori_state);
-
   // Dispatched to from OnConnectionStatusChange to handle updating
   // frontend UI components.
   void HandleConnectionStatusChangeOnFrontendLoop(ConnectionStatus status);
 
   void ClearServerDataDoneOnFrontendLoop(
       const SyncManager::ClearServerDataCallback& frontend_callback);
 
   SyncClient* const sync_client_;
 
   // The task runner where all the sync engine operations happen.
@@ skipping 15 matching lines @@
 
   const base::WeakPtr<SyncPrefs> sync_prefs_;
 
   // The host which we serve (and are owned by). Set in Initialize() and nulled
   // out in StopSyncingForShutdown().
   SyncEngineHost* host_ = nullptr;
 
   // A pointer to the registrar; owned by |core_|.
   SyncBackendRegistrar* registrar_ = nullptr;
 
-  // We cache the cryptographer's pending keys whenever NotifyPassphraseRequired
-  // is called. This way, before the UI calls SetDecryptionPassphrase on the
-  // syncer, it can avoid the overhead of an asynchronous decryption call and
-  // give the user immediate feedback about the passphrase entered by first
-  // trying to decrypt the cached pending keys on the UI thread. Note that
-  // SetDecryptionPassphrase can still fail after the cached pending keys are
-  // successfully decrypted if the pending keys have changed since the time they
-  // were cached.
-  sync_pb::EncryptedData cached_pending_keys_;
-
-  // The state of the passphrase required to decrypt the bag of encryption keys
-  // in the nigori node. Updated whenever a new nigori node arrives or the user
-  // manually changes their passphrase state. Cached so we can synchronously
-  // check it from the UI thread.
-  PassphraseType cached_passphrase_type_ = PassphraseType::IMPLICIT_PASSPHRASE;
-
-  // If an explicit passphrase is in use, the time at which the passphrase was
-  // first set (if available).
-  base::Time cached_explicit_passphrase_time_;
-
   invalidation::InvalidationService* invalidator_;
   bool invalidation_handler_registered_ = false;
 
   // Checks that we're on the same thread this was constructed on (UI thread).
   base::ThreadChecker thread_checker_;
 
   base::WeakPtrFactory<SyncBackendHostImpl> weak_ptr_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(SyncBackendHostImpl);
 };
 
 }  // namespace syncer
 
 #endif  // COMPONENTS_SYNC_DRIVER_GLUE_SYNC_BACKEND_HOST_IMPL_H_