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

components/sync/driver/glue/sync_backend_host_impl.cc

 // 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.
 
 #include "components/sync/driver/glue/sync_backend_host_impl.h"
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/command_line.h"
@@ skipping 88 matching lines @@
   SDVLOG(1) << "SyncBackendHostImpl::StartSyncingWithServer called.";
 
   sync_task_runner_->PostTask(
       FROM_HERE, base::Bind(&SyncBackendHostCore::DoStartSyncing, core_,
                             sync_prefs_->GetLastPollTime()));
 }
 
 void SyncBackendHostImpl::SetEncryptionPassphrase(const std::string& passphrase,
                                                   bool is_explicit) {
   DCHECK(thread_checker_.CalledOnValidThread());
-
-  if (!IsNigoriEnabled()) {
-    NOTREACHED() << "SetEncryptionPassphrase must never be called when nigori"
-                    " is disabled.";
-    return;
-  }
-
-  // We should never be called with an empty passphrase.
-  DCHECK(!passphrase.empty());
-
-  // SetEncryptionPassphrase should never be called if we are currently
-  // encrypted with an explicit passphrase.
-  DCHECK(cached_passphrase_type_ == PassphraseType::KEYSTORE_PASSPHRASE ||
-         cached_passphrase_type_ == PassphraseType::IMPLICIT_PASSPHRASE);
-
-  // Post an encryption task on the syncer thread.
   sync_task_runner_->PostTask(
       FROM_HERE, base::Bind(&SyncBackendHostCore::DoSetEncryptionPassphrase,
                             core_, passphrase, is_explicit));
 }
 
