Thread-safe version of PassphraseType.

components/sync/core_impl/sync_manager_impl_unittest.cc

 // Copyright 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.
 
 // Unit tests for the SyncApi. Note that a lot of the underlying
 // functionality is provided by the Syncable layer, which has its own
 // unit tests. We'll test SyncApi specific things in this harness.
 
 #include "components/sync/core_impl/sync_manager_impl.h"
 
@@ skipping 237 matching lines @@
   // tombstone.
   void ReplaceWithTombstone(const ModelType& model_type,
                             const std::string& client_tag);
 
   // Save changes to the Directory, destroy it then reload it.
   bool ReloadDir();
 
   UserShare* user_share();
   syncable::Directory* dir();
   SyncEncryptionHandler* encryption_handler();
+  PassphraseType GetPassphraseType(BaseTransaction* trans);
 
  private:
   base::MessageLoop message_loop_;
   TestUserShare test_user_share_;
 };
 
 UserShare* SyncApiTest::user_share() {
   return test_user_share_.user_share();
 }
 
 syncable::Directory* SyncApiTest::dir() {
   return test_user_share_.user_share()->directory.get();
 }
 
 SyncEncryptionHandler* SyncApiTest::encryption_handler() {
   return test_user_share_.encryption_handler();
 }
 
+PassphraseType SyncApiTest::GetPassphraseType(BaseTransaction* trans) {
+  return dir()->GetNigoriHandler()->GetPassphraseType(trans->GetWrappedTrans());
+}
+
 bool SyncApiTest::ReloadDir() {
   return test_user_share_.Reload();
 }
 
 void SyncApiTest::CreateEntryWithAttachmentMetadata(
     const ModelType& model_type,
     const std::string& client_tag,
     const sync_pb::AttachmentMetadata& attachment_metadata) {
   syncer::WriteTransaction trans(FROM_HERE, user_share());
   syncer::ReadNode root_node(&trans);
@@ skipping 835 matching lines @@
   ModelTypeSet GetEncryptedTypes() {
     ReadTransaction trans(FROM_HERE, sync_manager_.GetUserShare());
     return GetEncryptedTypesWithTrans(&trans);
   }
 
   ModelTypeSet GetEncryptedTypesWithTrans(BaseTransaction* trans) {
     return trans->GetDirectory()->GetNigoriHandler()->GetEncryptedTypes(
         trans->GetWrappedTrans());
   }
 
+  PassphraseType GetPassphraseType() {
+    ReadTransaction trans(FROM_HERE, sync_manager_.GetUserShare());
+    return GetPassphraseTypeWithTrans(&trans);
+  }
+
+  PassphraseType GetPassphraseTypeWithTrans(BaseTransaction* trans) {
+    return trans->GetDirectory()->GetNigoriHandler()->GetPassphraseType(
+        trans->GetWrappedTrans());
+  }
+
   void SimulateInvalidatorEnabledForTest(bool is_enabled) {
     DCHECK(sync_manager_.thread_checker_.CalledOnValidThread());
     sync_manager_.SetInvalidatorEnabled(is_enabled);
   }
 
   void SetProgressMarkerForType(ModelType type, bool set) {
     if (set) {
       sync_pb::DataTypeProgressMarker marker;
       marker.set_token("token");
       marker.set_data_type_id(GetSpecificsFieldNumberFromModelType(type));
       sync_manager_.directory()->SetDownloadProgress(type, marker);
     } else {
       sync_pb::DataTypeProgressMarker marker;
       sync_manager_.directory()->SetDownloadProgress(type, marker);
     }
   }
 
   InternalComponentsFactory::Switches GetSwitches() const { return switches_; }
 
   void ExpectPassphraseAcceptance() {
     EXPECT_CALL(encryption_observer_, OnPassphraseAccepted());
     EXPECT_CALL(encryption_observer_, OnEncryptionComplete());
     EXPECT_CALL(encryption_observer_, OnCryptographerStateChanged(_));
   }
 
   void SetImplicitPassphraseAndCheck(const std::string& passphrase) {
     sync_manager_.GetEncryptionHandler()->SetEncryptionPassphrase(passphrase,
                                                                   false);
-    EXPECT_EQ(PassphraseType::IMPLICIT_PASSPHRASE,
-              sync_manager_.GetEncryptionHandler()->GetPassphraseType());
+    EXPECT_EQ(PassphraseType::IMPLICIT_PASSPHRASE, GetPassphraseType());
   }
 
   void SetCustomPassphraseAndCheck(const std::string& passphrase) {
     EXPECT_CALL(encryption_observer_,
                 OnPassphraseTypeChanged(PassphraseType::CUSTOM_PASSPHRASE, _));
     sync_manager_.GetEncryptionHandler()->SetEncryptionPassphrase(passphrase,
                                                                   true);
-    EXPECT_EQ(PassphraseType::CUSTOM_PASSPHRASE,
-              sync_manager_.GetEncryptionHandler()->GetPassphraseType());
+    EXPECT_EQ(PassphraseType::CUSTOM_PASSPHRASE, GetPassphraseType());
   }
 
   bool HasUnrecoverableError() {
     return mock_unrecoverable_error_handler_.invocation_count() > 0;
   }
 
  private:
   // Needed by |sync_manager_|.
   base::MessageLoop message_loop_;
   // Needed by |sync_manager_|.
@@ skipping 312 matching lines @@
     sync_pb::NigoriSpecifics nigori;
     other_cryptographer.GetKeys(nigori.mutable_encryption_keybag());
     cryptographer->SetPendingKeys(nigori.encryption_keybag());
     EXPECT_TRUE(cryptographer->has_pending_keys());
     node.SetNigoriSpecifics(nigori);
   }
   EXPECT_CALL(encryption_observer_,
               OnBootstrapTokenUpdated(_, PASSPHRASE_BOOTSTRAP_TOKEN));
   ExpectPassphraseAcceptance();
   sync_manager_.GetEncryptionHandler()->SetDecryptionPassphrase("passphrase2");
