[Sync] Refactor GetEncryptedTypes usage.

sync/syncable/syncable_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/compiler_specific.h"
 #include "base/file_path.h"
 #include "base/file_util.h"
 #include "base/location.h"
@@ skipping 88 matching lines @@
   ScopedTempDir temp_dir_;
   NullDirectoryChangeDelegate delegate_;
   FakeEncryptor encryptor_;
   TestUnrecoverableErrorHandler handler_;
   FilePath db_path_;
 };
 
 const char SyncableGeneralTest::kIndexTestName[] = "IndexTest";
 
 TEST_F(SyncableGeneralTest, General) {
-  Directory dir(&encryptor_, &handler_, NULL,
-                new InMemoryDirectoryBackingStore("SimpleTest"));
+  Directory dir(new InMemoryDirectoryBackingStore("SimpleTest"),
+                &handler_,
+                NULL,
+                NULL,
+                NULL);
+
   ASSERT_EQ(OPENED, dir.Open(
           "SimpleTest", &delegate_, NullTransactionObserver()));
 
   int64 root_metahandle;
   {
     ReadTransaction rtrans(FROM_HERE, &dir);
     Entry e(&rtrans, GET_BY_ID, rtrans.root_id());
     ASSERT_TRUE(e.good());
     root_metahandle = e.Get(META_HANDLE);
   }
@@ skipping 79 matching lines @@
     MutableEntry e(&trans, GET_BY_HANDLE, written_metahandle);
     e.Put(IS_DEL, true);
 
     EXPECT_EQ(0, CountEntriesWithName(&trans, trans.root_id(), name));
   }
 
   dir.SaveChanges();
 }
 
 TEST_F(SyncableGeneralTest, ChildrenOps) {
-  Directory dir(&encryptor_, &handler_, NULL,
-                new InMemoryDirectoryBackingStore("SimpleTest"));
+  Directory dir(new InMemoryDirectoryBackingStore("SimpleTest"),
+                &handler_,
+                NULL,
+                NULL,
+                NULL);
   ASSERT_EQ(OPENED, dir.Open(
           "SimpleTest", &delegate_, NullTransactionObserver()));
 
   int64 written_metahandle;
   const Id id = TestIdFactory::FromNumber(99);
   std::string name = "Jeff";
   {
     ReadTransaction rtrans(FROM_HERE, &dir);
     Entry e(&rtrans, GET_BY_ID, id);
     ASSERT_FALSE(e.good());  // Hasn't been written yet.
@@ skipping 52 matching lines @@
 
 TEST_F(SyncableGeneralTest, ClientIndexRebuildsProperly) {
   int64 written_metahandle;
   TestIdFactory factory;
   const Id id = factory.NewServerId();
   std::string name = "cheesepuffs";
   std::string tag = "dietcoke";
 
   // Test creating a new meta entry.
   {
-    Directory dir(&encryptor_, &handler_, NULL,
-        new OnDiskDirectoryBackingStore(kIndexTestName, db_path_));
+    Directory dir(new OnDiskDirectoryBackingStore(kIndexTestName, db_path_),
+                  &handler_,
+                  NULL,
+                  NULL,
+                  NULL);
     ASSERT_EQ(OPENED, dir.Open(kIndexTestName, &delegate_,
                                NullTransactionObserver()));
     {
       WriteTransaction wtrans(FROM_HERE, UNITTEST, &dir);
       MutableEntry me(&wtrans, CREATE, wtrans.root_id(), name);
       ASSERT_TRUE(me.good());
       me.Put(ID, id);
       me.Put(BASE_VERSION, 1);
       me.Put(UNIQUE_CLIENT_TAG, tag);
       written_metahandle = me.Get(META_HANDLE);
     }
     dir.SaveChanges();
   }
 
   // The DB was closed. Now reopen it. This will cause index regeneration.
   {
-    Directory dir(&encryptor_, &handler_, NULL,
-        new OnDiskDirectoryBackingStore(kIndexTestName, db_path_));
+    Directory dir(new OnDiskDirectoryBackingStore(kIndexTestName, db_path_),
+                  &handler_,
+                  NULL,
+                  NULL,
+                  NULL);
     ASSERT_EQ(OPENED, dir.Open(kIndexTestName,
                                &delegate_, NullTransactionObserver()));
 
     ReadTransaction trans(FROM_HERE, &dir);
     Entry me(&trans, GET_BY_CLIENT_TAG, tag);
     ASSERT_TRUE(me.good());
     EXPECT_EQ(me.Get(ID), id);
     EXPECT_EQ(me.Get(BASE_VERSION), 1);
     EXPECT_EQ(me.Get(UNIQUE_CLIENT_TAG), tag);
     EXPECT_EQ(me.Get(META_HANDLE), written_metahandle);
   }
 }
 
 TEST_F(SyncableGeneralTest, ClientIndexRebuildsDeletedProperly) {
   TestIdFactory factory;
   const Id id = factory.NewServerId();
   std::string tag = "dietcoke";
 
   // Test creating a deleted, unsynced, server meta entry.
   {
-    Directory dir(&encryptor_, &handler_, NULL,
-        new OnDiskDirectoryBackingStore(kIndexTestName, db_path_));
+    Directory dir(new OnDiskDirectoryBackingStore(kIndexTestName, db_path_),
+                  &handler_,
+                  NULL,
+                  NULL,
+                  NULL);
     ASSERT_EQ(OPENED, dir.Open(kIndexTestName, &delegate_,
                                 NullTransactionObserver()));
     {
       WriteTransaction wtrans(FROM_HERE, UNITTEST, &dir);
       MutableEntry me(&wtrans, CREATE, wtrans.root_id(), "deleted");
       ASSERT_TRUE(me.good());
       me.Put(ID, id);
       me.Put(BASE_VERSION, 1);
       me.Put(UNIQUE_CLIENT_TAG, tag);
       me.Put(IS_DEL, true);
       me.Put(IS_UNSYNCED, true);  // Or it might be purged.
     }
     dir.SaveChanges();
   }
 
   // The DB was closed. Now reopen it. This will cause index regeneration.
   // Should still be present and valid in the client tag index.
   {
-    Directory dir(&encryptor_, &handler_, NULL,
-        new OnDiskDirectoryBackingStore(kIndexTestName, db_path_));
+    Directory dir(new OnDiskDirectoryBackingStore(kIndexTestName, db_path_),
+                  &handler_,
+                  NULL,
+                  NULL,
+                  NULL);
     ASSERT_EQ(OPENED, dir.Open(kIndexTestName, &delegate_,
                                NullTransactionObserver()));
 
     ReadTransaction trans(FROM_HERE, &dir);
     Entry me(&trans, GET_BY_CLIENT_TAG, tag);
     ASSERT_TRUE(me.good());
     EXPECT_EQ(me.Get(ID), id);
     EXPECT_EQ(me.Get(UNIQUE_CLIENT_TAG), tag);
     EXPECT_TRUE(me.Get(IS_DEL));
     EXPECT_TRUE(me.Get(IS_UNSYNCED));
   }
 }
 
 TEST_F(SyncableGeneralTest, ToValue) {
-  Directory dir(&encryptor_, &handler_, NULL,
-                new InMemoryDirectoryBackingStore("SimpleTest"));
+  Directory dir(new InMemoryDirectoryBackingStore("SimpleTest"),
+                &handler_,
+                NULL,
+                NULL,
+                NULL);
   ASSERT_EQ(OPENED, dir.Open(
           "SimpleTest", &delegate_, NullTransactionObserver()));
 
   const Id id = TestIdFactory::FromNumber(99);
   {
     ReadTransaction rtrans(FROM_HERE, &dir);
     Entry e(&rtrans, GET_BY_ID, id);
     EXPECT_FALSE(e.good());  // Hasn't been written yet.
 
     scoped_ptr<DictionaryValue> value(e.ToValue());
@@ skipping 21 matching lines @@
 }
 
 // A test fixture for syncable::Directory.  Uses an in-memory database to keep
 // the unit tests fast.
 class SyncableDirectoryTest : public testing::Test {
  protected:
   MessageLoop message_loop_;
   static const char kName[];
 
   virtual void SetUp() {
-    dir_.reset(new Directory(&encryptor_, &handler_, NULL,
-                             new InMemoryDirectoryBackingStore(kName)));
+    dir_.reset(new Directory(new InMemoryDirectoryBackingStore(kName),
+                             &handler_,
+                             NULL,
+                             NULL,
+                             NULL));
     ASSERT_TRUE(dir_.get());
     ASSERT_EQ(OPENED, dir_->Open(kName, &delegate_,
                                  NullTransactionObserver()));
     ASSERT_TRUE(dir_->good());
   }
 
   virtual void TearDown() {
     if (dir_.get())
       dir_->SaveChanges();
     dir_.reset();
@@ skipping 992 matching lines @@
     const std::string& dir_name,
     const FilePath& backing_filepath) {
   TestBackingStore* backing_store =
       new TestBackingStore(dir_name, backing_filepath);
   return new TestDirectory(encryptor, handler, backing_store);
 }
 
 TestDirectory::TestDirectory(Encryptor* encryptor,
                              UnrecoverableErrorHandler* handler,
                              TestBackingStore* backing_store)
-    : Directory(encryptor, handler, NULL, backing_store),
+    : Directory(backing_store, handler, NULL, NULL, NULL),
       backing_store_(backing_store) {
 }
 
 TestDirectory::~TestDirectory() { }
 
 TEST(OnDiskSyncableDirectory, FailInitialWrite) {
   FakeEncryptor encryptor;
   TestUnrecoverableErrorHandler handler;
   ScopedTempDir temp_dir;
   FilePath file_path = temp_dir.path().Append(
@@ skipping 175 matching lines @@
     sync_pb::EntitySpecifics specifics;
     specifics.mutable_bookmark()->set_favicon("PNG");
     specifics.mutable_bookmark()->set_url("http://nowhere");
     create.Put(SPECIFICS, specifics);
     create_pre_save = create.GetKernelCopy();
     update_pre_save = update.GetKernelCopy();
     create_id = create.Get(ID);
   }
 
   dir_->SaveChanges();
-  dir_.reset(new Directory(&encryptor_, &handler_, NULL,
-      new OnDiskDirectoryBackingStore(kName, file_path_)));
+  dir_.reset(new Directory(new OnDiskDirectoryBackingStore(kName, file_path_),
+                           &handler_,
+                           NULL,
+                           NULL,
+                           NULL));
+
   ASSERT_TRUE(dir_.get());
   ASSERT_EQ(OPENED, dir_->Open(kName, &delegate_, NullTransactionObserver()));
   ASSERT_TRUE(dir_->good());
 
   {
     ReadTransaction trans(FROM_HERE, dir_.get());
     Entry create(&trans, GET_BY_ID, create_id);
     EXPECT_EQ(1, CountEntriesWithName(&trans, trans.root_id(), create_name));
     Entry update(&trans, GET_BY_ID, update_id);
     create_post_save = create.GetKernelCopy();
@@ skipping 195 matching lines @@
 }
 
 DirOpenResult SyncableDirectoryTest::ReloadDirImpl() {
   // Do some tricky things to preserve the backing store.
   DirectoryBackingStore* saved_store = dir_->store_.release();
 
   // Close the current directory.
   dir_->Close();
   dir_.reset();
 
-  dir_.reset(new Directory(&encryptor_, &handler_, NULL, saved_store));
+  dir_.reset(new Directory(saved_store,
+                           &handler_,
+                           NULL,
+                           NULL,
+                           NULL));
   DirOpenResult result = dir_->OpenImpl(kName, &delegate_,
                                         NullTransactionObserver());
 
   // If something went wrong, we need to clear this member.  If we don't,
   // TearDown() will be guaranteed to crash when it calls SaveChanges().
   if (result != OPENED)
     dir_.reset();
 
   return result;
 }
@@ skipping 13 matching lines @@
   ScopedTempDir temp_dir_;
   FakeEncryptor encryptor_;
   TestUnrecoverableErrorHandler handler_;
   NullDirectoryChangeDelegate delegate_;
 };
 
 TEST_F(SyncableDirectoryManagement, TestFileRelease) {
   FilePath path = temp_dir_.path().Append(
       Directory::kSyncDatabaseFilename);
 
-  syncable::Directory dir(&encryptor_, &handler_, NULL,
-      new OnDiskDirectoryBackingStore("ScopeTest", path));
+  syncable::Directory dir(new OnDiskDirectoryBackingStore("ScopeTest", path),
+                          &handler_,
+                          NULL,
+                          NULL,
+                          NULL);
   DirOpenResult result =
       dir.Open("ScopeTest", &delegate_, NullTransactionObserver());
   ASSERT_EQ(result, OPENED);
   dir.Close();
 
   // Closing the directory should have released the backing database file.
   ASSERT_TRUE(file_util::Delete(path, true));
 }
 
 class StressTransactionsDelegate : public base::PlatformThread::Delegate {
@@ skipping 40 matching lines @@
 };
 
 TEST(SyncableDirectory, StressTransactions) {
   MessageLoop message_loop;
   ScopedTempDir temp_dir;
   ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
   FakeEncryptor encryptor;
   TestUnrecoverableErrorHandler handler;
   NullDirectoryChangeDelegate delegate;
   std::string dirname = "stress";
-  Directory dir(&encryptor, &handler, NULL,
-                new InMemoryDirectoryBackingStore(dirname));
+  Directory dir(new InMemoryDirectoryBackingStore(dirname),
+                &handler,
+                NULL,
+                NULL,
+                NULL);
   dir.Open(dirname, &delegate, NullTransactionObserver());
 
   const int kThreadCount = 7;
   base::PlatformThreadHandle threads[kThreadCount];
   scoped_ptr<StressTransactionsDelegate> thread_delegates[kThreadCount];
 
   for (int i = 0; i < kThreadCount; ++i) {
     thread_delegates[i].reset(new StressTransactionsDelegate(&dir, i));
     ASSERT_TRUE(base::PlatformThread::Create(
         0, thread_delegates[i].get(), &threads[i]));
@@ skipping 101 matching lines @@
   EXPECT_TRUE(CreateWithDefaultTag(factory_.NewServerId(), true));
   EXPECT_FALSE(CreateWithDefaultTag(factory_.NewServerId(), true));
   EXPECT_FALSE(CreateWithDefaultTag(factory_.NewServerId(), false));
   EXPECT_FALSE(CreateWithDefaultTag(factory_.NewLocalId(), false));
   EXPECT_FALSE(CreateWithDefaultTag(factory_.NewLocalId(), true));
 }
 
 }  // namespace
 }  // namespace syncable
 }  // namespace syncer