Changed DB to store node positions as Ordinals.

sync/syncable/mutable_entry.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/mutable_entry.h"
 
 #include "base/memory/scoped_ptr.h"
+#include "sync/internal_api/public/base/node_ordinal.h"
 #include "sync/syncable/directory.h"
 #include "sync/syncable/scoped_index_updater.h"
 #include "sync/syncable/scoped_kernel_lock.h"
 #include "sync/syncable/syncable-inl.h"
 #include "sync/syncable/syncable_changes_version.h"
 #include "sync/syncable/syncable_util.h"
 #include "sync/syncable/write_transaction.h"
 
 using std::string;
 
@@ skipping 16 matching lines @@
   kernel->put(ID, trans->directory_->NextId());
   kernel->put(META_HANDLE, trans->directory_->NextMetahandle());
   kernel->mark_dirty(trans->directory_->kernel_->dirty_metahandles);
   kernel->put(PARENT_ID, parent_id);
   kernel->put(NON_UNIQUE_NAME, name);
   const base::Time& now = base::Time::Now();
   kernel->put(CTIME, now);
   kernel->put(MTIME, now);
   // We match the database defaults here
   kernel->put(BASE_VERSION, CHANGES_VERSION);
+  kernel->put(SERVER_ORDINAL_IN_PARENT, NodeOrdinal::CreateInitialOrdinal());
   if (!trans->directory()->InsertEntry(trans, kernel.get())) {
     return; // We failed inserting, nothing more to do.
   }
   // Because this entry is new, it was originally deleted.
   kernel->put(IS_DEL, true);
   trans->SaveOriginal(kernel.get());
   kernel->put(IS_DEL, false);
 
   // Now swap the pointers.
   kernel_ = kernel.release();
 }
 
 MutableEntry::MutableEntry(WriteTransaction* trans, CreateNewUpdateItem,
                            const Id& id)
     : Entry(trans), write_transaction_(trans) {
   Entry same_id(trans, GET_BY_ID, id);
   kernel_ = NULL;
   if (same_id.good()) {
     return;  // already have an item with this ID.
   }
   scoped_ptr<EntryKernel> kernel(new EntryKernel());
 
   kernel->put(ID, id);
   kernel->put(META_HANDLE, trans->directory_->NextMetahandle());
   kernel->mark_dirty(trans->directory_->kernel_->dirty_metahandles);
+  kernel->put(SERVER_ORDINAL_IN_PARENT, NodeOrdinal::CreateInitialOrdinal());
   kernel->put(IS_DEL, true);
   // We match the database defaults here
   kernel->put(BASE_VERSION, CHANGES_VERSION);
   if (!trans->directory()->InsertEntry(trans, kernel.get())) {
     return;  // Failed inserting.
   }
   trans->SaveOriginal(kernel.get());
 
   kernel_ = kernel.release();
 }
@@ skipping 60 matching lines @@
     }
 
   return true;
 }
 
 bool MutableEntry::Put(Int64Field field, const int64& value) {
   DCHECK(kernel_);
   write_transaction_->SaveOriginal(kernel_);
   if (kernel_->ref(field) != value) {
     ScopedKernelLock lock(dir());
-    if (SERVER_POSITION_IN_PARENT == field) {
-      ScopedIndexUpdater<ParentIdAndHandleIndexer> updater(lock, kernel_,
-          dir()->kernel_->parent_id_child_index);
-      kernel_->put(field, value);
-    } else {
-      kernel_->put(field, value);
-    }
+    kernel_->put(field, value);
     kernel_->mark_dirty(dir()->kernel_->dirty_metahandles);
   }
   return true;
 }
 
 bool MutableEntry::Put(TimeField field, const base::Time& value) {
   DCHECK(kernel_);
   write_transaction_->SaveOriginal(kernel_);
   if (kernel_->ref(field) != value) {
     kernel_->put(field, value);
@@ skipping 17 matching lines @@
         NOTREACHED();
       }
     } else {
       kernel_->put(field, value);
     }
     kernel_->mark_dirty(dir()->kernel_->dirty_metahandles);
   }
   return true;
 }
 
+bool MutableEntry::Put(OrdinalField field, const NodeOrdinal& value) {
+  DCHECK(kernel_);
+  DCHECK(value.IsValid());
+  write_transaction_->SaveOriginal(kernel_);
+  if(!kernel_->ref(field).Equals(value)) {
+    ScopedKernelLock lock(dir());
+    if (SERVER_ORDINAL_IN_PARENT == field) {
+      ScopedIndexUpdater<ParentIdAndHandleIndexer> updater(
+          lock, kernel_, dir()->kernel_->parent_id_child_index);
+      kernel_->put(field, value);
+    } else {
+      kernel_->put(field, value);
+    }
+    kernel_->mark_dirty(dir()->kernel_->dirty_metahandles);
+  }
+  return true;
+}
+
 void MutableEntry::PutParentIdPropertyOnly(const Id& parent_id) {
   write_transaction_->SaveOriginal(kernel_);
   dir()->ReindexParentId(write_transaction(), kernel_, parent_id);
   kernel_->mark_dirty(dir()->kernel_->dirty_metahandles);
 }
 
 bool MutableEntry::Put(BaseVersion field, int64 value) {
   DCHECK(kernel_);
   write_transaction_->SaveOriginal(kernel_);
   if (kernel_->ref(field) != value) {
@@ skipping 208 matching lines @@
   DCHECK_NE(static_cast<MutableEntry*>(NULL), e);
   DCHECK(!e->IsRoot()) << "We shouldn't mark a permanent object for syncing.";
   if (!(e->Put(IS_UNSYNCED, true)))
     return false;
   e->Put(SYNCING, false);
   return true;
 }
 
 }  // namespace syncable
 }  // namespace syncer