-  EXPECT_EQ(PassphraseType::IMPLICIT_PASSPHRASE,
-            sync_manager_.GetEncryptionHandler()->GetPassphraseType());
+  EXPECT_EQ(PassphraseType::IMPLICIT_PASSPHRASE, GetPassphraseType());
   EXPECT_FALSE(IsEncryptEverythingEnabledForTest());
   {
     ReadTransaction trans(FROM_HERE, sync_manager_.GetUserShare());
     Cryptographer* cryptographer = trans.GetCryptographer();
     EXPECT_TRUE(cryptographer->is_ready());
     // Verify we're encrypting with the new key.
     sync_pb::EncryptedData encrypted;
     cryptographer->GetKeys(&encrypted);
     EXPECT_TRUE(other_cryptographer.CanDecrypt(encrypted));
   }
@@ skipping 104 matching lines @@
   EXPECT_CALL(encryption_observer_, OnCryptographerStateChanged(_));
   EXPECT_CALL(encryption_observer_,
               OnPassphraseTypeChanged(PassphraseType::CUSTOM_PASSPHRASE, _));
   EXPECT_CALL(encryption_observer_, OnPassphraseRequired(_, _));
   EXPECT_CALL(encryption_observer_, OnEncryptedTypesChanged(_, false));
   sync_manager_.GetEncryptionHandler()->Init();
   EXPECT_CALL(encryption_observer_,
               OnBootstrapTokenUpdated(_, PASSPHRASE_BOOTSTRAP_TOKEN));
   ExpectPassphraseAcceptance();
   sync_manager_.GetEncryptionHandler()->SetDecryptionPassphrase("explicit");
-  EXPECT_EQ(PassphraseType::CUSTOM_PASSPHRASE,
-            sync_manager_.GetEncryptionHandler()->GetPassphraseType());
+  EXPECT_EQ(PassphraseType::CUSTOM_PASSPHRASE, GetPassphraseType());
   EXPECT_FALSE(IsEncryptEverythingEnabledForTest());
   {
     ReadTransaction trans(FROM_HERE, sync_manager_.GetUserShare());
     Cryptographer* cryptographer = trans.GetCryptographer();
     EXPECT_TRUE(cryptographer->is_ready());
     // Verify we're encrypting with the new key.
     sync_pb::EncryptedData encrypted;
     cryptographer->GetKeys(&encrypted);
     EXPECT_TRUE(other_cryptographer.CanDecrypt(encrypted));
   }
@@ skipping 1702 matching lines @@
 // SyncManagerInitInvalidStorageTest::GetFactory will return
 // DirectoryBackingStore that ensures that SyncManagerImpl::OpenDirectory fails.
 // SyncManagerImpl initialization is done in SyncManagerTest::SetUp. This test's
 // task is to ensure that SyncManagerImpl reported initialization failure in
 // OnInitializationComplete callback.
 TEST_F(SyncManagerInitInvalidStorageTest, FailToOpenDatabase) {
   EXPECT_FALSE(initialization_succeeded_);
 }
 
 }  // namespace syncer