[Sync] Implement keystore migration support.

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 100 matching lines @@
   virtual void OnPassphraseAccepted() OVERRIDE;
   virtual void OnBootstrapTokenUpdated(
       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;
+  virtual void OnPassphraseTypeChanged(syncer::PassphraseType type) OVERRIDE;
 
   // syncer::InvalidationHandler implementation.
   virtual void OnInvalidatorStateChange(
       syncer::InvalidatorState state) OVERRIDE;
   virtual void OnIncomingInvalidation(
       const syncer::ObjectIdStateMap& id_state_map,
       syncer::IncomingInvalidationSource source) OVERRIDE;
 
   // Note:
   //
@@ skipping 190 matching lines @@
       core_(new Core(name, profile_->GetPath().Append(kSyncDataFolderName),
                      weak_ptr_factory_.GetWeakPtr())),
       initialization_state_(NOT_ATTEMPTED),
       sync_prefs_(sync_prefs),
       invalidator_factory_(
           ParseNotifierOptions(*CommandLine::ForCurrentProcess(),
                                profile_->GetRequestContext()),
           content::GetUserAgent(GURL()),
           invalidator_storage),
       frontend_(NULL),
-      cached_passphrase_state_(syncer::IMPLICIT_PASSPHRASE) {
+      cached_passphrase_type_(syncer::IMPLICIT_PASSPHRASE) {
 }
 
 SyncBackendHost::SyncBackendHost(Profile* profile)
     : weak_ptr_factory_(ALLOW_THIS_IN_INITIALIZER_LIST(this)),
       sync_thread_("Chrome_SyncThread"),
       frontend_loop_(MessageLoop::current()),
       profile_(profile),
       name_("Unknown"),
       initialization_state_(NOT_ATTEMPTED),
       invalidator_factory_(
           ParseNotifierOptions(*CommandLine::ForCurrentProcess(),
                                profile_->GetRequestContext()),
           content::GetUserAgent(GURL()),
           base::WeakPtr<syncer::InvalidationStateTracker>()),
       frontend_(NULL),
-      cached_passphrase_state_(syncer::IMPLICIT_PASSPHRASE) {
+      cached_passphrase_type_(syncer::IMPLICIT_PASSPHRASE) {
 }
 
 SyncBackendHost::~SyncBackendHost() {
   DCHECK(!core_ && !frontend_) << "Must call Shutdown before destructor.";
   DCHECK(!chrome_sync_notification_bridge_.get());
   DCHECK(!registrar_.get());
 }
 
 namespace {
 
@@ skipping 404 matching lines @@
 }
 
 bool SyncBackendHost::IsUsingExplicitPassphrase() {
   // This should only be called once the nigori node has been downloaded, as
   // otherwise we have no idea what kind of passphrase we are using. This will
   // NOTREACH in sync_manager and return false if we fail to load the nigori
   // node.
   // TODO(zea): expose whether the custom passphrase is a frozen implicit
   // passphrase or not to provide better messaging.
   return IsNigoriEnabled() && (
-      cached_passphrase_state_ == syncer::CUSTOM_PASSPHRASE ||
-      cached_passphrase_state_ == syncer::FROZEN_IMPLICIT_PASSPHRASE);
+      cached_passphrase_type_ == syncer::CUSTOM_PASSPHRASE ||
+      cached_passphrase_type_ == syncer::FROZEN_IMPLICIT_PASSPHRASE);
 }
 
 bool SyncBackendHost::IsCryptographerReady(
     const syncer::BaseTransaction* trans) const {
   return initialized() && trans->GetCryptographer()->is_ready();
 }
 
 void SyncBackendHost::GetModelSafeRoutingInfo(
     syncer::ModelSafeRoutingInfo* out) const {
   if (initialized()) {
@@ skipping 227 matching lines @@
   host_.Call(
       FROM_HERE,
       &SyncBackendHost::NotifyEncryptionComplete);
 }
 
 void SyncBackendHost::Core::OnCryptographerStateChanged(
     syncer::Cryptographer* cryptographer) {
   // Do nothing.
 }
 
-void SyncBackendHost::Core::OnPassphraseStateChanged(
-    syncer::PassphraseState state) {
+void SyncBackendHost::Core::OnPassphraseTypeChanged(
+    syncer::PassphraseType type) {
   host_.Call(
       FROM_HERE,
-      &SyncBackendHost::HandlePassphraseStateChangedOnFrontendLoop,
-      state);
+      &SyncBackendHost::HandlePassphraseTypeChangedOnFrontendLoop,
+      type);
 }
 
 void SyncBackendHost::Core::OnActionableError(
     const syncer::SyncProtocolError& sync_error) {
   if (!sync_loop_)
     return;
   DCHECK_EQ(MessageLoop::current(), sync_loop_);
   host_.Call(
       FROM_HERE,
       &SyncBackendHost::HandleActionableErrorEventOnFrontendLoop,
@@ skipping 469 matching lines @@
 }
 
 void SyncBackendHost::NotifyEncryptionComplete() {
   if (!frontend_)
     return;
 
   DCHECK_EQ(MessageLoop::current(), frontend_loop_);
   frontend_->OnEncryptionComplete();
 }
 
-void SyncBackendHost::HandlePassphraseStateChangedOnFrontendLoop(
-    syncer::PassphraseState state) {
+void SyncBackendHost::HandlePassphraseTypeChangedOnFrontendLoop(
+    syncer::PassphraseType type) {
   DCHECK_EQ(MessageLoop::current(), frontend_loop_);
-  DVLOG(1) << "Passphrase state changed to "
-           << syncer::PassphraseStateToString(state);
-  cached_passphrase_state_ = state;
+  DVLOG(1) << "Passphrase type changed to "
+           << syncer::PassphraseTypeToString(type);
+  cached_passphrase_type_ = type;
 }
 
 void SyncBackendHost::HandleStopSyncingPermanentlyOnFrontendLoop() {
   if (!frontend_)
     return;
   frontend_->OnStopSyncingPermanently();
 }
 
 void SyncBackendHost::HandleConnectionStatusChangeOnFrontendLoop(
     syncer::ConnectionStatus status) {
   if (!frontend_)
     return;
 
   DCHECK_EQ(MessageLoop::current(), frontend_loop_);
 
   frontend_->OnConnectionStatusChange(status);
 }
 
 void SyncBackendHost::HandleNigoriConfigurationCompletedOnFrontendLoop(
     const syncer::ModelTypeSet failed_configuration_types) {
   HandleInitializationCompletedOnFrontendLoop(
       failed_configuration_types.Empty());
 }
 
 #undef SDVLOG
 
 #undef SLOG
 
 }  // namespace browser_sync