[Sync] Refactor GetEncryptedTypes usage.

sync/engine/apply_updates_command_unittest.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 <string>
 
 #include "base/format_macros.h"
 #include "base/location.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/stringprintf.h"
@@ skipping 47 matching lines @@
     workers()->push_back(
         make_scoped_refptr(new FakeModelWorker(GROUP_UI)));
     workers()->push_back(
         make_scoped_refptr(new FakeModelWorker(GROUP_PASSWORD)));
     (*mutable_routing_info())[BOOKMARKS] = GROUP_UI;
     (*mutable_routing_info())[PASSWORDS] = GROUP_PASSWORD;
     (*mutable_routing_info())[NIGORI] = GROUP_PASSIVE;
     SyncerCommandTest::SetUp();
     entry_factory_.reset(new TestEntryFactory(directory()));
     ExpectNoGroupsToChange(apply_updates_command_);
-
-    syncable::ReadTransaction trans(FROM_HERE, directory());
-    directory()->GetCryptographer(&trans)->SetNigoriHandler(
-        &fake_encryption_handler_);
-    fake_encryption_handler_.set_cryptographer(
-        directory()->GetCryptographer(&trans));
   }
 
  protected:
   DISALLOW_COPY_AND_ASSIGN(ApplyUpdatesCommandTest);
 
   ApplyUpdatesCommand apply_updates_command_;
-  FakeEncryptor encryptor_;
   TestIdFactory id_factory_;
   scoped_ptr<TestEntryFactory> entry_factory_;
