sync: Start moving away from PREV_ID and NEXT_ID

sync/engine/syncer_unittest.cc

 // Copyright 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 //
 // Syncer unit tests. Unfortunately a lot of these tests
 // are outdated and need to be reworked and updated.
 
 #include <algorithm>
 #include <limits>
 #include <list>
@@ skipping 72 matching lines @@
 using syncable::GET_BY_ID;
 using syncable::GET_BY_CLIENT_TAG;
 using syncable::GET_BY_SERVER_TAG;
 using syncable::ID;
 using syncable::IS_DEL;
 using syncable::IS_DIR;
 using syncable::IS_UNAPPLIED_UPDATE;
 using syncable::IS_UNSYNCED;
 using syncable::META_HANDLE;
 using syncable::MTIME;
-using syncable::NEXT_ID;
 using syncable::NON_UNIQUE_NAME;
 using syncable::PARENT_ID;
-using syncable::PREV_ID;
 using syncable::BASE_SERVER_SPECIFICS;
 using syncable::SERVER_IS_DEL;
 using syncable::SERVER_PARENT_ID;
 using syncable::SERVER_ORDINAL_IN_PARENT;
 using syncable::SERVER_SPECIFICS;
 using syncable::SERVER_VERSION;
 using syncable::UNIQUE_CLIENT_TAG;
 using syncable::UNIQUE_SERVER_TAG;
 using syncable::SPECIFICS;
 using syncable::SYNCING;
@@ skipping 4395 matching lines @@
 
     syncable::ReadTransaction trans(FROM_HERE, directory());
 
     Id prev_id;
     DCHECK(prev_id.IsRoot());
     PosMap::iterator next = position_map_.begin();
     for (PosMap::iterator i = next++; i != position_map_.end(); ++i) {
       Id id = i->second;
       Entry entry_with_id(&trans, GET_BY_ID, id);
       EXPECT_TRUE(entry_with_id.good());
-      EXPECT_EQ(prev_id, entry_with_id.Get(PREV_ID));
+      EXPECT_EQ(prev_id, entry_with_id.GetPredecessorId());
       EXPECT_EQ(
           i->first,
           NodeOrdinalToInt64(entry_with_id.Get(SERVER_ORDINAL_IN_PARENT)));
       if (next == position_map_.end()) {
-        EXPECT_EQ(Id(), entry_with_id.Get(NEXT_ID));
+        EXPECT_EQ(Id(), entry_with_id.GetSuccessorId());
       } else {
-        EXPECT_EQ(next->second, entry_with_id.Get(NEXT_ID));
+        EXPECT_EQ(next->second, entry_with_id.GetSuccessorId());
         next++;
       }
       prev_id = id;
     }
   }
 
   void AddRootItemWithPosition(int64 position) {
     string id = string("ServerId") + base::Int64ToString(next_update_id_++);
     string name = "my name is my id -- " + id;
     int revision = next_revision_++;
@@ skipping 99 matching lines @@
 
   void ExpectLocalOrderIsByServerId() {
     syncable::ReadTransaction trans(FROM_HERE, directory());
     Id null_id;
     Entry low(&trans, GET_BY_ID, low_id_);
     Entry mid(&trans, GET_BY_ID, mid_id_);
     Entry high(&trans, GET_BY_ID, high_id_);
     EXPECT_TRUE(low.good());
     EXPECT_TRUE(mid.good());
     EXPECT_TRUE(high.good());
-    EXPECT_TRUE(low.Get(PREV_ID) == null_id);
-    EXPECT_TRUE(mid.Get(PREV_ID) == low_id_);
-    EXPECT_TRUE(high.Get(PREV_ID) == mid_id_);
-    EXPECT_TRUE(high.Get(NEXT_ID) == null_id);
-    EXPECT_TRUE(mid.Get(NEXT_ID) == high_id_);
-    EXPECT_TRUE(low.Get(NEXT_ID) == mid_id_);
+    EXPECT_TRUE(low.GetPredecessorId() == null_id);
+    EXPECT_TRUE(mid.GetPredecessorId() == low_id_);
+    EXPECT_TRUE(high.GetPredecessorId() == mid_id_);
+    EXPECT_TRUE(high.GetSuccessorId() == null_id);
+    EXPECT_TRUE(mid.GetSuccessorId() == high_id_);
+    EXPECT_TRUE(low.GetSuccessorId() == mid_id_);
   }
 
  protected:
   // When there's a tiebreak on the numeric position, it's supposed to be
   // broken by string comparison of the ids.  These ids are in increasing
   // order.
   const Id low_id_;
   const Id mid_id_;
   const Id high_id_;
 
@@ skipping 44 matching lines @@
 
 TEST_F(SyncerPositionTiebreakingTest, MidLowHigh) {
   Add(mid_id_);
   Add(low_id_);
   Add(high_id_);
   SyncShareNudge();
   ExpectLocalOrderIsByServerId();
 }
 
 }  // namespace syncer