Changed DB to store node positions as Ordinals.

sync/syncable/directory.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 "sync/syncable/directory.h"
 
 #include "base/debug/trace_event.h"
 #include "base/perftimer.h"
 #include "base/stl_util.h"
 #include "base/string_number_conversions.h"
+#include "sync/internal_api/public/base/node_ordinal.h"
 #include "sync/internal_api/public/util/unrecoverable_error_handler.h"
 #include "sync/syncable/base_transaction.h"
 #include "sync/syncable/entry.h"
 #include "sync/syncable/entry_kernel.h"
 #include "sync/syncable/in_memory_directory_backing_store.h"
 #include "sync/syncable/on_disk_directory_backing_store.h"
 #include "sync/syncable/read_transaction.h"
 #include "sync/syncable/scoped_index_updater.h"
 #include "sync/syncable/syncable-inl.h"
 #include "sync/syncable/syncable_changes_version.h"
@@ skipping 22 matching lines @@
   return !a->ref(UNIQUE_CLIENT_TAG).empty();
 }
 
 bool ParentIdAndHandleIndexer::Comparator::operator() (
     const syncable::EntryKernel* a,
     const syncable::EntryKernel* b) const {
   int cmp = a->ref(PARENT_ID).compare(b->ref(PARENT_ID));
   if (cmp != 0)
     return cmp < 0;
 
-  int64 a_position = a->ref(SERVER_POSITION_IN_PARENT);
-  int64 b_position = b->ref(SERVER_POSITION_IN_PARENT);
-  if (a_position != b_position)
-    return a_position < b_position;
+  NodeOrdinal a_position = a->ref(SERVER_ORDINAL_IN_PARENT);

[akalin, 2012/10/05 00:57:59]

use const ref

[vishwath, 2012/10/05 18:34:49]

Done.

+  NodeOrdinal b_position = b->ref(SERVER_ORDINAL_IN_PARENT);

[akalin, 2012/10/05 00:57:59]

here too

[vishwath, 2012/10/05 18:34:49]

Done.

+  if (!a_position.Equals(b_position))
+    return a_position.LessThan(b_position);
 
   cmp = a->ref(ID).compare(b->ref(ID));
   return cmp < 0;
 }
 
 // static
 bool ParentIdAndHandleIndexer::ShouldInclude(const EntryKernel* a) {
   // This index excludes deleted items and the root item.  The root
   // item is excluded so that it doesn't show up as a child of itself.
   return !a->ref(IS_DEL) && !a->ref(ID).IsRoot();
@@ skipping 1058 matching lines @@
   return true;
 }
 
 Id Directory::ComputePrevIdFromServerPosition(
     const EntryKernel* entry,
     const syncable::Id& parent_id) {
   ScopedKernelLock lock(this);
 
   // Find the natural insertion point in the parent_id_child_index, and
   // work back from there, filtering out ineligible candidates.
-  ParentIdChildIndex::iterator sibling = LocateInParentChildIndex(lock,
-      parent_id, entry->ref(SERVER_POSITION_IN_PARENT), entry->ref(ID));
+  ParentIdChildIndex::iterator sibling = LocateInParentChildIndex(
+      lock,
+      parent_id,
+      NodeOrdinalToInt64(entry->ref(SERVER_ORDINAL_IN_PARENT)),
+      entry->ref(ID));
   ParentIdChildIndex::iterator first_sibling =
       GetParentChildIndexLowerBound(lock, parent_id);
 
   while (sibling != first_sibling) {
     --sibling;
     EntryKernel* candidate = *sibling;
 
     // The item itself should never be in the range under consideration.
     DCHECK_NE(candidate->ref(META_HANDLE), entry->ref(META_HANDLE));
 
@@ skipping 22 matching lines @@
   // This item will be the first in the sibling order.
   return Id();
 }
 
 Directory::ParentIdChildIndex::iterator Directory::LocateInParentChildIndex(
     const ScopedKernelLock& lock,
     const Id& parent_id,
     int64 position_in_parent,
     const Id& item_id_for_tiebreaking) {
   kernel_->needle.put(PARENT_ID, parent_id);
-  kernel_->needle.put(SERVER_POSITION_IN_PARENT, position_in_parent);
+  kernel_->needle.put(SERVER_ORDINAL_IN_PARENT,
+                      Int64ToNodeOrdinal(position_in_parent));
   kernel_->needle.put(ID, item_id_for_tiebreaking);
   return kernel_->parent_id_child_index->lower_bound(&kernel_->needle);
 }
 
 Directory::ParentIdChildIndex::iterator
 Directory::GetParentChildIndexLowerBound(const ScopedKernelLock& lock,
                                          const Id& parent_id) {
   // Peg the parent ID, and use the least values for the remaining
   // index variables.
   return LocateInParentChildIndex(lock, parent_id,
@@ skipping 44 matching lines @@
   // There were no children in the linked list.
   return NULL;
 }
 
 ScopedKernelLock::ScopedKernelLock(const Directory* dir)
   :  scoped_lock_(dir->kernel_->mutex), dir_(const_cast<Directory*>(dir)) {
 }
 
 }  // namespace syncable
 }  // namespace syncer