sync: Create sync entry factory class for tests

Move some of the helper functions embedded in
ApplyUpdatesCommandUnittest into a separate class.  This will make it
easier to reuse this code in other test cases.

This CL is a prerequisite for some upcoming changes that move Nigori update
application out of ApplyUpdatesCommand.

BUG=111297
TEST=


Review URL: https://chromiumcodereview.appspot.com/10658006

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@144326 0039d316-1c4b-4281-b951-d872f2087c98

2 files changed, 97 insertions, 244 deletions

diff --git a/sync/engine/DEPS b/sync/engine/DEPS
index af825b6..591b69f 100644
--- a/sync/engine/DEPS
+++ b/sync/engine/DEPS
@@ -3,6 +3,7 @@ include_rules = [
   "+sync/internal_api/public/engine",
   "+sync/internal_api/public/sessions",
   "+sync/internal_api/public/syncable",
+  "+sync/internal_api/public/test",
   "+sync/internal_api/public/util",
   "+sync/protocol",
   "+sync/sessions",
diff --git a/sync/engine/apply_updates_command_unittest.cc b/sync/engine/apply_updates_command_unittest.cc
index f334bf1..5e43d0a 100644
--- a/sync/engine/apply_updates_command_unittest.cc
+++ b/sync/engine/apply_updates_command_unittest.cc
@@ -6,11 +6,13 @@
 
 #include "base/format_macros.h"
 #include "base/location.h"
+#include "base/memory/scoped_ptr.h"
 #include "base/stringprintf.h"
 #include "sync/engine/apply_updates_command.h"
 #include "sync/engine/nigori_util.h"
 #include "sync/engine/syncer.h"
 #include "sync/engine/syncer_util.h"
+#include "sync/internal_api/public/test/test_entry_factory.h"
 #include "sync/protocol/bookmark_specifics.pb.h"
 #include "sync/protocol/password_specifics.pb.h"
 #include "sync/sessions/sync_session.h"
@@ -46,7 +48,7 @@ sync_pb::EntitySpecifics DefaultBookmarkSpecifics() {
 class ApplyUpdatesCommandTest : public SyncerCommandTest {
  public:
  protected:
-  ApplyUpdatesCommandTest() : next_revision_(1) {}
+  ApplyUpdatesCommandTest() {}
   virtual ~ApplyUpdatesCommandTest() {}
 
   virtual void SetUp() {
@@ -60,170 +62,26 @@ class ApplyUpdatesCommandTest : public SyncerCommandTest {
     (*mutable_routing_info())[syncable::PASSWORDS] = GROUP_PASSWORD;
     (*mutable_routing_info())[syncable::NIGORI] = GROUP_PASSIVE;
     SyncerCommandTest::SetUp();
+    entry_factory_.reset(new TestEntryFactory(directory()));
     ExpectNoGroupsToChange(apply_updates_command_);
   }
 
-  // Create a new unapplied folder node with a parent.
-  void CreateUnappliedNewItemWithParent(
-      const string& item_id,
-      const sync_pb::EntitySpecifics& specifics,
-      const string& parent_id) {
-    WriteTransaction trans(FROM_HERE, UNITTEST, directory());
-    MutableEntry entry(&trans, syncable::CREATE_NEW_UPDATE_ITEM,
-        Id::CreateFromServerId(item_id));
-    ASSERT_TRUE(entry.good());
-    entry.Put(syncable::SERVER_VERSION, next_revision_++);
-    entry.Put(syncable::IS_UNAPPLIED_UPDATE, true);
-
-    entry.Put(syncable::SERVER_NON_UNIQUE_NAME, item_id);
-    entry.Put(syncable::SERVER_PARENT_ID, Id::CreateFromServerId(parent_id));
-    entry.Put(syncable::SERVER_IS_DIR, true);
-    entry.Put(syncable::SERVER_SPECIFICS, specifics);
-  }
-
-  // Create a new unapplied update without a parent.
-  void CreateUnappliedNewItem(const string& item_id,
-                              const sync_pb::EntitySpecifics& specifics,
-                              bool is_unique) {
-    WriteTransaction trans(FROM_HERE, UNITTEST, directory());
-    MutableEntry entry(&trans, syncable::CREATE_NEW_UPDATE_ITEM,
-        Id::CreateFromServerId(item_id));
-    ASSERT_TRUE(entry.good());
-    entry.Put(syncable::SERVER_VERSION, next_revision_++);
-    entry.Put(syncable::IS_UNAPPLIED_UPDATE, true);
-    entry.Put(syncable::SERVER_NON_UNIQUE_NAME, item_id);
-    entry.Put(syncable::SERVER_PARENT_ID, syncable::GetNullId());
-    entry.Put(syncable::SERVER_IS_DIR, false);
-    entry.Put(syncable::SERVER_SPECIFICS, specifics);
-    if (is_unique)  // For top-level nodes.
-      entry.Put(syncable::UNIQUE_SERVER_TAG, item_id);
-  }
-
-  // Create an unsynced item in the database.  If item_id is a local ID, it
-  // will be treated as a create-new.  Otherwise, if it's a server ID, we'll
-  // fake the server data so that it looks like it exists on the server.
-  // Returns the methandle of the created item in |metahandle_out| if not NULL.
-  void CreateUnsyncedItem(const Id& item_id,
-                          const Id& parent_id,
-                          const string& name,
-                          bool is_folder,
-                          syncable::ModelType model_type,
-                          int64* metahandle_out) {
-    WriteTransaction trans(FROM_HERE, UNITTEST, directory());
-    Id predecessor_id;
-    ASSERT_TRUE(
-        directory()->GetLastChildIdForTest(&trans, parent_id, &predecessor_id));
-    MutableEntry entry(&trans, syncable::CREATE, parent_id, name);
-    ASSERT_TRUE(entry.good());
-    entry.Put(syncable::ID, item_id);
-    entry.Put(syncable::BASE_VERSION,
-        item_id.ServerKnows() ? next_revision_++ : 0);
-    entry.Put(syncable::IS_UNSYNCED, true);
-    entry.Put(syncable::IS_DIR, is_folder);
-    entry.Put(syncable::IS_DEL, false);
-    entry.Put(syncable::PARENT_ID, parent_id);
-    CHECK(entry.PutPredecessor(predecessor_id));
-    sync_pb::EntitySpecifics default_specifics;
-    syncable::AddDefaultFieldValue(model_type, &default_specifics);
-    entry.Put(syncable::SPECIFICS, default_specifics);
-    if (item_id.ServerKnows()) {
-      entry.Put(syncable::SERVER_SPECIFICS, default_specifics);
-      entry.Put(syncable::SERVER_IS_DIR, is_folder);
-      entry.Put(syncable::SERVER_PARENT_ID, parent_id);
-      entry.Put(syncable::SERVER_IS_DEL, false);
-    }
-    if (metahandle_out)
-      *metahandle_out = entry.Get(syncable::META_HANDLE);
-  }
-
-  // Creates an item that is both unsynced an an unapplied update.  Returns the
-  // metahandle of the created item.
-  int64 CreateUnappliedAndUnsyncedItem(const string& name,
-                                       syncable::ModelType model_type) {
-    int64 metahandle = 0;
-    CreateUnsyncedItem(id_factory_.MakeServer(name), id_factory_.root(), name,
-                       false, model_type, &metahandle);
-
-    WriteTransaction trans(FROM_HERE, UNITTEST, directory());
-    MutableEntry entry(&trans, syncable::GET_BY_HANDLE, metahandle);
-    if (!entry.good()) {
-      ADD_FAILURE();
-      return syncable::kInvalidMetaHandle;
-    }
-
-    entry.Put(syncable::IS_UNAPPLIED_UPDATE, true);
-    entry.Put(syncable::SERVER_VERSION, GetNextRevision());
-
-    return metahandle;
-  }
-
-
-  // Creates an item that has neither IS_UNSYNED or IS_UNAPPLIED_UPDATE.  The
-  // item is known to both the server and client.  Returns the metahandle of
-  // the created item.
-  int64 CreateSyncedItem(const std::string& name, syncable::ModelType
-                         model_type, bool is_folder) {
-    WriteTransaction trans(FROM_HERE, UNITTEST, directory());
-
-    syncable::Id parent_id(id_factory_.root());
-    syncable::Id item_id(id_factory_.MakeServer(name));
-    int64 version = GetNextRevision();
-
-    sync_pb::EntitySpecifics default_specifics;
-    syncable::AddDefaultFieldValue(model_type, &default_specifics);
-
-    MutableEntry entry(&trans, syncable::CREATE, parent_id, name);
-    if (!entry.good()) {
-      ADD_FAILURE();
-      return syncable::kInvalidMetaHandle;
-    }
-
-    entry.Put(syncable::ID, item_id);
-    entry.Put(syncable::BASE_VERSION, version);
-    entry.Put(syncable::IS_UNSYNCED, false);
-    entry.Put(syncable::NON_UNIQUE_NAME, name);
-    entry.Put(syncable::IS_DIR, is_folder);
-    entry.Put(syncable::IS_DEL, false);
-    entry.Put(syncable::PARENT_ID, parent_id);
-
-    if (!entry.PutPredecessor(id_factory_.root())) {
-      ADD_FAILURE();
-      return syncable::kInvalidMetaHandle;
-    }
-    entry.Put(syncable::SPECIFICS, default_specifics);
-
-    entry.Put(syncable::SERVER_VERSION, GetNextRevision());
-    entry.Put(syncable::IS_UNAPPLIED_UPDATE, true);
-    entry.Put(syncable::SERVER_NON_UNIQUE_NAME, "X");
-    entry.Put(syncable::SERVER_PARENT_ID, id_factory_.MakeServer("Y"));
-    entry.Put(syncable::SERVER_IS_DIR, is_folder);
-    entry.Put(syncable::SERVER_IS_DEL, false);
-    entry.Put(syncable::SERVER_SPECIFICS, default_specifics);
-    entry.Put(syncable::SERVER_PARENT_ID, parent_id);
-
-    return entry.Get(syncable::META_HANDLE);
-  }
-
-  int64 GetNextRevision() {
-    return next_revision_++;
-  }
-
   ApplyUpdatesCommand apply_updates_command_;
   FakeEncryptor encryptor_;
   TestIdFactory id_factory_;
+  scoped_ptr<TestEntryFactory> entry_factory_;
  private:
-  int64 next_revision_;
   DISALLOW_COPY_AND_ASSIGN(ApplyUpdatesCommandTest);
 };
 
 TEST_F(ApplyUpdatesCommandTest, Simple) {
   string root_server_id = syncable::GetNullId().GetServerId();
-  CreateUnappliedNewItemWithParent("parent",
-                                   DefaultBookmarkSpecifics(),
-                                   root_server_id);
-  CreateUnappliedNewItemWithParent("child",
-                                   DefaultBookmarkSpecifics(),
-                                   "parent");
+  entry_factory_->CreateUnappliedNewItemWithParent("parent",
+                                                   DefaultBookmarkSpecifics(),
+                                                   root_server_id);
+  entry_factory_->CreateUnappliedNewItemWithParent("child",
+                                                   DefaultBookmarkSpecifics(),
+                                                   "parent");
 
   ExpectGroupToChange(apply_updates_command_, GROUP_UI);
   apply_updates_command_.ExecuteImpl(session());
@@ -249,21 +107,16 @@ TEST_F(ApplyUpdatesCommandTest, UpdateWithChildrenBeforeParents) {
   // Set a bunch of updates which are difficult to apply in the order
   // they're received due to dependencies on other unseen items.
   string root_server_id = syncable::GetNullId().GetServerId();
-  CreateUnappliedNewItemWithParent("a_child_created_first",
-                                   DefaultBookmarkSpecifics(),
-                                   "parent");
-  CreateUnappliedNewItemWithParent("x_child_created_first",
-                                   DefaultBookmarkSpecifics(),
-                                   "parent");
-  CreateUnappliedNewItemWithParent("parent",
-                                   DefaultBookmarkSpecifics(),
-                                   root_server_id);
-  CreateUnappliedNewItemWithParent("a_child_created_second",
-                                   DefaultBookmarkSpecifics(),
-                                   "parent");
-  CreateUnappliedNewItemWithParent("x_child_created_second",
-                                   DefaultBookmarkSpecifics(),
-                                   "parent");
+  entry_factory_->CreateUnappliedNewItemWithParent(
+      "a_child_created_first", DefaultBookmarkSpecifics(), "parent");
+  entry_factory_->CreateUnappliedNewItemWithParent(
+      "x_child_created_first", DefaultBookmarkSpecifics(), "parent");
+  entry_factory_->CreateUnappliedNewItemWithParent(
+      "parent", DefaultBookmarkSpecifics(), root_server_id);
+  entry_factory_->CreateUnappliedNewItemWithParent(
+      "a_child_created_second", DefaultBookmarkSpecifics(), "parent");
+  entry_factory_->CreateUnappliedNewItemWithParent(
+      "x_child_created_second", DefaultBookmarkSpecifics(), "parent");
 
   ExpectGroupToChange(apply_updates_command_, GROUP_UI);
   apply_updates_command_.ExecuteImpl(session());
@@ -285,7 +138,8 @@ TEST_F(ApplyUpdatesCommandTest, UpdateWithChildrenBeforeParents) {
 // to detect that this update can't be applied because it is in a CONFLICT
 // state.
 TEST_F(ApplyUpdatesCommandTest, SimpleConflict) {
-  CreateUnappliedAndUnsyncedItem("item", syncable::BOOKMARKS);
+  entry_factory_->CreateUnappliedAndUnsyncedItem(
+      "item", syncable::BOOKMARKS);
 
   ExpectGroupToChange(apply_updates_command_, GROUP_UI);
   apply_updates_command_.ExecuteImpl(session());
@@ -304,8 +158,8 @@ TEST_F(ApplyUpdatesCommandTest, SimpleConflict) {
 // simple conflict processing logic; it is in a CONFLICT_HIERARCHY state.
 TEST_F(ApplyUpdatesCommandTest, HierarchyAndSimpleConflict) {
   // Create a simply-conflicting item.  It will start with valid parent ids.
-  int64 handle = CreateUnappliedAndUnsyncedItem("orphaned_by_server",
-                                                syncable::BOOKMARKS);
+  int64 handle = entry_factory_->CreateUnappliedAndUnsyncedItem(
+      "orphaned_by_server", syncable::BOOKMARKS);
   {
     // Manually set the SERVER_PARENT_ID to bad value.
     // A bad parent indicates a hierarchy conflict.
@@ -342,21 +196,23 @@ TEST_F(ApplyUpdatesCommandTest, HierarchyConflictDirectoryLoop) {
   // parent of 'Y'.
   {
     // Create it as a child of root node.
-    int64 handle = CreateSyncedItem("X", syncable::BOOKMARKS, true);
+    int64 handle = entry_factory_->CreateSyncedItem(
+        "X", syncable::BOOKMARKS, true);
 
     WriteTransaction trans(FROM_HERE, UNITTEST, directory());
     MutableEntry entry(&trans, syncable::GET_BY_HANDLE, handle);
     ASSERT_TRUE(entry.good());
 
     // Re-parent from root to "Y"
-    entry.Put(syncable::SERVER_VERSION, GetNextRevision());
+    entry.Put(syncable::SERVER_VERSION, entry_factory_->GetNextRevision());
     entry.Put(syncable::IS_UNAPPLIED_UPDATE, true);
     entry.Put(syncable::SERVER_PARENT_ID, id_factory_.MakeServer("Y"));
   }
 
   // Item 'Y' is child of 'X'.
-  CreateUnsyncedItem(id_factory_.MakeServer("Y"), id_factory_.MakeServer("X"),
-                     "Y", true, syncable::BOOKMARKS, NULL);
+  entry_factory_->CreateUnsyncedItem(
+      id_factory_.MakeServer("Y"), id_factory_.MakeServer("X"), "Y", true,
+      syncable::BOOKMARKS, NULL);
 
   // If the server's update were applied, we would have X be a child of Y, and Y
   // as a child of X.  That's a directory loop.  The UpdateApplicator should
@@ -384,8 +240,9 @@ TEST_F(ApplyUpdatesCommandTest, HierarchyConflictDirectoryLoop) {
 TEST_F(ApplyUpdatesCommandTest, HierarchyConflictDeletedParent) {
   // Create a locally deleted parent item.
   int64 parent_handle;
-  CreateUnsyncedItem(Id::CreateFromServerId("parent"), id_factory_.root(),
-                     "parent", true, syncable::BOOKMARKS, &parent_handle);
+  entry_factory_->CreateUnsyncedItem(
+      Id::CreateFromServerId("parent"), id_factory_.root(),
+      "parent", true, syncable::BOOKMARKS, &parent_handle);
   {
     WriteTransaction trans(FROM_HERE, UNITTEST, directory());
     MutableEntry entry(&trans, syncable::GET_BY_HANDLE, parent_handle);
@@ -393,8 +250,8 @@ TEST_F(ApplyUpdatesCommandTest, HierarchyConflictDeletedParent) {
   }
 
   // Create an incoming child from the server.
-  CreateUnappliedNewItemWithParent("child", DefaultBookmarkSpecifics(),
-                                   "parent");
+  entry_factory_->CreateUnappliedNewItemWithParent(
+      "child", DefaultBookmarkSpecifics(), "parent");
 
   // The server's update may seem valid to some other client, but on this client
   // that new item's parent no longer exists.  The update should not be applied
@@ -420,23 +277,24 @@ TEST_F(ApplyUpdatesCommandTest, HierarchyConflictDeleteNonEmptyDirectory) {
   // Create a server-deleted directory.
   {
     // Create it as a child of root node.
-    int64 handle = CreateSyncedItem("parent", syncable::BOOKMARKS, true);
+    int64 handle = entry_factory_->CreateSyncedItem(
+        "parent", syncable::BOOKMARKS, true);
 
     WriteTransaction trans(FROM_HERE, UNITTEST, directory());
     MutableEntry entry(&trans, syncable::GET_BY_HANDLE, handle);
     ASSERT_TRUE(entry.good());
 
     // Delete it on the server.
-    entry.Put(syncable::SERVER_VERSION, GetNextRevision());
+    entry.Put(syncable::SERVER_VERSION, entry_factory_->GetNextRevision());
     entry.Put(syncable::IS_UNAPPLIED_UPDATE, true);
     entry.Put(syncable::SERVER_PARENT_ID, id_factory_.root());
     entry.Put(syncable::SERVER_IS_DEL, true);
   }
 
   // Create a local child of the server-deleted directory.
-  CreateUnsyncedItem(id_factory_.MakeServer("child"),
-                     id_factory_.MakeServer("parent"), "child", false,
-                     syncable::BOOKMARKS, NULL);
+  entry_factory_->CreateUnsyncedItem(
+      id_factory_.MakeServer("child"), id_factory_.MakeServer("parent"),
+      "child", false, syncable::BOOKMARKS, NULL);
 
   // The server's request to delete the directory must be ignored, otherwise our
   // unsynced new child would be orphaned.  This is a hierarchy conflict.
@@ -458,12 +316,10 @@ TEST_F(ApplyUpdatesCommandTest, HierarchyConflictDeleteNonEmptyDirectory) {
 // item is in a CONFLICT_HIERARCHY state.
 TEST_F(ApplyUpdatesCommandTest, HierarchyConflictUnknownParent) {
   // We shouldn't be able to do anything with either of these items.
-  CreateUnappliedNewItemWithParent("some_item",
-                                   DefaultBookmarkSpecifics(),
-                                   "unknown_parent");
-  CreateUnappliedNewItemWithParent("some_other_item",
-                                   DefaultBookmarkSpecifics(),
-                                   "some_item");
+  entry_factory_->CreateUnappliedNewItemWithParent(
+      "some_item", DefaultBookmarkSpecifics(), "unknown_parent");
+  entry_factory_->CreateUnappliedNewItemWithParent(
+      "some_other_item", DefaultBookmarkSpecifics(), "some_item");
 
   ExpectGroupToChange(apply_updates_command_, GROUP_UI);
   apply_updates_command_.ExecuteImpl(session());
@@ -486,24 +342,18 @@ TEST_F(ApplyUpdatesCommandTest, HierarchyConflictUnknownParent) {
 TEST_F(ApplyUpdatesCommandTest, ItemsBothKnownAndUnknown) {
   // See what happens when there's a mixture of good and bad updates.
   string root_server_id = syncable::GetNullId().GetServerId();
-  CreateUnappliedNewItemWithParent("first_unknown_item",
-                                   DefaultBookmarkSpecifics(),
-                                   "unknown_parent");
-  CreateUnappliedNewItemWithParent("first_known_item",
-                                   DefaultBookmarkSpecifics(),
-                                   root_server_id);
-  CreateUnappliedNewItemWithParent("second_unknown_item",
-                                   DefaultBookmarkSpecifics(),
-                                   "unknown_parent");
-  CreateUnappliedNewItemWithParent("second_known_item",
-                                   DefaultBookmarkSpecifics(),
-                                   "first_known_item");
-  CreateUnappliedNewItemWithParent("third_known_item",
-                                   DefaultBookmarkSpecifics(),
-                                   "fourth_known_item");
-  CreateUnappliedNewItemWithParent("fourth_known_item",
-                                   DefaultBookmarkSpecifics(),
-                                   root_server_id);
+  entry_factory_->CreateUnappliedNewItemWithParent(
+      "first_unknown_item", DefaultBookmarkSpecifics(), "unknown_parent");
+  entry_factory_->CreateUnappliedNewItemWithParent(
+      "first_known_item", DefaultBookmarkSpecifics(), root_server_id);
+  entry_factory_->CreateUnappliedNewItemWithParent(
+      "second_unknown_item", DefaultBookmarkSpecifics(), "unknown_parent");
+  entry_factory_->CreateUnappliedNewItemWithParent(
+      "second_known_item", DefaultBookmarkSpecifics(), "first_known_item");
+  entry_factory_->CreateUnappliedNewItemWithParent(
+      "third_known_item", DefaultBookmarkSpecifics(), "fourth_known_item");
+  entry_factory_->CreateUnappliedNewItemWithParent(
+      "fourth_known_item", DefaultBookmarkSpecifics(), root_server_id);
 
   ExpectGroupToChange(apply_updates_command_, GROUP_UI);
   apply_updates_command_.ExecuteImpl(session());
@@ -539,7 +389,7 @@ TEST_F(ApplyUpdatesCommandTest, DecryptablePassword) {
 
   cryptographer->Encrypt(data,
                          specifics.mutable_password()->mutable_encrypted());
-  CreateUnappliedNewItem("item", specifics, false);
+  entry_factory_->CreateUnappliedNewItem("item", specifics, false);
 
   ExpectGroupToChange(apply_updates_command_, GROUP_PASSWORD);
   apply_updates_command_.ExecuteImpl(session());
@@ -562,13 +412,12 @@ TEST_F(ApplyUpdatesCommandTest, UndecryptableData) {
   encrypted_bookmark.mutable_encrypted();
   AddDefaultFieldValue(syncable::BOOKMARKS, &encrypted_bookmark);
   string root_server_id = syncable::GetNullId().GetServerId();
-  CreateUnappliedNewItemWithParent("folder",
-                                   encrypted_bookmark,
-                                   root_server_id);
-  CreateUnappliedNewItem("item2", encrypted_bookmark, false);
+  entry_factory_->CreateUnappliedNewItemWithParent(
+      "folder", encrypted_bookmark, root_server_id);
+  entry_factory_->CreateUnappliedNewItem("item2", encrypted_bookmark, false);
   sync_pb::EntitySpecifics encrypted_password;
   encrypted_password.mutable_password();
-  CreateUnappliedNewItem("item3", encrypted_password, false);
+  entry_factory_->CreateUnappliedNewItem("item3", encrypted_password, false);
 
   ExpectGroupsToChange(apply_updates_command_, GROUP_UI, GROUP_PASSWORD);
   apply_updates_command_.ExecuteImpl(session());
@@ -597,7 +446,7 @@ TEST_F(ApplyUpdatesCommandTest, UndecryptableData) {
     ASSERT_TRUE(status->update_progress());
     EXPECT_EQ(1, status->update_progress()->AppliedUpdatesSize())
         << "All updates should have been attempted";
-  ASSERT_TRUE(status->conflict_progress());
+    ASSERT_TRUE(status->conflict_progress());
     EXPECT_EQ(0, status->conflict_progress()->SimpleConflictingItemsSize())
         << "The updates that can't be decrypted should not be in regular "
         << "conflict";
@@ -625,7 +474,7 @@ TEST_F(ApplyUpdatesCommandTest, SomeUndecryptablePassword) {
       cryptographer->Encrypt(data,
           specifics.mutable_password()->mutable_encrypted());
     }
-    CreateUnappliedNewItem("item1", specifics, false);
+    entry_factory_->CreateUnappliedNewItem("item1", specifics, false);
   }
   {
     // Create a new cryptographer, independent of the one in the session.
@@ -639,7 +488,7 @@ TEST_F(ApplyUpdatesCommandTest, SomeUndecryptablePassword) {
 
     cryptographer.Encrypt(data,
         specifics.mutable_password()->mutable_encrypted());
-    CreateUnappliedNewItem("item2", specifics, false);
+    entry_factory_->CreateUnappliedNewItem("item2", specifics, false);
   }
 
   ExpectGroupToChange(apply_updates_command_, GROUP_PASSWORD);
@@ -689,8 +538,8 @@ TEST_F(ApplyUpdatesCommandTest, NigoriUpdate) {
   other_cryptographer.GetKeys(nigori->mutable_encrypted());
   nigori->set_encrypt_bookmarks(true);
   encrypted_types.Put(syncable::BOOKMARKS);
-  CreateUnappliedNewItem(syncable::ModelTypeToRootTag(syncable::NIGORI),
-                         specifics, true);
+  entry_factory_->CreateUnappliedNewItem(
+      syncable::ModelTypeToRootTag(syncable::NIGORI), specifics, true);
   EXPECT_FALSE(cryptographer->has_pending_keys());
 
   ExpectGroupToChange(apply_updates_command_, GROUP_PASSIVE);
@@ -739,8 +588,8 @@ TEST_F(ApplyUpdatesCommandTest, NigoriUpdateForDisabledTypes) {
   nigori->set_encrypt_themes(true);
   encrypted_types.Put(syncable::SESSIONS);
   encrypted_types.Put(syncable::THEMES);
-  CreateUnappliedNewItem(syncable::ModelTypeToRootTag(syncable::NIGORI),
-                         specifics, true);
+  entry_factory_->CreateUnappliedNewItem(
+      syncable::ModelTypeToRootTag(syncable::NIGORI), specifics, true);
   EXPECT_FALSE(cryptographer->has_pending_keys());
 
   ExpectGroupToChange(apply_updates_command_, GROUP_PASSIVE);
@@ -792,21 +641,22 @@ TEST_F(ApplyUpdatesCommandTest, EncryptUnsyncedChanges) {
   // Create unsynced bookmarks without encryption.
   // First item is a folder
   Id folder_id = id_factory_.NewLocalId();
-  CreateUnsyncedItem(folder_id, id_factory_.root(), "folder",
-                     true, syncable::BOOKMARKS, NULL);
+  entry_factory_->CreateUnsyncedItem(folder_id, id_factory_.root(), "folder",
+                                     true, syncable::BOOKMARKS, NULL);
   // Next five items are children of the folder
   size_t i;
   size_t batch_s = 5;
   for (i = 0; i < batch_s; ++i) {
-    CreateUnsyncedItem(id_factory_.NewLocalId(), folder_id,
-                       base::StringPrintf("Item %"PRIuS"", i), false,
-                       syncable::BOOKMARKS, NULL);
+    entry_factory_->CreateUnsyncedItem(id_factory_.NewLocalId(), folder_id,
+                                       base::StringPrintf("Item %"PRIuS"", i),
+                                       false, syncable::BOOKMARKS, NULL);
   }
   // Next five items are children of the root.
   for (; i < 2*batch_s; ++i) {
-    CreateUnsyncedItem(id_factory_.NewLocalId(), id_factory_.root(),
-                       base::StringPrintf("Item %"PRIuS"", i), false,
-                       syncable::BOOKMARKS, NULL);
+    entry_factory_->CreateUnsyncedItem(
+        id_factory_.NewLocalId(), id_factory_.root(),
+        base::StringPrintf("Item %"PRIuS"", i), false,
+        syncable::BOOKMARKS, NULL);
   }
 
   KeyParams params = {"localhost", "dummy", "foobar"};
@@ -816,8 +666,8 @@ TEST_F(ApplyUpdatesCommandTest, EncryptUnsyncedChanges) {
   cryptographer->GetKeys(nigori->mutable_encrypted());
   nigori->set_encrypt_bookmarks(true);
   encrypted_types.Put(syncable::BOOKMARKS);
-  CreateUnappliedNewItem(syncable::ModelTypeToRootTag(syncable::NIGORI),
-                         specifics, true);
+  entry_factory_->CreateUnappliedNewItem(
+      syncable::ModelTypeToRootTag(syncable::NIGORI), specifics, true);
   EXPECT_FALSE(cryptographer->has_pending_keys());
   EXPECT_TRUE(cryptographer->is_ready());
 
@@ -856,7 +706,7 @@ TEST_F(ApplyUpdatesCommandTest, EncryptUnsyncedChanges) {
     // If ProcessUnsyncedChangesForEncryption worked, all our unsynced changes
     // should be encrypted now.
     EXPECT_TRUE(syncable::ModelTypeSet::All().Equals(
-        cryptographer->GetEncryptedTypes()));
+                cryptographer->GetEncryptedTypes()));
     EXPECT_TRUE(VerifyUnsyncedChangesAreEncrypted(&trans, encrypted_types));
 
     Syncer::UnsyncedMetaHandles handles;
@@ -870,7 +720,7 @@ TEST_F(ApplyUpdatesCommandTest, EncryptUnsyncedChanges) {
     MutableEntry entry(&trans, syncable::GET_BY_SERVER_TAG,
                        syncable::ModelTypeToRootTag(syncable::NIGORI));
     ASSERT_TRUE(entry.good());
-    entry.Put(syncable::SERVER_VERSION, GetNextRevision());
+    entry.Put(syncable::SERVER_VERSION, entry_factory_->GetNextRevision());
     entry.Put(syncable::IS_UNAPPLIED_UPDATE, true);
   }
   ExpectGroupToChange(apply_updates_command_, GROUP_PASSIVE);
@@ -928,21 +778,23 @@ TEST_F(ApplyUpdatesCommandTest, CannotEncryptUnsyncedChanges) {
   // Create unsynced bookmarks without encryption.
   // First item is a folder
   Id folder_id = id_factory_.NewLocalId();
-  CreateUnsyncedItem(folder_id, id_factory_.root(), "folder", true,
-                     syncable::BOOKMARKS, NULL);
+  entry_factory_->CreateUnsyncedItem(
+      folder_id, id_factory_.root(), "folder", true,
+      syncable::BOOKMARKS, NULL);
   // Next five items are children of the folder
   size_t i;
   size_t batch_s = 5;
   for (i = 0; i < batch_s; ++i) {
-    CreateUnsyncedItem(id_factory_.NewLocalId(), folder_id,
-                       base::StringPrintf("Item %"PRIuS"", i), false,
-                       syncable::BOOKMARKS, NULL);
+    entry_factory_->CreateUnsyncedItem(id_factory_.NewLocalId(), folder_id,
+                                       base::StringPrintf("Item %"PRIuS"", i),
+                                       false, syncable::BOOKMARKS, NULL);
   }
   // Next five items are children of the root.
   for (; i < 2*batch_s; ++i) {
-    CreateUnsyncedItem(id_factory_.NewLocalId(), id_factory_.root(),
-                       base::StringPrintf("Item %"PRIuS"", i), false,
-                       syncable::BOOKMARKS, NULL);
+    entry_factory_->CreateUnsyncedItem(
+        id_factory_.NewLocalId(), id_factory_.root(),
+        base::StringPrintf("Item %"PRIuS"", i), false,
+        syncable::BOOKMARKS, NULL);
   }
 
   // We encrypt with new keys, triggering the local cryptographer to be unready
@@ -955,8 +807,8 @@ TEST_F(ApplyUpdatesCommandTest, CannotEncryptUnsyncedChanges) {
   other_cryptographer.GetKeys(nigori->mutable_encrypted());
   nigori->set_encrypt_bookmarks(true);
   encrypted_types.Put(syncable::BOOKMARKS);
-  CreateUnappliedNewItem(syncable::ModelTypeToRootTag(syncable::NIGORI),
-                         specifics, true);
+  entry_factory_->CreateUnappliedNewItem(
+      syncable::ModelTypeToRootTag(syncable::NIGORI), specifics, true);
   EXPECT_FALSE(cryptographer->has_pending_keys());
 
   {
@@ -994,7 +846,7 @@ TEST_F(ApplyUpdatesCommandTest, CannotEncryptUnsyncedChanges) {
     // cryptographer should be updated.
     EXPECT_FALSE(VerifyUnsyncedChangesAreEncrypted(&trans, encrypted_types));
     EXPECT_TRUE(cryptographer->GetEncryptedTypes().Equals(
-        syncable::ModelTypeSet().All()));
+                syncable::ModelTypeSet().All()));
     EXPECT_FALSE(cryptographer->is_ready());
     EXPECT_TRUE(cryptographer->has_pending_keys());