-  FakeSyncEncryptionHandler fake_encryption_handler_;
 };
 
 TEST_F(ApplyUpdatesCommandTest, Simple) {
   string root_server_id = syncable::GetNullId().GetServerId();
   entry_factory_->CreateUnappliedNewItemWithParent("parent",
                                                    DefaultBookmarkSpecifics(),
                                                    root_server_id);
   entry_factory_->CreateUnappliedNewItemWithParent("child",
                                                    DefaultBookmarkSpecifics(),
                                                    "parent");
@@ skipping 365 matching lines @@
         << "conflict";
     EXPECT_EQ(1, status->conflict_progress()->EncryptionConflictingItemsSize())
         << "The updates that can't be decrypted should be in encryption "
         << "conflict";
     EXPECT_EQ(0, status->update_progress()->SuccessfullyAppliedUpdateCount())
         << "No update that can't be decrypted should be applied";
   }
 }
 
 TEST_F(ApplyUpdatesCommandTest, SomeUndecryptablePassword) {
+  Cryptographer* cryptographer;
   // Only decryptable password updates should be applied.
   {
     sync_pb::EntitySpecifics specifics;
     sync_pb::PasswordSpecificsData data;
     data.set_origin("http://example.com/1");
     {
       syncable::ReadTransaction trans(FROM_HERE, directory());
-      Cryptographer* cryptographer = directory()->GetCryptographer(&trans);
+      cryptographer = directory()->GetCryptographer(&trans);
 
       KeyParams params = {"localhost", "dummy", "foobar"};
       cryptographer->AddKey(params);
 
       cryptographer->Encrypt(data,
           specifics.mutable_password()->mutable_encrypted());
     }
     entry_factory_->CreateUnappliedNewItem("item1", specifics, false);
   }
   {
     // Create a new cryptographer, independent of the one in the session.
-    Cryptographer cryptographer(&encryptor_);
+    Cryptographer other_cryptographer(cryptographer->encryptor());
     KeyParams params = {"localhost", "dummy", "bazqux"};
-    cryptographer.AddKey(params);
+    other_cryptographer.AddKey(params);
 
     sync_pb::EntitySpecifics specifics;
     sync_pb::PasswordSpecificsData data;
     data.set_origin("http://example.com/2");
 
-    cryptographer.Encrypt(data,
+    other_cryptographer.Encrypt(data,
         specifics.mutable_password()->mutable_encrypted());
     entry_factory_->CreateUnappliedNewItem("item2", specifics, false);
   }
 
   ExpectGroupToChange(apply_updates_command_, GROUP_PASSWORD);
   apply_updates_command_.ExecuteImpl(session());
 
   sessions::StatusController* status = session()->mutable_status_controller();
   EXPECT_TRUE(status->HasConflictingUpdates())
     << "Updates that can't be decrypted should trigger the syncer to have "
@@ skipping 18 matching lines @@
 TEST_F(ApplyUpdatesCommandTest, NigoriUpdate) {
   // Storing the cryptographer separately is bad, but for this test we
   // know it's safe.
   Cryptographer* cryptographer;
   ModelTypeSet encrypted_types;
   encrypted_types.Put(PASSWORDS);
   encrypted_types.Put(NIGORI);
   {
     syncable::ReadTransaction trans(FROM_HERE, directory());
     cryptographer = directory()->GetCryptographer(&trans);
-    EXPECT_TRUE(cryptographer->GetEncryptedTypes().Equals(encrypted_types));
+    EXPECT_TRUE(directory()->GetNigoriHandler()->GetEncryptedTypes(&trans)
+        .Equals(encrypted_types));
   }
 
   // Nigori node updates should update the Cryptographer.
-  Cryptographer other_cryptographer(&encryptor_);
+  Cryptographer other_cryptographer(cryptographer->encryptor());
   KeyParams params = {"localhost", "dummy", "foobar"};
   other_cryptographer.AddKey(params);
 
   sync_pb::EntitySpecifics specifics;
   sync_pb::NigoriSpecifics* nigori = specifics.mutable_nigori();
   other_cryptographer.GetKeys(nigori->mutable_encrypted());
   nigori->set_encrypt_everything(true);
   entry_factory_->CreateUnappliedNewItem(
       ModelTypeToRootTag(NIGORI), specifics, true);
   EXPECT_FALSE(cryptographer->has_pending_keys());
 
   ExpectGroupToChange(apply_updates_command_, GROUP_PASSIVE);
   apply_updates_command_.ExecuteImpl(session());
 
   sessions::StatusController* status = session()->mutable_status_controller();
   sessions::ScopedModelSafeGroupRestriction r(status, GROUP_PASSIVE);
   ASSERT_TRUE(status->update_progress());
   EXPECT_EQ(1, status->update_progress()->AppliedUpdatesSize())
       << "All updates should have been attempted";
   ASSERT_TRUE(status->conflict_progress());
   EXPECT_EQ(0, status->conflict_progress()->SimpleConflictingItemsSize())
       << "The nigori update shouldn't be in conflict";
   EXPECT_EQ(1, status->update_progress()->SuccessfullyAppliedUpdateCount())
       << "The nigori update should be applied";
 
   EXPECT_FALSE(cryptographer->is_ready());
   EXPECT_TRUE(cryptographer->has_pending_keys());
-  EXPECT_TRUE(cryptographer->GetEncryptedTypes().Equals(ModelTypeSet::All()));
+  {
+    syncable::ReadTransaction trans(FROM_HERE, directory());
+    EXPECT_TRUE(directory()->GetNigoriHandler()->GetEncryptedTypes(&trans)
+        .Equals(ModelTypeSet::All()));
+  }
 }
 
 TEST_F(ApplyUpdatesCommandTest, NigoriUpdateForDisabledTypes) {
   // Storing the cryptographer separately is bad, but for this test we
   // know it's safe.
   Cryptographer* cryptographer;
   ModelTypeSet encrypted_types;
   encrypted_types.Put(PASSWORDS);
   encrypted_types.Put(NIGORI);
   {
     syncable::ReadTransaction trans(FROM_HERE, directory());
     cryptographer = directory()->GetCryptographer(&trans);
-    EXPECT_TRUE(cryptographer->GetEncryptedTypes().Equals(encrypted_types));
+    EXPECT_TRUE(directory()->GetNigoriHandler()->GetEncryptedTypes(&trans)
+        .Equals(encrypted_types));
   }
 
   // Nigori node updates should update the Cryptographer.
-  Cryptographer other_cryptographer(&encryptor_);
+  Cryptographer other_cryptographer(cryptographer->encryptor());
   KeyParams params = {"localhost", "dummy", "foobar"};
   other_cryptographer.AddKey(params);
 
   sync_pb::EntitySpecifics specifics;
   sync_pb::NigoriSpecifics* nigori = specifics.mutable_nigori();
   other_cryptographer.GetKeys(nigori->mutable_encrypted());
   nigori->set_encrypt_everything(true);
   entry_factory_->CreateUnappliedNewItem(
       ModelTypeToRootTag(NIGORI), specifics, true);
   EXPECT_FALSE(cryptographer->has_pending_keys());
 
   ExpectGroupToChange(apply_updates_command_, GROUP_PASSIVE);
   apply_updates_command_.ExecuteImpl(session());
 
   sessions::StatusController* status = session()->mutable_status_controller();
   sessions::ScopedModelSafeGroupRestriction r(status, GROUP_PASSIVE);
   ASSERT_TRUE(status->update_progress());
   EXPECT_EQ(1, status->update_progress()->AppliedUpdatesSize())
       << "All updates should have been attempted";
   ASSERT_TRUE(status->conflict_progress());
   EXPECT_EQ(0, status->conflict_progress()->SimpleConflictingItemsSize())
       << "The nigori update shouldn't be in conflict";
   EXPECT_EQ(1, status->update_progress()->SuccessfullyAppliedUpdateCount())
       << "The nigori update should be applied";
 
   EXPECT_FALSE(cryptographer->is_ready());
   EXPECT_TRUE(cryptographer->has_pending_keys());
-  EXPECT_TRUE(cryptographer->GetEncryptedTypes().Equals(ModelTypeSet::All()));
+  {
+    syncable::ReadTransaction trans(FROM_HERE, directory());
+    EXPECT_TRUE(directory()->GetNigoriHandler()->GetEncryptedTypes(&trans)
+        .Equals(ModelTypeSet::All()));
+  }
 }
 
 // Create some local unsynced and unencrypted data. Apply a nigori update that
 // turns on encryption for the unsynced data. Ensure we properly encrypt the
 // data as part of the nigori update. Apply another nigori update with no
 // changes. Ensure we ignore already-encrypted unsynced data and that nothing
 // breaks.
 TEST_F(ApplyUpdatesCommandTest, EncryptUnsyncedChanges) {
   // Storing the cryptographer separately is bad, but for this test we
   // know it's safe.
   Cryptographer* cryptographer;
   ModelTypeSet encrypted_types;
   encrypted_types.Put(PASSWORDS);
   encrypted_types.Put(NIGORI);
   {
     syncable::ReadTransaction trans(FROM_HERE, directory());
     cryptographer = directory()->GetCryptographer(&trans);
-    EXPECT_TRUE(cryptographer->GetEncryptedTypes().Equals(encrypted_types));
+    EXPECT_TRUE(directory()->GetNigoriHandler()->GetEncryptedTypes(&trans)
+        .Equals(encrypted_types));
 
     // With default encrypted_types, this should be true.
     EXPECT_TRUE(VerifyUnsyncedChangesAreEncrypted(&trans, encrypted_types));
 
     Syncer::UnsyncedMetaHandles handles;
     GetUnsyncedEntries(&trans, &handles);
     EXPECT_TRUE(handles.empty());
   }
 
   // Create unsynced bookmarks without encryption.
@@ skipping 56 matching lines @@
     EXPECT_EQ(1, status->update_progress()->SuccessfullyAppliedUpdateCount())
         << "The nigori update should be applied";
   }
   EXPECT_FALSE(cryptographer->has_pending_keys());
   EXPECT_TRUE(cryptographer->is_ready());
   {
     syncable::ReadTransaction trans(FROM_HERE, directory());
 
     // If ProcessUnsyncedChangesForEncryption worked, all our unsynced changes
     // should be encrypted now.
-    EXPECT_TRUE(ModelTypeSet::All().Equals(
-        cryptographer->GetEncryptedTypes()));
+    EXPECT_TRUE(directory()->GetNigoriHandler()->GetEncryptedTypes(&trans)
+        .Equals(ModelTypeSet::All()));
     EXPECT_TRUE(VerifyUnsyncedChangesAreEncrypted(&trans, encrypted_types));
 
     Syncer::UnsyncedMetaHandles handles;
     GetUnsyncedEntries(&trans, &handles);
     EXPECT_EQ(2*batch_s+1, handles.size());
   }
 
   // Simulate another nigori update that doesn't change anything.
   {
     WriteTransaction trans(FROM_HERE, UNITTEST, directory());
@@ skipping 18 matching lines @@
         << "No updates should be in conflict";
     EXPECT_EQ(2, status->update_progress()->SuccessfullyAppliedUpdateCount())
         << "The nigori update should be applied";
   }
   EXPECT_FALSE(cryptographer->has_pending_keys());
   EXPECT_TRUE(cryptographer->is_ready());
   {
     syncable::ReadTransaction trans(FROM_HERE, directory());
 
     // All our changes should still be encrypted.
-    EXPECT_TRUE(ModelTypeSet::All().Equals(
-        cryptographer->GetEncryptedTypes()));
+    EXPECT_TRUE(directory()->GetNigoriHandler()->GetEncryptedTypes(&trans)
+        .Equals(ModelTypeSet::All()));
     EXPECT_TRUE(VerifyUnsyncedChangesAreEncrypted(&trans, encrypted_types));
 
     Syncer::UnsyncedMetaHandles handles;
     GetUnsyncedEntries(&trans, &handles);
     EXPECT_EQ(2*batch_s+1, handles.size());
   }
 }
 
 TEST_F(ApplyUpdatesCommandTest, CannotEncryptUnsyncedChanges) {
   // Storing the cryptographer separately is bad, but for this test we
   // know it's safe.
   Cryptographer* cryptographer;
   ModelTypeSet encrypted_types;
   encrypted_types.Put(PASSWORDS);
   encrypted_types.Put(NIGORI);
   {
     syncable::ReadTransaction trans(FROM_HERE, directory());
     cryptographer = directory()->GetCryptographer(&trans);
-    EXPECT_TRUE(cryptographer->GetEncryptedTypes().Equals(encrypted_types));
+    EXPECT_TRUE(directory()->GetNigoriHandler()->GetEncryptedTypes(&trans)
+        .Equals(encrypted_types));
 
     // With default encrypted_types, this should be true.
     EXPECT_TRUE(VerifyUnsyncedChangesAreEncrypted(&trans, encrypted_types));
 
     Syncer::UnsyncedMetaHandles handles;
     GetUnsyncedEntries(&trans, &handles);
     EXPECT_TRUE(handles.empty());
   }
 
   // Create unsynced bookmarks without encryption.
@@ skipping 13 matching lines @@
   // Next five items are children of the root.
   for (; i < 2*batch_s; ++i) {
     entry_factory_->CreateUnsyncedItem(
         id_factory_.NewLocalId(), id_factory_.root(),
         base::StringPrintf("Item %"PRIuS"", i), false,
         BOOKMARKS, NULL);
   }
 
   // We encrypt with new keys, triggering the local cryptographer to be unready
   // and unable to decrypt data (once updated).
-  Cryptographer other_cryptographer(&encryptor_);
+  Cryptographer other_cryptographer(cryptographer->encryptor());
   KeyParams params = {"localhost", "dummy", "foobar"};
   other_cryptographer.AddKey(params);
   sync_pb::EntitySpecifics specifics;
   sync_pb::NigoriSpecifics* nigori = specifics.mutable_nigori();
   other_cryptographer.GetKeys(nigori->mutable_encrypted());
   nigori->set_encrypt_everything(true);
   encrypted_types.Put(BOOKMARKS);
   entry_factory_->CreateUnappliedNewItem(
       ModelTypeToRootTag(NIGORI), specifics, true);
   EXPECT_FALSE(cryptographer->has_pending_keys());
@@ skipping 25 matching lines @@
   EXPECT_EQ(1, status->update_progress()->SuccessfullyAppliedUpdateCount())
       << "The nigori update should be applied";
   EXPECT_FALSE(cryptographer->is_ready());
   EXPECT_TRUE(cryptographer->has_pending_keys());
   {
     syncable::ReadTransaction trans(FROM_HERE, directory());
 
     // Since we have pending keys, we would have failed to encrypt, but the
     // cryptographer should be updated.
     EXPECT_FALSE(VerifyUnsyncedChangesAreEncrypted(&trans, encrypted_types));
-    EXPECT_TRUE(cryptographer->GetEncryptedTypes().Equals(
-        ModelTypeSet().All()));
+    EXPECT_TRUE(directory()->GetNigoriHandler()->GetEncryptedTypes(&trans)
+        .Equals(ModelTypeSet::All()));
     EXPECT_FALSE(cryptographer->is_ready());
     EXPECT_TRUE(cryptographer->has_pending_keys());
 
     Syncer::UnsyncedMetaHandles handles;
     GetUnsyncedEntries(&trans, &handles);
     EXPECT_EQ(2*batch_s+1, handles.size());
   }
 }
 
 }  // namespace syncer