-bool SyncBackendHostImpl::SetDecryptionPassphrase(
+void SyncBackendHostImpl::SetDecryptionPassphrase(
     const std::string& passphrase) {
   DCHECK(thread_checker_.CalledOnValidThread());
-
-  if (!IsNigoriEnabled()) {
-    NOTREACHED() << "SetDecryptionPassphrase must never be called when nigori"
-                    " is disabled.";
-    return false;
-  }
-
-  // We should never be called with an empty passphrase.
-  DCHECK(!passphrase.empty());
-
-  // This should only be called when we have cached pending keys.
-  DCHECK(cached_pending_keys_.has_blob());
-
-  // Check the passphrase that was provided against our local cache of the
-  // cryptographer's pending keys. If this was unsuccessful, the UI layer can
-  // immediately call OnPassphraseRequired without showing the user a spinner.
-  if (!CheckPassphraseAgainstCachedPendingKeys(passphrase))
-    return false;
-
-  // Post a decryption task on the syncer thread.
   sync_task_runner_->PostTask(
       FROM_HERE, base::Bind(&SyncBackendHostCore::DoSetDecryptionPassphrase,
                             core_, passphrase));
-
-  // Since we were able to decrypt the cached pending keys with the passphrase
-  // provided, we immediately alert the UI layer that the passphrase was
-  // accepted. This will avoid the situation where a user enters a passphrase,
-  // clicks OK, immediately reopens the advanced settings dialog, and gets an
-  // unnecessary prompt for a passphrase.
-  // Note: It is not guaranteed that the passphrase will be accepted by the
-  // syncer thread, since we could receive a new nigori node while the task is
-  // pending. This scenario is a valid race, and SetDecryptionPassphrase can
-  // trigger a new OnPassphraseRequired if it needs to.
-  NotifyPassphraseAccepted();
-  return true;
 }
 
 void SyncBackendHostImpl::StopSyncingForShutdown() {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   // Stop getting messages from the sync thread.
   weak_ptr_factory_.InvalidateWeakPtrs();
   // Immediately stop sending messages to the host.
   host_ = nullptr;
 
@@ skipping 82 matching lines @@
 SyncBackendHostImpl::Status SyncBackendHostImpl::GetDetailedStatus() {
   DCHECK(initialized());
   return core_->sync_manager()->GetDetailedStatus();
 }
 
 bool SyncBackendHostImpl::HasUnsyncedItems() const {
   DCHECK(initialized());
   return core_->sync_manager()->HasUnsyncedItems();
 }
 
-bool SyncBackendHostImpl::IsNigoriEnabled() const {
-  return registrar_ && registrar_->IsNigoriEnabled();
-}
-
-PassphraseType SyncBackendHostImpl::GetPassphraseType() const {
-  return cached_passphrase_type_;
-}
-
-base::Time SyncBackendHostImpl::GetExplicitPassphraseTime() const {
-  return cached_explicit_passphrase_time_;
-}
-
 bool SyncBackendHostImpl::IsCryptographerReady(
     const BaseTransaction* trans) const {
   return initialized() && trans->GetCryptographer() &&
          trans->GetCryptographer()->is_ready();
 }
 
 void SyncBackendHostImpl::GetModelSafeRoutingInfo(
     ModelSafeRoutingInfo* out) const {
   if (initialized()) {
     CHECK(registrar_);
@@ skipping 107 matching lines @@
     host_->OnSyncCycleCompleted(snapshot);
   }
 }
 
 void SyncBackendHostImpl::RetryConfigurationOnFrontendLoop(
     const base::Closure& retry_callback) {
   SDVLOG(1) << "Failed to complete configuration, informing of retry.";
   retry_callback.Run();
 }
 
-void SyncBackendHostImpl::PersistEncryptionBootstrapToken(
-    const std::string& token,
-    BootstrapTokenType token_type) {
-  CHECK(sync_prefs_.get());
-  if (token_type == PASSPHRASE_BOOTSTRAP_TOKEN)
-    sync_prefs_->SetEncryptionBootstrapToken(token);
-  else
-    sync_prefs_->SetKeystoreEncryptionBootstrapToken(token);
-}
-
 void SyncBackendHostImpl::HandleActionableErrorEventOnFrontendLoop(
     const SyncProtocolError& sync_error) {
   DCHECK(thread_checker_.CalledOnValidThread());
   host_->OnActionableError(sync_error);
 }
 
 void SyncBackendHostImpl::HandleMigrationRequestedOnFrontendLoop(
     ModelTypeSet types) {
   DCHECK(thread_checker_.CalledOnValidThread());
   host_->OnMigrationNeededForTypes(types);
 }
 
 void SyncBackendHostImpl::OnInvalidatorStateChange(InvalidatorState state) {
   sync_task_runner_->PostTask(
       FROM_HERE, base::Bind(&SyncBackendHostCore::DoOnInvalidatorStateChange,
                             core_, state));
 }
 
 void SyncBackendHostImpl::OnIncomingInvalidation(
     const ObjectIdInvalidationMap& invalidation_map) {
   sync_task_runner_->PostTask(
       FROM_HERE, base::Bind(&SyncBackendHostCore::DoOnIncomingInvalidation,
                             core_, invalidation_map));
 }
 
 std::string SyncBackendHostImpl::GetOwnerName() const {
   return "SyncBackendHostImpl";
 }
 
-bool SyncBackendHostImpl::CheckPassphraseAgainstCachedPendingKeys(
-    const std::string& passphrase) const {
-  DCHECK(cached_pending_keys_.has_blob());
-  DCHECK(!passphrase.empty());
-  Nigori nigori;
-  nigori.InitByDerivation("localhost", "dummy", passphrase);
-  std::string plaintext;
-  bool result = nigori.Decrypt(cached_pending_keys_.blob(), &plaintext);
-  DVLOG_IF(1, result) << "Passphrase failed to decrypt pending keys.";
-  return result;
-}
-
-void SyncBackendHostImpl::NotifyPassphraseRequired(
-    PassphraseRequiredReason reason,
-    sync_pb::EncryptedData pending_keys) {
-  DCHECK(thread_checker_.CalledOnValidThread());
-
-  // Update our cache of the cryptographer's pending keys.
-  cached_pending_keys_ = pending_keys;
-
-  host_->OnPassphraseRequired(reason, pending_keys);
-}
-
-void SyncBackendHostImpl::NotifyPassphraseAccepted() {
-  DCHECK(thread_checker_.CalledOnValidThread());
-  // Clear our cache of the cryptographer's pending keys.
-  cached_pending_keys_.clear_blob();
-  host_->OnPassphraseAccepted();
-}
-
-void SyncBackendHostImpl::NotifyEncryptedTypesChanged(
-    ModelTypeSet encrypted_types,
-    bool encrypt_everything) {
-  DCHECK(thread_checker_.CalledOnValidThread());
-  host_->OnEncryptedTypesChanged(encrypted_types, encrypt_everything);
-}
-
-void SyncBackendHostImpl::NotifyEncryptionComplete() {
-  DCHECK(thread_checker_.CalledOnValidThread());
-  host_->OnEncryptionComplete();
-}
-
-void SyncBackendHostImpl::HandlePassphraseTypeChangedOnFrontendLoop(
-    PassphraseType type,
-    base::Time explicit_passphrase_time) {
-  DCHECK(thread_checker_.CalledOnValidThread());
-  DVLOG(1) << "Passphrase type changed to " << PassphraseTypeToString(type);
-  cached_passphrase_type_ = type;
-  cached_explicit_passphrase_time_ = explicit_passphrase_time;
-}
-
-void SyncBackendHostImpl::HandleLocalSetPassphraseEncryptionOnFrontendLoop(
-    const SyncEncryptionHandler::NigoriState& nigori_state) {
-  DCHECK(thread_checker_.CalledOnValidThread());
-  host_->OnLocalSetPassphraseEncryption(nigori_state);
-}
-
 void SyncBackendHostImpl::HandleConnectionStatusChangeOnFrontendLoop(
     ConnectionStatus status) {
   DCHECK(thread_checker_.CalledOnValidThread());
   DVLOG(1) << "Connection status changed: " << ConnectionStatusToString(status);
   host_->OnConnectionStatusChange(status);
 }
 
 void SyncBackendHostImpl::HandleProtocolEventOnFrontendLoop(
     std::unique_ptr<ProtocolEvent> event) {
   DCHECK(thread_checker_.CalledOnValidThread());
@@ skipping 54 matching lines @@
     const SyncManager::ClearServerDataCallback& frontend_callback) {
   DCHECK(thread_checker_.CalledOnValidThread());
   frontend_callback.Run();
 }
 
 }  // namespace syncer
 
 #undef SDVLOG
 
 #undef SLOG