WIP: The Bookmark Position Megapatch

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/basictypes.h"
 #include "base/compiler_specific.h"
 #include "base/file_path.h"
 #include "base/file_util.h"
 #include "base/files/scoped_temp_dir.h"
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop.h"
 #include "base/stringprintf.h"
 #include "base/synchronization/condition_variable.h"
 #include "base/test/values_test_util.h"
 #include "base/threading/platform_thread.h"
 #include "base/values.h"
-#include "sync/internal_api/public/base/node_ordinal.h"
 #include "sync/protocol/bookmark_specifics.pb.h"
 #include "sync/syncable/directory_backing_store.h"
 #include "sync/syncable/directory_change_delegate.h"
 #include "sync/syncable/in_memory_directory_backing_store.h"
 #include "sync/syncable/metahandle_set.h"
 #include "sync/syncable/mutable_entry.h"
 #include "sync/syncable/on_disk_directory_backing_store.h"
 #include "sync/syncable/read_transaction.h"
 #include "sync/syncable/syncable_proto_util.h"
 #include "sync/syncable/syncable_util.h"
@@ skipping 106 matching lines @@
     dir.GetChildHandlesById(&rtrans, rtrans.root_id(), &child_handles);
     EXPECT_TRUE(child_handles.empty());
 
     dir.GetChildHandlesByHandle(&rtrans, root_metahandle, &child_handles);
     EXPECT_TRUE(child_handles.empty());
   }
 
   // Test creating a new meta entry.
   {
     WriteTransaction wtrans(FROM_HERE, UNITTEST, &dir);
-    MutableEntry me(&wtrans, CREATE, wtrans.root_id(), name);
+    MutableEntry me(&wtrans, CREATE_BOOKMARK, wtrans.root_id(), name);
     ASSERT_TRUE(me.good());
     me.Put(ID, id);
     me.Put(BASE_VERSION, 1);
     written_metahandle = me.Get(META_HANDLE);
   }
 
   // Test GetChildHandles* after something is now in the DB.
   // Also check that GET_BY_ID works.
   {
     ReadTransaction rtrans(FROM_HERE, &dir);
@@ skipping 63 matching lines @@
           "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.
 
+    Entry root(&rtrans, GET_BY_ID, rtrans.root_id());
+    ASSERT_TRUE(root.good());
     EXPECT_FALSE(dir.HasChildren(&rtrans, rtrans.root_id()));
-    Id child_id;
-    EXPECT_TRUE(dir.GetFirstChildId(&rtrans, rtrans.root_id(), &child_id));
-    EXPECT_TRUE(child_id.IsRoot());
+    EXPECT_TRUE(root.GetFirstChildId().IsRoot());
   }
 
   {
     WriteTransaction wtrans(FROM_HERE, UNITTEST, &dir);
-    MutableEntry me(&wtrans, CREATE, wtrans.root_id(), name);
+    MutableEntry me(&wtrans, CREATE_BOOKMARK, wtrans.root_id(), name);
     ASSERT_TRUE(me.good());
     me.Put(ID, id);
     me.Put(BASE_VERSION, 1);
     written_metahandle = me.Get(META_HANDLE);
   }
 
   // Test children ops after something is now in the DB.
   {
     ReadTransaction rtrans(FROM_HERE, &dir);
     Entry e(&rtrans, GET_BY_ID, id);
     ASSERT_TRUE(e.good());
 
     Entry child(&rtrans, GET_BY_HANDLE, written_metahandle);
     ASSERT_TRUE(child.good());
 
+    Entry root(&rtrans, GET_BY_ID, rtrans.root_id());
+    ASSERT_TRUE(root.good());
     EXPECT_TRUE(dir.HasChildren(&rtrans, rtrans.root_id()));
-    Id child_id;
-    EXPECT_TRUE(dir.GetFirstChildId(&rtrans, rtrans.root_id(), &child_id));
-    EXPECT_EQ(e.Get(ID), child_id);
+    EXPECT_EQ(e.Get(ID), root.GetFirstChildId());
   }
 
   {
     WriteTransaction wtrans(FROM_HERE, UNITTEST, &dir);
     MutableEntry me(&wtrans, GET_BY_HANDLE, written_metahandle);
     ASSERT_TRUE(me.good());
     me.Put(IS_DEL, true);
   }
 
   // Test children ops after the children have been deleted.
   {
     ReadTransaction rtrans(FROM_HERE, &dir);
     Entry e(&rtrans, GET_BY_ID, id);
     ASSERT_TRUE(e.good());
 
+    Entry root(&rtrans, GET_BY_ID, rtrans.root_id());
+    ASSERT_TRUE(root.good());
     EXPECT_FALSE(dir.HasChildren(&rtrans, rtrans.root_id()));
-    Id child_id;
-    EXPECT_TRUE(dir.GetFirstChildId(&rtrans, rtrans.root_id(), &child_id));
-    EXPECT_TRUE(child_id.IsRoot());
+    EXPECT_TRUE(root.GetFirstChildId().IsRoot());
   }
 
   dir.SaveChanges();
 }
 
 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(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);
