[Sync] Move keystore key handling to SyncEncryptionHandlerImpl

chrome/browser/sync/glue/sync_backend_host.cc

 // 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.
 
 #include "build/build_config.h"
 
 #include "chrome/browser/sync/glue/sync_backend_host.h"
 
 #include <algorithm>
 #include <map>
@@ skipping 91 matching lines @@
   virtual void OnUpdatedToken(const std::string& token) OVERRIDE;
   virtual void OnActionableError(
       const syncer::SyncProtocolError& sync_error) OVERRIDE;
 
   // SyncEncryptionHandler::Observer implementation.
   virtual void OnPassphraseRequired(
       syncer::PassphraseRequiredReason reason,
       const sync_pb::EncryptedData& pending_keys) OVERRIDE;
   virtual void OnPassphraseAccepted() OVERRIDE;
   virtual void OnBootstrapTokenUpdated(
-      const std::string& bootstrap_token) OVERRIDE;
+      const std::string& bootstrap_token,
+      syncer::BootstrapTokenType type) OVERRIDE;
   virtual void OnEncryptedTypesChanged(
       syncer::ModelTypeSet encrypted_types,
       bool encrypt_everything) OVERRIDE;
   virtual void OnEncryptionComplete() OVERRIDE;
   virtual void OnCryptographerStateChanged(
       syncer::Cryptographer* cryptographer) OVERRIDE;
   virtual void OnPassphraseStateChanged(syncer::PassphraseState state) OVERRIDE;
 
   // syncer::InvalidationHandler implementation.
   virtual void OnNotificationsEnabled() OVERRIDE;
