[Sync] Refactor passphrase state handling

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 30 matching lines @@
 #include "jingle/notifier/base/notifier_options.h"
 #include "net/base/host_port_pair.h"
 #include "net/url_request/url_request_context_getter.h"
 #include "sync/internal_api/public/base_transaction.h"
 #include "sync/internal_api/public/engine/model_safe_worker.h"
 #include "sync/internal_api/public/http_bridge.h"
 #include "sync/internal_api/public/internal_components_factory_impl.h"
 #include "sync/internal_api/public/read_transaction.h"
 #include "sync/internal_api/public/sync_manager_factory.h"
 #include "sync/internal_api/public/util/experiments.h"
+#include "sync/internal_api/public/util/sync_string_conversions.h"
 #include "sync/notifier/sync_notifier.h"
 #include "sync/protocol/encryption.pb.h"
 #include "sync/protocol/sync.pb.h"
 #include "sync/util/nigori.h"
 
 static const int kSaveChangesIntervalSeconds = 10;
 static const FilePath::CharType kSyncDataFolderName[] =
     FILE_PATH_LITERAL("Sync Data");
 
 typedef TokenService::TokenAvailableDetails TokenAvailableDetails;
@@ skipping 47 matching lines @@
       const sync_pb::EncryptedData& pending_keys) OVERRIDE;
   virtual void OnPassphraseAccepted() OVERRIDE;
   virtual void OnBootstrapTokenUpdated(
       const std::string& bootstrap_token) 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;
   virtual void OnNotificationsDisabled(
       syncer::NotificationsDisabledReason reason) OVERRIDE;
   virtual void OnIncomingNotification(
       const syncer::ObjectIdStateMap& id_state_map,
       syncer::IncomingNotificationSource source) OVERRIDE;
 
   // Note:
@@ skipping 190 matching lines @@
       name_(name),
       core_(new Core(name, profile_->GetPath().Append(kSyncDataFolderName),
                      weak_ptr_factory_.GetWeakPtr())),
       initialization_state_(NOT_ATTEMPTED),
       sync_prefs_(sync_prefs),
       sync_notifier_factory_(
           ParseNotifierOptions(*CommandLine::ForCurrentProcess(),
                                profile_->GetRequestContext()),
           content::GetUserAgent(GURL()),
           invalidator_storage),
-      frontend_(NULL) {
+      frontend_(NULL),
+      cached_passphrase_state_(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),
       sync_notifier_factory_(
           ParseNotifierOptions(*CommandLine::ForCurrentProcess(),
                                profile_->GetRequestContext()),
           content::GetUserAgent(GURL()),
           base::WeakPtr<syncer::InvalidationStateTracker>()),
-      frontend_(NULL) {
+      frontend_(NULL),
+      cached_passphrase_state_(syncer::IMPLICIT_PASSPHRASE) {
 }
 
 SyncBackendHost::~SyncBackendHost() {
   DCHECK(!core_ && !frontend_) << "Must call Shutdown before destructor.";
   DCHECK(!chrome_sync_notification_bridge_.get());
   DCHECK(!registrar_.get());
 }
 
 namespace {
 
@@ skipping 401 matching lines @@
 
 bool SyncBackendHost::IsNigoriEnabled() const {
   return registrar_.get() && registrar_->IsNigoriEnabled();
 }
 
 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): cache this value here, then make the encryption handler
-  // NonThreadSafe and only accessible from the sync thread.
-  return IsNigoriEnabled() &&
-      core_->sync_manager()->GetEncryptionHandler()->
-          IsUsingExplicitPassphrase();
+  // 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);
 }
 
 bool SyncBackendHost::IsCryptographerReady(
     const syncer::BaseTransaction* trans) const {
   return initialized() && trans->GetCryptographer()->is_ready();
 }
 
 void SyncBackendHost::GetModelSafeRoutingInfo(
     syncer::ModelSafeRoutingInfo* out) const {
   if (initialized()) {
@@ skipping 238 matching lines @@
   host_.Call(
       FROM_HERE,
       &SyncBackendHost::NotifyEncryptionComplete);
 }
 
 void SyncBackendHost::Core::OnCryptographerStateChanged(
     syncer::Cryptographer* cryptographer) {
   // Do nothing.
 }
 
+void SyncBackendHost::Core::OnPassphraseStateChanged(
+    syncer::PassphraseState state) {
+  host_.Call(
+      FROM_HERE,
+      &SyncBackendHost::HandlePassphraseStateChangedOnFrontendLoop,
+      state);
+}
+
 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,
       sync_error);
 }
@@ skipping 121 matching lines @@
     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 333 matching lines @@
 }
 
 void SyncBackendHost::NotifyEncryptionComplete() {
   if (!frontend_)
     return;
 
   DCHECK_EQ(MessageLoop::current(), frontend_loop_);
   frontend_->OnEncryptionComplete();
 }
 
+void SyncBackendHost::HandlePassphraseStateChangedOnFrontendLoop(
+    syncer::PassphraseState state) {
+  DCHECK_EQ(MessageLoop::current(), frontend_loop_);
+  DVLOG(1) << "Passphrase state changed to "
+           << syncer::PassphraseStateToString(state);
+  cached_passphrase_state_ = state;
+}
+
 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