+      MutableEntry me(&wtrans, CREATE_BOOKMARK, 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.
@@ skipping 25 matching lines @@
   {
     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");
+      MutableEntry me(&wtrans, CREATE_BOOKMARK, 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();
   }
 
@@ skipping 34 matching lines @@
     EXPECT_FALSE(e.good());  // Hasn't been written yet.
 
     scoped_ptr<DictionaryValue> value(e.ToValue(NULL));
     ExpectDictBooleanValue(false, *value, "good");
     EXPECT_EQ(1u, value->size());
   }
 
   // Test creating a new meta entry.
   {
     WriteTransaction wtrans(FROM_HERE, UNITTEST, &dir);
-    MutableEntry me(&wtrans, CREATE, wtrans.root_id(), "new");
+    MutableEntry me(&wtrans, CREATE_BOOKMARK, wtrans.root_id(), "new");
     ASSERT_TRUE(me.good());
     me.Put(ID, id);
     me.Put(BASE_VERSION, 1);
 
     scoped_ptr<DictionaryValue> value(me.ToValue(NULL));
     ExpectDictBooleanValue(true, *value, "good");
     EXPECT_TRUE(value->HasKey("kernel"));
-    ExpectDictStringValue("Unspecified", *value, "modelType");
+    ExpectDictStringValue("Bookmarks", *value, "modelType");
     ExpectDictBooleanValue(true, *value, "existsOnClientBecauseNameIsNonEmpty");
     ExpectDictBooleanValue(false, *value, "isRoot");
   }
 
   dir.SaveChanges();
 }
 
 // A test fixture for syncable::Directory.  Uses an in-memory database to keep
 // the unit tests fast.
 class SyncableDirectoryTest : public testing::Test {
@@ skipping 74 matching lines @@
   void CreateEntry(const std::string& entryname) {
     CreateEntry(entryname, TestIdFactory::FromNumber(-99));
   }
 
   // Creates an empty entry and sets the ID field to id.
   void CreateEntry(const std::string& entryname, const int id) {
     CreateEntry(entryname, TestIdFactory::FromNumber(id));
   }
   void CreateEntry(const std::string& entryname, Id id) {
     WriteTransaction wtrans(FROM_HERE, UNITTEST, dir_.get());
-    MutableEntry me(&wtrans, CREATE, wtrans.root_id(), entryname);
+    MutableEntry me(&wtrans, CREATE_BOOKMARK, wtrans.root_id(), entryname);
     ASSERT_TRUE(me.good());
     me.Put(ID, id);
     me.Put(IS_UNSYNCED, true);
   }
 
   void ValidateEntry(BaseTransaction* trans,
                      int64 id,
                      bool check_name,
                      const std::string& name,
                      int64 base_version,
@@ skipping 19 matching lines @@
   DirOpenResult ReloadDirImpl();
 };
 
 TEST_F(SyncableDirectoryTest, TakeSnapshotGetsMetahandlesToPurge) {
   const int metas_to_create = 50;
   MetahandleSet expected_purges;
   MetahandleSet all_handles;
   {
     WriteTransaction trans(FROM_HERE, UNITTEST, dir_.get());
     for (int i = 0; i < metas_to_create; i++) {
-      MutableEntry e(&trans, CREATE, trans.root_id(), "foo");
+      MutableEntry e(&trans, CREATE_BOOKMARK, trans.root_id(), "foo");
       e.Put(IS_UNSYNCED, true);
       sync_pb::EntitySpecifics specs;
       if (i % 2 == 0) {
         AddDefaultFieldValue(BOOKMARKS, &specs);
         expected_purges.insert(e.Get(META_HANDLE));
         all_handles.insert(e.Get(META_HANDLE));
       } else {
         AddDefaultFieldValue(PREFERENCES, &specs);
         all_handles.insert(e.Get(META_HANDLE));
       }
@@ skipping 20 matching lines @@
   dir_->TakeSnapshotForSaveChanges(&snapshot2);
   EXPECT_TRUE(all_handles == snapshot2.metahandles_to_purge);
 }
 
 TEST_F(SyncableDirectoryTest, TakeSnapshotGetsAllDirtyHandlesTest) {
   const int metahandles_to_create = 100;
   std::vector<int64> expected_dirty_metahandles;
   {
     WriteTransaction trans(FROM_HERE, UNITTEST, dir_.get());
     for (int i = 0; i < metahandles_to_create; i++) {
-      MutableEntry e(&trans, CREATE, trans.root_id(), "foo");
+      MutableEntry e(&trans, CREATE_BOOKMARK, trans.root_id(), "foo");
       expected_dirty_metahandles.push_back(e.Get(META_HANDLE));
       e.Put(IS_UNSYNCED, true);
     }
   }
   // Fake SaveChanges() and make sure we got what we expected.
   {
     Directory::SaveChangesSnapshot snapshot;
     base::AutoLock scoped_lock(dir_->kernel_->save_changes_mutex);
     dir_->TakeSnapshotForSaveChanges(&snapshot);
     // Make sure there's an entry for each new metahandle.  Make sure all
@@ skipping 10 matching lines @@
     WriteTransaction trans(FROM_HERE, UNITTEST, dir_.get());
     std::vector<int64> new_dirty_metahandles;
     for (std::vector<int64>::const_iterator i =
         expected_dirty_metahandles.begin();
         i != expected_dirty_metahandles.end(); ++i) {
         // Change existing entries to directories to dirty them.
         MutableEntry e1(&trans, GET_BY_HANDLE, *i);
         e1.Put(IS_DIR, true);
         e1.Put(IS_UNSYNCED, true);
         // Add new entries
-        MutableEntry e2(&trans, CREATE, trans.root_id(), "bar");
+        MutableEntry e2(&trans, CREATE_BOOKMARK, trans.root_id(), "bar");
         e2.Put(IS_UNSYNCED, true);
         new_dirty_metahandles.push_back(e2.Get(META_HANDLE));
     }
     expected_dirty_metahandles.insert(expected_dirty_metahandles.end(),
         new_dirty_metahandles.begin(), new_dirty_metahandles.end());
   }
   // Fake SaveChanges() and make sure we got what we expected.
   {
     Directory::SaveChangesSnapshot snapshot;
     base::AutoLock scoped_lock(dir_->kernel_->save_changes_mutex);
@@ skipping 11 matching lines @@
 
 TEST_F(SyncableDirectoryTest, TakeSnapshotGetsOnlyDirtyHandlesTest) {
   const int metahandles_to_create = 100;
 
   // half of 2 * metahandles_to_create
   const unsigned int number_changed = 100u;
   std::vector<int64> expected_dirty_metahandles;
   {
     WriteTransaction trans(FROM_HERE, UNITTEST, dir_.get());
     for (int i = 0; i < metahandles_to_create; i++) {
-      MutableEntry e(&trans, CREATE, trans.root_id(), "foo");
+      MutableEntry e(&trans, CREATE_BOOKMARK, trans.root_id(), "foo");
       expected_dirty_metahandles.push_back(e.Get(META_HANDLE));
       e.Put(IS_UNSYNCED, true);
     }
   }
   dir_->SaveChanges();
   // Put a new value with existing transactions as well as adding new ones.
   {
     WriteTransaction trans(FROM_HERE, UNITTEST, dir_.get());
     std::vector<int64> new_dirty_metahandles;
     for (std::vector<int64>::const_iterator i =
         expected_dirty_metahandles.begin();
         i != expected_dirty_metahandles.end(); ++i) {
         // Change existing entries to directories to dirty them.
         MutableEntry e1(&trans, GET_BY_HANDLE, *i);
         ASSERT_TRUE(e1.good());
         e1.Put(IS_DIR, true);
         e1.Put(IS_UNSYNCED, true);
         // Add new entries
-        MutableEntry e2(&trans, CREATE, trans.root_id(), "bar");
+        MutableEntry e2(&trans, CREATE_BOOKMARK, trans.root_id(), "bar");
         e2.Put(IS_UNSYNCED, true);
         new_dirty_metahandles.push_back(e2.Get(META_HANDLE));
     }
     expected_dirty_metahandles.insert(expected_dirty_metahandles.end(),
         new_dirty_metahandles.begin(), new_dirty_metahandles.end());
   }
   dir_->SaveChanges();
   // Don't make any changes whatsoever and ensure nothing comes back.
   {
     WriteTransaction trans(FROM_HERE, UNITTEST, dir_.get());
@@ skipping 60 matching lines @@
 TEST_F(SyncableDirectoryTest, TestBasicLookupValidID) {
   CreateEntry("rtc");
   ReadTransaction rtrans(FROM_HERE, dir_.get());
   Entry e(&rtrans, GET_BY_ID, TestIdFactory::FromNumber(-99));
   ASSERT_TRUE(e.good());
 }
 
 TEST_F(SyncableDirectoryTest, TestDelete) {
   std::string name = "peanut butter jelly time";
   WriteTransaction trans(FROM_HERE, UNITTEST, dir_.get());
-  MutableEntry e1(&trans, CREATE, trans.root_id(), name);
+  MutableEntry e1(&trans, CREATE_BOOKMARK, trans.root_id(), name);
   ASSERT_TRUE(e1.good());
   ASSERT_TRUE(e1.Put(IS_DEL, true));
-  MutableEntry e2(&trans, CREATE, trans.root_id(), name);
+  MutableEntry e2(&trans, CREATE_BOOKMARK, trans.root_id(), name);
   ASSERT_TRUE(e2.good());
   ASSERT_TRUE(e2.Put(IS_DEL, true));
-  MutableEntry e3(&trans, CREATE, trans.root_id(), name);
+  MutableEntry e3(&trans, CREATE_BOOKMARK, trans.root_id(), name);
   ASSERT_TRUE(e3.good());
   ASSERT_TRUE(e3.Put(IS_DEL, true));
 
   ASSERT_TRUE(e1.Put(IS_DEL, false));
   ASSERT_TRUE(e2.Put(IS_DEL, false));
   ASSERT_TRUE(e3.Put(IS_DEL, false));
 
   ASSERT_TRUE(e1.Put(IS_DEL, true));
   ASSERT_TRUE(e2.Put(IS_DEL, true));
   ASSERT_TRUE(e3.Put(IS_DEL, true));
 }
 
 TEST_F(SyncableDirectoryTest, TestGetUnsynced) {
   Directory::UnsyncedMetaHandles handles;
   int64 handle1, handle2;
   {
     WriteTransaction trans(FROM_HERE, UNITTEST, dir_.get());
 
     dir_->GetUnsyncedMetaHandles(&trans, &handles);
     ASSERT_TRUE(0 == handles.size());
 
-    MutableEntry e1(&trans, CREATE, trans.root_id(), "abba");
+    MutableEntry e1(&trans, CREATE_BOOKMARK, trans.root_id(), "abba");
     ASSERT_TRUE(e1.good());
     handle1 = e1.Get(META_HANDLE);
     e1.Put(BASE_VERSION, 1);
     e1.Put(IS_DIR, true);
     e1.Put(ID, TestIdFactory::FromNumber(101));
 
-    MutableEntry e2(&trans, CREATE, e1.Get(ID), "bread");
+    MutableEntry e2(&trans, CREATE_BOOKMARK, e1.Get(ID), "bread");
     ASSERT_TRUE(e2.good());
     handle2 = e2.Get(META_HANDLE);
     e2.Put(BASE_VERSION, 1);
     e2.Put(ID, TestIdFactory::FromNumber(102));
   }
   dir_->SaveChanges();
   {
     WriteTransaction trans(FROM_HERE, UNITTEST, dir_.get());
 
     dir_->GetUnsyncedMetaHandles(&trans, &handles);
@@ skipping 44 matching lines @@
 TEST_F(SyncableDirectoryTest, TestGetUnappliedUpdates) {
   std::vector<int64> handles;
   int64 handle1, handle2;
   const FullModelTypeSet all_types = FullModelTypeSet::All();
   {
     WriteTransaction trans(FROM_HERE, UNITTEST, dir_.get());
 
     dir_->GetUnappliedUpdateMetaHandles(&trans, all_types, &handles);
     ASSERT_TRUE(0 == handles.size());
 
-    MutableEntry e1(&trans, CREATE, trans.root_id(), "abba");
+    MutableEntry e1(&trans, CREATE_BOOKMARK, trans.root_id(), "abba");
     ASSERT_TRUE(e1.good());
     handle1 = e1.Get(META_HANDLE);
     e1.Put(IS_UNAPPLIED_UPDATE, false);
     e1.Put(BASE_VERSION, 1);
     e1.Put(ID, TestIdFactory::FromNumber(101));
     e1.Put(IS_DIR, true);
 
-    MutableEntry e2(&trans, CREATE, e1.Get(ID), "bread");
+    MutableEntry e2(&trans, CREATE_BOOKMARK, e1.Get(ID), "bread");
     ASSERT_TRUE(e2.good());
     handle2 = e2.Get(META_HANDLE);
     e2.Put(IS_UNAPPLIED_UPDATE, false);
     e2.Put(BASE_VERSION, 1);
     e2.Put(ID, TestIdFactory::FromNumber(102));
   }
   dir_->SaveChanges();
   {
     WriteTransaction trans(FROM_HERE, UNITTEST, dir_.get());
 
@@ skipping 40 matching lines @@
   }
 }
 
 
 TEST_F(SyncableDirectoryTest, DeleteBug_531383) {
   // Try to evoke a check failure...
   TestIdFactory id_factory;
   int64 grandchild_handle;
   {
     WriteTransaction wtrans(FROM_HERE, UNITTEST, dir_.get());
-    MutableEntry parent(&wtrans, CREATE, id_factory.root(), "Bob");
+    MutableEntry parent(&wtrans, CREATE_BOOKMARK, id_factory.root(), "Bob");
     ASSERT_TRUE(parent.good());
     parent.Put(IS_DIR, true);
     parent.Put(ID, id_factory.NewServerId());
     parent.Put(BASE_VERSION, 1);
-    MutableEntry child(&wtrans, CREATE, parent.Get(ID), "Bob");
+    MutableEntry child(&wtrans, CREATE_BOOKMARK, parent.Get(ID), "Bob");
     ASSERT_TRUE(child.good());
     child.Put(IS_DIR, true);
     child.Put(ID, id_factory.NewServerId());
     child.Put(BASE_VERSION, 1);
-    MutableEntry grandchild(&wtrans, CREATE, child.Get(ID), "Bob");
+    MutableEntry grandchild(&wtrans, CREATE_BOOKMARK, child.Get(ID), "Bob");
     ASSERT_TRUE(grandchild.good());
     grandchild.Put(ID, id_factory.NewServerId());
     grandchild.Put(BASE_VERSION, 1);
     ASSERT_TRUE(grandchild.Put(IS_DEL, true));
-    MutableEntry twin(&wtrans, CREATE, child.Get(ID), "Bob");
+    MutableEntry twin(&wtrans, CREATE_BOOKMARK, child.Get(ID), "Bob");
     ASSERT_TRUE(twin.good());
     ASSERT_TRUE(twin.Put(IS_DEL, true));
     ASSERT_TRUE(grandchild.Put(IS_DEL, false));
 
     grandchild_handle = grandchild.Get(META_HANDLE);
   }
   dir_->SaveChanges();
   {
     WriteTransaction wtrans(FROM_HERE, UNITTEST, dir_.get());
     MutableEntry grandchild(&wtrans, GET_BY_HANDLE, grandchild_handle);
     grandchild.Put(IS_DEL, true);  // Used to CHECK fail here.
   }
 }
 
 static inline bool IsLegalNewParent(const Entry& a, const Entry& b) {
   return IsLegalNewParent(a.trans(), a.Get(ID), b.Get(ID));
 }
 
 TEST_F(SyncableDirectoryTest, TestIsLegalNewParent) {
   TestIdFactory id_factory;
   WriteTransaction wtrans(FROM_HERE, UNITTEST, dir_.get());
   Entry root(&wtrans, GET_BY_ID, id_factory.root());
   ASSERT_TRUE(root.good());
-  MutableEntry parent(&wtrans, CREATE, root.Get(ID), "Bob");
+  MutableEntry parent(&wtrans, CREATE_BOOKMARK, root.Get(ID), "Bob");
   ASSERT_TRUE(parent.good());
   parent.Put(IS_DIR, true);
   parent.Put(ID, id_factory.NewServerId());
   parent.Put(BASE_VERSION, 1);
-  MutableEntry child(&wtrans, CREATE, parent.Get(ID), "Bob");
+  MutableEntry child(&wtrans, CREATE_BOOKMARK, parent.Get(ID), "Bob");
   ASSERT_TRUE(child.good());
   child.Put(IS_DIR, true);
   child.Put(ID, id_factory.NewServerId());
   child.Put(BASE_VERSION, 1);
-  MutableEntry grandchild(&wtrans, CREATE, child.Get(ID), "Bob");
+  MutableEntry grandchild(&wtrans, CREATE_BOOKMARK, child.Get(ID), "Bob");
   ASSERT_TRUE(grandchild.good());
   grandchild.Put(ID, id_factory.NewServerId());
   grandchild.Put(BASE_VERSION, 1);
 
-  MutableEntry parent2(&wtrans, CREATE, root.Get(ID), "Pete");
+  MutableEntry parent2(&wtrans, CREATE_BOOKMARK, root.Get(ID), "Pete");
   ASSERT_TRUE(parent2.good());
   parent2.Put(IS_DIR, true);
   parent2.Put(ID, id_factory.NewServerId());
   parent2.Put(BASE_VERSION, 1);
-  MutableEntry child2(&wtrans, CREATE, parent2.Get(ID), "Pete");
+  MutableEntry child2(&wtrans, CREATE_BOOKMARK, parent2.Get(ID), "Pete");
   ASSERT_TRUE(child2.good());
   child2.Put(IS_DIR, true);
   child2.Put(ID, id_factory.NewServerId());
   child2.Put(BASE_VERSION, 1);
-  MutableEntry grandchild2(&wtrans, CREATE, child2.Get(ID), "Pete");
+  MutableEntry grandchild2(&wtrans, CREATE_BOOKMARK, child2.Get(ID), "Pete");
   ASSERT_TRUE(grandchild2.good());
   grandchild2.Put(ID, id_factory.NewServerId());
   grandchild2.Put(BASE_VERSION, 1);
   // resulting tree
   //           root
   //           /  |
   //     parent    parent2
   //          |    |
   //      child    child2
   //          |    |
@@ skipping 11 matching lines @@
 
 TEST_F(SyncableDirectoryTest, TestEntryIsInFolder) {
   // Create a subdir and an entry.
   int64 entry_handle;
   syncable::Id folder_id;
   syncable::Id entry_id;
   std::string entry_name = "entry";
 
   {
     WriteTransaction trans(FROM_HERE, UNITTEST, dir_.get());
-    MutableEntry folder(&trans, CREATE, trans.root_id(), "folder");
+    MutableEntry folder(&trans, CREATE_BOOKMARK, trans.root_id(), "folder");
     ASSERT_TRUE(folder.good());
     EXPECT_TRUE(folder.Put(IS_DIR, true));
     EXPECT_TRUE(folder.Put(IS_UNSYNCED, true));
     folder_id = folder.Get(ID);
 
-    MutableEntry entry(&trans, CREATE, folder.Get(ID), entry_name);
+    MutableEntry entry(&trans, CREATE_BOOKMARK, folder.Get(ID), entry_name);
     ASSERT_TRUE(entry.good());
     entry_handle = entry.Get(META_HANDLE);
     entry.Put(IS_UNSYNCED, true);
     entry_id = entry.Get(ID);
   }
 
   // Make sure we can find the entry in the folder.
   {
     ReadTransaction trans(FROM_HERE, dir_.get());
     EXPECT_EQ(0, CountEntriesWithName(&trans, trans.root_id(), entry_name));
     EXPECT_EQ(1, CountEntriesWithName(&trans, folder_id, entry_name));
 
     Entry entry(&trans, GET_BY_ID, entry_id);
     ASSERT_TRUE(entry.good());
     EXPECT_EQ(entry_handle, entry.Get(META_HANDLE));
     EXPECT_TRUE(entry.Get(NON_UNIQUE_NAME) == entry_name);
     EXPECT_TRUE(entry.Get(PARENT_ID) == folder_id);
   }
 }
 
 TEST_F(SyncableDirectoryTest, TestParentIdIndexUpdate) {
   std::string child_name = "child";
 
   WriteTransaction wt(FROM_HERE, UNITTEST, dir_.get());
-  MutableEntry parent_folder(&wt, CREATE, wt.root_id(), "folder1");
+  MutableEntry parent_folder(&wt, CREATE_BOOKMARK, wt.root_id(), "folder1");
   parent_folder.Put(IS_UNSYNCED, true);
   EXPECT_TRUE(parent_folder.Put(IS_DIR, true));
 
-  MutableEntry parent_folder2(&wt, CREATE, wt.root_id(), "folder2");
+  MutableEntry parent_folder2(&wt, CREATE_BOOKMARK, wt.root_id(), "folder2");
   parent_folder2.Put(IS_UNSYNCED, true);
   EXPECT_TRUE(parent_folder2.Put(IS_DIR, true));
 
-  MutableEntry child(&wt, CREATE, parent_folder.Get(ID), child_name);
+  MutableEntry child(&wt, CREATE_BOOKMARK, parent_folder.Get(ID), child_name);
   EXPECT_TRUE(child.Put(IS_DIR, true));
   child.Put(IS_UNSYNCED, true);
 
   ASSERT_TRUE(child.good());
 
   EXPECT_EQ(0, CountEntriesWithName(&wt, wt.root_id(), child_name));
   EXPECT_EQ(parent_folder.Get(ID), child.Get(PARENT_ID));
   EXPECT_EQ(1, CountEntriesWithName(&wt, parent_folder.Get(ID), child_name));
   EXPECT_EQ(0, CountEntriesWithName(&wt, parent_folder2.Get(ID), child_name));
   child.Put(PARENT_ID, parent_folder2.Get(ID));
   EXPECT_EQ(parent_folder2.Get(ID), child.Get(PARENT_ID));
   EXPECT_EQ(0, CountEntriesWithName(&wt, parent_folder.Get(ID), child_name));
   EXPECT_EQ(1, CountEntriesWithName(&wt, parent_folder2.Get(ID), child_name));
 }
 
 TEST_F(SyncableDirectoryTest, TestNoReindexDeletedItems) {
   std::string folder_name = "folder";
   std::string new_name = "new_name";
 
   WriteTransaction trans(FROM_HERE, UNITTEST, dir_.get());
-  MutableEntry folder(&trans, CREATE, trans.root_id(), folder_name);
+  MutableEntry folder(&trans, CREATE_BOOKMARK, trans.root_id(), folder_name);
   ASSERT_TRUE(folder.good());
   ASSERT_TRUE(folder.Put(IS_DIR, true));
   ASSERT_TRUE(folder.Put(IS_DEL, true));
 
   EXPECT_EQ(0, CountEntriesWithName(&trans, trans.root_id(), folder_name));
 
   MutableEntry deleted(&trans, GET_BY_ID, folder.Get(ID));
   ASSERT_TRUE(deleted.good());
   ASSERT_TRUE(deleted.Put(PARENT_ID, trans.root_id()));
   ASSERT_TRUE(deleted.Put(NON_UNIQUE_NAME, new_name));
 
   EXPECT_EQ(0, CountEntriesWithName(&trans, trans.root_id(), folder_name));
   EXPECT_EQ(0, CountEntriesWithName(&trans, trans.root_id(), new_name));
 }
 
 TEST_F(SyncableDirectoryTest, TestCaseChangeRename) {
   WriteTransaction trans(FROM_HERE, UNITTEST, dir_.get());
-  MutableEntry folder(&trans, CREATE, trans.root_id(), "CaseChange");
+  MutableEntry folder(&trans, CREATE_BOOKMARK, trans.root_id(), "CaseChange");
   ASSERT_TRUE(folder.good());
   EXPECT_TRUE(folder.Put(PARENT_ID, trans.root_id()));
   EXPECT_TRUE(folder.Put(NON_UNIQUE_NAME, "CASECHANGE"));
   EXPECT_TRUE(folder.Put(IS_DEL, true));
 }
 
 // Create items of each model type, and check that GetModelType and
 // GetServerModelType return the right value.
 TEST_F(SyncableDirectoryTest, GetModelType) {
   TestIdFactory id_factory;
   for (int i = 0; i < MODEL_TYPE_COUNT; ++i) {
     ModelType datatype = ModelTypeFromInt(i);
     SCOPED_TRACE(testing::Message("Testing model type ") << datatype);
     switch (datatype) {
       case UNSPECIFIED:
       case TOP_LEVEL_FOLDER:
         continue;  // Datatype isn't a function of Specifics.
       default:
         break;
     }
     sync_pb::EntitySpecifics specifics;
     AddDefaultFieldValue(datatype, &specifics);
 
     WriteTransaction trans(FROM_HERE, UNITTEST, dir_.get());
 
-    MutableEntry folder(&trans, CREATE, trans.root_id(), "Folder");
+    MutableEntry folder(&trans, CREATE_BOOKMARK, trans.root_id(), "Folder");
     ASSERT_TRUE(folder.good());
     folder.Put(ID, id_factory.NewServerId());
     folder.Put(SPECIFICS, specifics);
     folder.Put(BASE_VERSION, 1);
     folder.Put(IS_DIR, true);
     folder.Put(IS_DEL, false);
     ASSERT_EQ(datatype, folder.GetModelType());
 
-    MutableEntry item(&trans, CREATE, trans.root_id(), "Item");
+    MutableEntry item(&trans, CREATE_BOOKMARK, trans.root_id(), "Item");
     ASSERT_TRUE(item.good());
     item.Put(ID, id_factory.NewServerId());
     item.Put(SPECIFICS, specifics);
     item.Put(BASE_VERSION, 1);
     item.Put(IS_DIR, false);
     item.Put(IS_DEL, false);
     ASSERT_EQ(datatype, item.GetModelType());
 
     // It's critical that deletion records retain their datatype, so that
     // they can be dispatched to the appropriate change processor.
-    MutableEntry deleted_item(&trans, CREATE, trans.root_id(), "Deleted Item");
+    MutableEntry deleted_item(
+        &trans, CREATE_BOOKMARK, trans.root_id(), "Deleted Item");
     ASSERT_TRUE(item.good());
     deleted_item.Put(ID, id_factory.NewServerId());
     deleted_item.Put(SPECIFICS, specifics);
     deleted_item.Put(BASE_VERSION, 1);
     deleted_item.Put(IS_DIR, false);
     deleted_item.Put(IS_DEL, true);
     ASSERT_EQ(datatype, deleted_item.GetModelType());
 
     MutableEntry server_folder(&trans, CREATE_NEW_UPDATE_ITEM,
         id_factory.NewServerId());
@@ skipping 34 matching lines @@
 // a more common variant of the 'DeletedAndUnsyncedChild' scenario tested below.
 TEST_F(SyncableDirectoryTest, ChangeEntryIDAndUpdateChildren_ParentAndChild) {
   TestIdFactory id_factory;
   Id orig_parent_id;
   Id orig_child_id;
 
   {
     // Create two client-side items, a parent and child.
     WriteTransaction trans(FROM_HERE, UNITTEST, dir_.get());
 
-    MutableEntry parent(&trans, CREATE, id_factory.root(), "parent");
+    MutableEntry parent(&trans, CREATE_BOOKMARK, id_factory.root(), "parent");
     parent.Put(IS_DIR, true);
     parent.Put(IS_UNSYNCED, true);
 
-    MutableEntry child(&trans, CREATE, parent.Get(ID), "child");
+    MutableEntry child(&trans, CREATE_BOOKMARK, parent.Get(ID), "child");
     child.Put(IS_UNSYNCED, true);
 
     orig_parent_id = parent.Get(ID);
     orig_child_id = child.Get(ID);
   }
 
   {
     // Simulate what happens after committing two items.  Their IDs will be
     // replaced with server IDs.  The child is renamed first, then the parent.
     WriteTransaction trans(FROM_HERE, UNITTEST, dir_.get());
@@ skipping 23 matching lines @@
 TEST_F(SyncableDirectoryTest,
        ChangeEntryIDAndUpdateChildren_DeletedAndUnsyncedChild) {
   TestIdFactory id_factory;
   Id orig_parent_id;
   Id orig_child_id;
 
   {
     // Create two client-side items, a parent and child.
     WriteTransaction trans(FROM_HERE, UNITTEST, dir_.get());
 
-    MutableEntry parent(&trans, CREATE, id_factory.root(), "parent");
+    MutableEntry parent(&trans, CREATE_BOOKMARK, id_factory.root(), "parent");
     parent.Put(IS_DIR, true);
     parent.Put(IS_UNSYNCED, true);
 
-    MutableEntry child(&trans, CREATE, parent.Get(ID), "child");
+    MutableEntry child(&trans, CREATE_BOOKMARK, parent.Get(ID), "child");
     child.Put(IS_UNSYNCED, true);
 
     orig_parent_id = parent.Get(ID);
     orig_child_id = child.Get(ID);
   }
 
   {
     // Delete the child.
     WriteTransaction trans(FROM_HERE, UNITTEST, dir_.get());
 
@@ skipping 58 matching lines @@
   Id zombie_id = id_factory.NewLocalId();
 
   // We're about to do some bad things.  Tell the directory verification
   // routines to look the other way.
   dir_->SetInvariantCheckLevel(OFF);
 
   {
     WriteTransaction trans(FROM_HERE, UNITTEST, dir_.get());
 
     // Create an uncommitted tombstone entry.
-    MutableEntry server_knows(&trans, CREATE, id_factory.root(),
+    MutableEntry server_knows(&trans, CREATE_BOOKMARK, id_factory.root(),
                               "server_knows");
     server_knows.Put(ID, server_knows_id);
     server_knows.Put(IS_UNSYNCED, true);
     server_knows.Put(IS_DEL, true);
     server_knows.Put(BASE_VERSION, 5);
     server_knows.Put(SERVER_VERSION, 4);
 
     // Create a valid update entry.
-    MutableEntry not_is_del(&trans, CREATE, id_factory.root(), "not_is_del");
+    MutableEntry not_is_del(
+        &trans, CREATE_BOOKMARK, id_factory.root(), "not_is_del");
     not_is_del.Put(ID, not_is_del_id);
     not_is_del.Put(IS_DEL, false);
     not_is_del.Put(IS_UNSYNCED, true);
 
     // Create a tombstone which should never be sent to the server because the
     // server never knew about the item's existence.
     //
     // New clients should never put entries into this state.  We work around
     // this by setting IS_DEL before setting IS_UNSYNCED, something which the
     // client should never do in practice.
-    MutableEntry zombie(&trans, CREATE, id_factory.root(), "zombie");
+    MutableEntry zombie(&trans, CREATE_BOOKMARK, id_factory.root(), "zombie");
     zombie.Put(ID, zombie_id);
     zombie.Put(IS_DEL, true);
     zombie.Put(IS_UNSYNCED, true);
   }
 
   ASSERT_EQ(OPENED, SimulateSaveAndReloadDir());
 
   {
     ReadTransaction trans(FROM_HERE, dir_.get());
 
     // The directory loading routines should have cleaned things up, making it
     // safe to check invariants once again.
     dir_->FullyCheckTreeInvariants(&trans);
 
     Entry server_knows(&trans, GET_BY_ID, server_knows_id);
     EXPECT_TRUE(server_knows.good());
 
     Entry not_is_del(&trans, GET_BY_ID, not_is_del_id);
     EXPECT_TRUE(not_is_del.good());
 
     Entry zombie(&trans, GET_BY_ID, zombie_id);
     EXPECT_FALSE(zombie.good());
   }
 }
 
-TEST_F(SyncableDirectoryTest, OrdinalWithNullSurvivesSaveAndReload) {
+TEST_F(SyncableDirectoryTest, PositionWithNullSurvivesSaveAndReload) {
   TestIdFactory id_factory;
   Id null_child_id;
   const char null_cstr[] = "\0null\0test";
   std::string null_str(null_cstr, arraysize(null_cstr) - 1);
-  NodeOrdinal null_ord = NodeOrdinal(null_str);
+  std::string suffix =
+      std::string(UniquePosition::kSuffixLength - null_str.length(), '\x7f')
+      + null_str;
+  UniquePosition null_pos = UniquePosition::FromInt64(10, suffix);
 
   {
     WriteTransaction trans(FROM_HERE, UNITTEST, dir_.get());
 
-    MutableEntry parent(&trans, CREATE, id_factory.root(), "parent");
+    MutableEntry parent(&trans, CREATE_BOOKMARK, id_factory.root(), "parent");
     parent.Put(IS_DIR, true);
     parent.Put(IS_UNSYNCED, true);
 
-    MutableEntry child(&trans, CREATE, parent.Get(ID), "child");
+    MutableEntry child(&trans, CREATE_BOOKMARK, parent.Get(ID), "child");
     child.Put(IS_UNSYNCED, true);
-    child.Put(SERVER_ORDINAL_IN_PARENT, null_ord);
+    child.Put(UNIQUE_POSITION, null_pos);
+    child.Put(SERVER_UNIQUE_POSITION, null_pos);
 
     null_child_id = child.Get(ID);
   }
 
   EXPECT_EQ(OPENED, SimulateSaveAndReloadDir());
 
   {
     ReadTransaction trans(FROM_HERE, dir_.get());
 
     Entry null_ordinal_child(&trans, GET_BY_ID, null_child_id);
     EXPECT_TRUE(
-        null_ord.Equals(null_ordinal_child.Get(SERVER_ORDINAL_IN_PARENT)));
+        null_pos.Equals(null_ordinal_child.Get(UNIQUE_POSITION)));
+    EXPECT_TRUE(
+        null_pos.Equals(null_ordinal_child.Get(SERVER_UNIQUE_POSITION)));
   }
-
 }
 
 // An OnDirectoryBackingStore that can be set to always fail SaveChanges.
 class TestBackingStore : public OnDiskDirectoryBackingStore {
  public:
   TestBackingStore(const std::string& dir_name,
                    const FilePath& backing_filepath);
 
   virtual ~TestBackingStore();
 
@@ skipping 147 matching lines @@
     WriteTransaction trans(FROM_HERE, UNITTEST, dir_.get());
 
     // Make it look like these types have completed initial sync.
     CreateTypeRoot(&trans, dir_.get(), BOOKMARKS);
     CreateTypeRoot(&trans, dir_.get(), PREFERENCES);
     CreateTypeRoot(&trans, dir_.get(), AUTOFILL);
 
     // Add more nodes for this type.  Technically, they should be placed under
     // the proper type root nodes but the assertions in this test won't notice
     // if their parent isn't quite right.
-    MutableEntry item1(&trans, CREATE, trans.root_id(), "Item");
+    MutableEntry item1(&trans, CREATE_BOOKMARK, trans.root_id(), "Item");
     ASSERT_TRUE(item1.good());
-    item1.Put(SPECIFICS, bookmark_specs);
     item1.Put(SERVER_SPECIFICS, bookmark_specs);
     item1.Put(IS_UNSYNCED, true);
 
     MutableEntry item2(&trans, CREATE_NEW_UPDATE_ITEM,
                        id_factory.NewServerId());
     ASSERT_TRUE(item2.good());
     item2.Put(SERVER_SPECIFICS, bookmark_specs);
     item2.Put(IS_UNAPPLIED_UPDATE, true);
 
-    MutableEntry item3(&trans, CREATE, trans.root_id(), "Item");
+    MutableEntry item3(&trans, CREATE_UNIQUE, PREFERENCES,
+                       trans.root_id(), "Item");
     ASSERT_TRUE(item3.good());
     item3.Put(SPECIFICS, preference_specs);
     item3.Put(SERVER_SPECIFICS, preference_specs);
     item3.Put(IS_UNSYNCED, true);
 
     MutableEntry item4(&trans, CREATE_NEW_UPDATE_ITEM,
                        id_factory.NewServerId());
     ASSERT_TRUE(item4.good());
     item4.Put(SERVER_SPECIFICS, preference_specs);
     item4.Put(IS_UNAPPLIED_UPDATE, true);
 
-    MutableEntry item5(&trans, CREATE, trans.root_id(), "Item");
+    MutableEntry item5(&trans, CREATE_UNIQUE, AUTOFILL,
+                       trans.root_id(), "Item");
     ASSERT_TRUE(item5.good());
     item5.Put(SPECIFICS, autofill_specs);
     item5.Put(SERVER_SPECIFICS, autofill_specs);
     item5.Put(IS_UNSYNCED, true);
 
     MutableEntry item6(&trans, CREATE_NEW_UPDATE_ITEM,
       id_factory.NewServerId());
     ASSERT_TRUE(item6.good());
     item6.Put(SERVER_SPECIFICS, autofill_specs);
     item6.Put(IS_UNAPPLIED_UPDATE, true);
@@ skipping 56 matching lines @@
 TEST_F(OnDiskSyncableDirectoryTest,
        TestSimpleFieldsPreservedDuringSaveChanges) {
   Id update_id = TestIdFactory::FromNumber(1);
   Id create_id;
   EntryKernel create_pre_save, update_pre_save;
   EntryKernel create_post_save, update_post_save;
   std::string create_name =  "Create";
 
   {
     WriteTransaction trans(FROM_HERE, UNITTEST, dir_.get());
-    MutableEntry create(&trans, CREATE, trans.root_id(), create_name);
+    MutableEntry create(&trans, CREATE_BOOKMARK, trans.root_id(), create_name);
     MutableEntry update(&trans, CREATE_NEW_UPDATE_ITEM, update_id);
     create.Put(IS_UNSYNCED, true);
     update.Put(IS_UNAPPLIED_UPDATE, true);
     sync_pb::EntitySpecifics specifics;
     specifics.mutable_bookmark()->set_favicon("PNG");
     specifics.mutable_bookmark()->set_url("http://nowhere");
     create.Put(SPECIFICS, specifics);
     update.Put(SPECIFICS, specifics);
     create_pre_save = create.GetKernelCopy();
     update_pre_save = update.GetKernelCopy();
@@ skipping 63 matching lines @@
               << "String field #" << i << " changed during save/load";
   }
   for ( ; i < PROTO_FIELDS_END; ++i) {
     EXPECT_EQ(create_pre_save.ref((ProtoField)i).SerializeAsString(),
               create_post_save.ref((ProtoField)i).SerializeAsString())
               << "Blob field #" << i << " changed during save/load";
     EXPECT_EQ(update_pre_save.ref((ProtoField)i).SerializeAsString(),
               update_post_save.ref((ProtoField)i).SerializeAsString())
               << "Blob field #" << i << " changed during save/load";
   }
-  for ( ; i < ORDINAL_FIELDS_END; ++i) {
-    EXPECT_EQ(create_pre_save.ref((OrdinalField)i).ToInternalValue(),
-              create_post_save.ref((OrdinalField)i).ToInternalValue())
-              << "Blob field #" << i << " changed during save/load";
-    EXPECT_EQ(update_pre_save.ref((OrdinalField)i).ToInternalValue(),
-              update_post_save.ref((OrdinalField)i).ToInternalValue())
-              << "Blob field #" << i << " changed during save/load";
+  for ( ; i < UNIQUE_POSITION_FIELDS_END; ++i) {
+    EXPECT_EQ(create_pre_save.ref((UniquePositionField)i).ToInternalValue(),
+              create_post_save.ref((UniquePositionField)i).ToInternalValue())
+              << "Position field #" << i << " changed during save/load";
+    EXPECT_EQ(update_pre_save.ref((UniquePositionField)i).ToInternalValue(),
+              update_post_save.ref((UniquePositionField)i).ToInternalValue())
+              << "Position field #" << i << " changed during save/load";
+  }
+  for ( ; i < BYTES_FIELDS_END; ++i) {
+    EXPECT_EQ(create_pre_save.ref((BytesField)i),
+              create_post_save.ref((BytesField)i))
+              << "Bytes field #" << i << " changed during save/load";
+    EXPECT_EQ(update_pre_save.ref((BytesField)i),
+              update_post_save.ref((BytesField)i))
+              << "Bytes field #" << i << " changed during save/load";
   }
 }
 
 TEST_F(OnDiskSyncableDirectoryTest, TestSaveChangesFailure) {
   int64 handle1 = 0;
   // Set up an item using a regular, saveable directory.
   {
     WriteTransaction trans(FROM_HERE, UNITTEST, dir_.get());
 
-    MutableEntry e1(&trans, CREATE, trans.root_id(), "aguilera");
+    MutableEntry e1(&trans, CREATE_BOOKMARK, trans.root_id(), "aguilera");
     ASSERT_TRUE(e1.good());
     EXPECT_TRUE(e1.GetKernelCopy().is_dirty());
     handle1 = e1.Get(META_HANDLE);
     e1.Put(BASE_VERSION, 1);
     e1.Put(IS_DIR, true);
     e1.Put(ID, TestIdFactory::FromNumber(101));
     EXPECT_TRUE(e1.GetKernelCopy().is_dirty());
     EXPECT_TRUE(IsInDirtyMetahandles(handle1));
   }
   ASSERT_TRUE(dir_->SaveChanges());
@@ skipping 25 matching lines @@
     ASSERT_TRUE(aguilera.good());
     EXPECT_FALSE(aguilera.GetKernelCopy().is_dirty());
     EXPECT_EQ(aguilera.Get(NON_UNIQUE_NAME), "overwritten");
     EXPECT_FALSE(aguilera.GetKernelCopy().is_dirty());
     EXPECT_FALSE(IsInDirtyMetahandles(handle1));
     aguilera.Put(NON_UNIQUE_NAME, "christina");
     EXPECT_TRUE(aguilera.GetKernelCopy().is_dirty());
     EXPECT_TRUE(IsInDirtyMetahandles(handle1));
 
     // New item.
-    MutableEntry kids_on_block(&trans, CREATE, trans.root_id(), "kids");
+    MutableEntry kids_on_block(
+        &trans, CREATE_BOOKMARK, trans.root_id(), "kids");
     ASSERT_TRUE(kids_on_block.good());
     handle2 = kids_on_block.Get(META_HANDLE);
     kids_on_block.Put(BASE_VERSION, 1);
     kids_on_block.Put(IS_DIR, true);
     kids_on_block.Put(ID, TestIdFactory::FromNumber(102));
     EXPECT_TRUE(kids_on_block.GetKernelCopy().is_dirty());
     EXPECT_TRUE(IsInDirtyMetahandles(handle2));
   }
 
   // We are using an unsaveable directory, so this can't succeed.  However,
@@ skipping 14 matching lines @@
      EXPECT_TRUE(IsInDirtyMetahandles(handle1));
   }
 }
 
 TEST_F(OnDiskSyncableDirectoryTest, TestSaveChangesFailureWithPurge) {
   int64 handle1 = 0;
   // Set up an item using a regular, saveable directory.
   {
     WriteTransaction trans(FROM_HERE, UNITTEST, dir_.get());
 
-    MutableEntry e1(&trans, CREATE, trans.root_id(), "aguilera");
+    MutableEntry e1(&trans, CREATE_BOOKMARK, trans.root_id(), "aguilera");
     ASSERT_TRUE(e1.good());
     EXPECT_TRUE(e1.GetKernelCopy().is_dirty());
     handle1 = e1.Get(META_HANDLE);
     e1.Put(BASE_VERSION, 1);
     e1.Put(IS_DIR, true);
     e1.Put(ID, TestIdFactory::FromNumber(101));
     sync_pb::EntitySpecifics bookmark_specs;
     AddDefaultFieldValue(BOOKMARKS, &bookmark_specs);
     e1.Put(SPECIFICS, bookmark_specs);
     e1.Put(SERVER_SPECIFICS, bookmark_specs);
@@ skipping 123 matching lines @@
       if (rand_action < 4 && !path_name.empty()) {
         ReadTransaction trans(FROM_HERE, dir_);
         CHECK(1 == CountEntriesWithName(&trans, trans.root_id(), path_name));
         base::PlatformThread::Sleep(base::TimeDelta::FromMilliseconds(
             rand() % 10));
       } else {
         std::string unique_name =
             base::StringPrintf("%d.%d", thread_number_, entry_count++);
         path_name.assign(unique_name.begin(), unique_name.end());
         WriteTransaction trans(FROM_HERE, UNITTEST, dir_);
-        MutableEntry e(&trans, CREATE, trans.root_id(), path_name);
+        MutableEntry e(&trans, CREATE_BOOKMARK, trans.root_id(), path_name);
         CHECK(e.good());
         base::PlatformThread::Sleep(base::TimeDelta::FromMilliseconds(
             rand() % 20));
         e.Put(IS_UNSYNCED, true);
         if (e.Put(ID, TestIdFactory::FromNumber(rand())) &&
             e.Get(ID).ServerKnows() && !e.Get(ID).IsRoot()) {
            e.Put(BASE_VERSION, 1);
         }
       }
     }
@@ skipping 36 matching lines @@
 
 class SyncableClientTagTest : public SyncableDirectoryTest {
  public:
   static const int kBaseVersion = 1;
   const char* test_name_;
   const char* test_tag_;
 
   SyncableClientTagTest() : test_name_("test_name"), test_tag_("dietcoke") {}
 
   bool CreateWithDefaultTag(Id id, bool deleted) {
-    return CreateWithTag(test_tag_, id, deleted);
-  }
-
-  // Attempt to create an entry with a default tag.
-  bool CreateWithTag(const char* tag, Id id, bool deleted) {
     WriteTransaction wtrans(FROM_HERE, UNITTEST, dir_.get());
-    MutableEntry me(&wtrans, CREATE, wtrans.root_id(), test_name_);
+    MutableEntry me(&wtrans, CREATE_UNIQUE, PREFERENCES,
+                    wtrans.root_id(), test_name_);
     CHECK(me.good());
     me.Put(ID, id);
     if (id.ServerKnows()) {
       me.Put(BASE_VERSION, kBaseVersion);
     }
     me.Put(IS_UNSYNCED, true);
     me.Put(IS_DEL, deleted);
     me.Put(IS_DIR, false);
-    return me.Put(UNIQUE_CLIENT_TAG, tag);
+    return me.Put(UNIQUE_CLIENT_TAG, test_tag_);
   }
 
   // Verify an entry exists with the default tag.
   void VerifyTag(Id id, bool deleted) {
     // Should still be present and valid in the client tag index.
     ReadTransaction trans(FROM_HERE, dir_.get());
     Entry me(&trans, GET_BY_CLIENT_TAG, test_tag_);
     CHECK(me.good());
     EXPECT_EQ(me.Get(ID), id);
     EXPECT_EQ(me.Get(UNIQUE_CLIENT_TAG), test_tag_);
@@ skipping 57 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