@@ skipping 766 matching lines @@
   DCHECK(!sync_manager_.get());
   DCHECK(!sync_loop_);
 }
 
 void SyncBackendHost::Core::OnSyncCycleCompleted(
     const SyncSessionSnapshot& snapshot) {
   if (!sync_loop_)
     return;
   DCHECK_EQ(MessageLoop::current(), sync_loop_);
 
-  if (snapshot.model_neutral_state().last_get_key_result ==
-          syncer::SYNCER_OK) {
-    // If we just received a new keystore key, get it and make sure we update
-    // the bootstrap token with it.
-    std::string keystore_token;
-    sync_manager_->GetKeystoreKeyBootstrapToken(&keystore_token);
-    if (!keystore_token.empty()) {
-      DVLOG(1) << "Persisting keystore encryption bootstrap token.";
-      host_.Call(FROM_HERE,
-                 &SyncBackendHost::PersistEncryptionBootstrapToken,
-                 keystore_token,
-                 KEYSTORE_BOOTSTRAP_TOKEN);
-    } else {
-      NOTREACHED();
-    }
-  }
-
   host_.Call(
       FROM_HERE,
       &SyncBackendHost::HandleSyncCycleCompletedOnFrontendLoop,
       snapshot);
 }
 
 
 void SyncBackendHost::Core::OnInitializationComplete(
     const syncer::WeakHandle<syncer::JsBackend>& js_backend,
     bool success,
     const syncer::ModelTypeSet restored_types) {
   DCHECK_EQ(MessageLoop::current(), sync_loop_);
 
   if (!success) {
     DoDestroySyncManager();
+  } else {
+    // Register for encryption related changes now. We have to do this before
+    // the associate nigori state in order to receive notifications triggered
+    // by the initial download of the nigori node.
+    sync_manager_->GetEncryptionHandler()->AddObserver(this);
   }
 
   host_.Call(
       FROM_HERE,
       &SyncBackendHost::HandleSyncManagerInitializationOnFrontendLoop,
       js_backend, success, restored_types);
 
   if (success) {
     // Initialization is complete, so we can schedule recurring SaveChanges.
     sync_loop_->PostTask(FROM_HERE,
@@ skipping 25 matching lines @@
 void SyncBackendHost::Core::OnPassphraseAccepted() {
   if (!sync_loop_)
     return;
   DCHECK_EQ(MessageLoop::current(), sync_loop_);
   host_.Call(
       FROM_HERE,
       &SyncBackendHost::NotifyPassphraseAccepted);
 }
 
 void SyncBackendHost::Core::OnBootstrapTokenUpdated(
-    const std::string& bootstrap_token) {
+    const std::string& bootstrap_token,
+    syncer::BootstrapTokenType type) {
   if (!sync_loop_)
     return;
   DCHECK_EQ(MessageLoop::current(), sync_loop_);
   host_.Call(FROM_HERE,
              &SyncBackendHost::PersistEncryptionBootstrapToken,
              bootstrap_token,
-             PASSPHRASE_BOOTSTRAP_TOKEN);
+             type);
 }
 
 void SyncBackendHost::Core::OnStopSyncingPermanently() {
   if (!sync_loop_)
     return;
   DCHECK_EQ(MessageLoop::current(), sync_loop_);
   host_.Call(
       FROM_HERE,
       &SyncBackendHost::HandleStopSyncingPermanentlyOnFrontendLoop);
 }
@@ skipping 174 matching lines @@
 }
 
 void SyncBackendHost::Core::DoStartSyncing(
     const syncer::ModelSafeRoutingInfo& routing_info) {
   DCHECK_EQ(MessageLoop::current(), sync_loop_);
   sync_manager_->StartSyncingNormally(routing_info);
 }
 
 void SyncBackendHost::Core::DoAssociateNigori() {
   DCHECK_EQ(MessageLoop::current(), sync_loop_);
-  sync_manager_->GetEncryptionHandler()->AddObserver(this);
   sync_manager_->GetEncryptionHandler()->Init();
   host_.Call(FROM_HERE,
-             &SyncBackendHost::HandlePassphraseStateChangedOnFrontendLoop,
-             sync_manager_->GetEncryptionHandler()->GetPassphraseState());
-  host_.Call(FROM_HERE,
              &SyncBackendHost::HandleInitializationCompletedOnFrontendLoop,
              true);
 }
 
 void SyncBackendHost::Core::DoSetEncryptionPassphrase(
     const std::string& passphrase,
     bool is_explicit) {
   DCHECK_EQ(MessageLoop::current(), sync_loop_);
   sync_manager_->GetEncryptionHandler()->SetEncryptionPassphrase(
       passphrase, is_explicit);
@@ skipping 227 matching lines @@
 }
 
 void SyncBackendHost::RetryConfigurationOnFrontendLoop(
     const base::Closure& retry_callback) {
   SDVLOG(1) << "Failed to complete configuration, informing of retry.";
   retry_callback.Run();
 }
 
 void SyncBackendHost::PersistEncryptionBootstrapToken(
     const std::string& token,
-    BootstrapTokenType token_type) {
+    syncer::BootstrapTokenType token_type) {
   CHECK(sync_prefs_.get());
   DCHECK(!token.empty());
-  if (token_type == PASSPHRASE_BOOTSTRAP_TOKEN)
+  if (token_type == syncer::PASSPHRASE_BOOTSTRAP_TOKEN)
     sync_prefs_->SetEncryptionBootstrapToken(token);
   else
     sync_prefs_->SetKeystoreEncryptionBootstrapToken(token);
 }
 
 void SyncBackendHost::HandleActionableErrorEventOnFrontendLoop(
     const syncer::SyncProtocolError& sync_error) {
   if (!frontend_)
     return;
   DCHECK_EQ(MessageLoop::current(), frontend_loop_);
@@ skipping 117 matching lines @@
     const syncer::ModelTypeSet failed_configuration_types) {
   HandleInitializationCompletedOnFrontendLoop(
       failed_configuration_types.Empty());
 }
 
 #undef SDVLOG
 
 #undef SLOG
 
 }  // namespace browser_sync