[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::SyncNotifierObserver 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,
@@ skipping 40 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 427 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