WIP: The Bookmark Position Megapatch

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/internal_api/public/base/unique_position.h"
 #include "sync/syncable/directory.h"
 #include "sync/syncable/scoped_index_updater.h"
 #include "sync/syncable/scoped_kernel_lock.h"
+#include "sync/syncable/scoped_parent_child_index_updater.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;
 
 namespace syncer {
 namespace syncable {
 
-MutableEntry::MutableEntry(WriteTransaction* trans, Create,
-                           const Id& parent_id, const string& name)
-    : Entry(trans),
-      write_transaction_(trans) {
-  Init(trans, parent_id, name);
-}
-
-
-void MutableEntry::Init(WriteTransaction* trans, const Id& parent_id,
+void MutableEntry::Init(WriteTransaction* trans,
+                        ModelType model_type,
+                        const Id& parent_id,
                         const string& name) {
   scoped_ptr<EntryKernel> kernel(new EntryKernel);
   kernel_ = NULL;
 
   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.
-  }
+
+  // Normally the SPECIFICS setting code is wrapped in logic to deal with
+  // unknown fields and encryption.  Since all we want to do here is ensure that
+  // GetModelType() returns a correct value from the very beginning, these
+  // few lines are sufficient.
+  sync_pb::EntitySpecifics specifics;
+  AddDefaultFieldValue(model_type, &specifics);
+  kernel->put(SPECIFICS, specifics);
+
   // 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, CreateBookmark,
+                           const Id& parent_id, const string& name)
+    : Entry(trans),
+      write_transaction_(trans) {
+  Init(trans, BOOKMARKS, parent_id, name);
+
+  std::string unique_tag = syncable::GenerateSyncableBookmarkHash(
+      trans->directory()->cache_guid(), Get(ID).value());
+
+  kernel_->put(UNIQUE_BOOKMARK_TAG, unique_tag);
+  kernel_->put(UNIQUE_POSITION,
+               UniquePosition::InitialPosition(unique_tag));
+  trans->directory()->InsertEntry(trans, kernel_);
+}
+
+MutableEntry::MutableEntry(WriteTransaction* trans,
+                           CreateUnique,
+                           ModelType model_type,
+                           const Id& parent_id,
+                           const string& name)
+    : Entry(trans),
+      write_transaction_(trans) {
+  DCHECK_NE(model_type, BOOKMARKS);
+  Init(trans, model_type, parent_id, name);
+  trans->directory()->InsertEntry(trans, kernel_);
+}
+
 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 17 matching lines @@
     : Entry(trans, GET_BY_SERVER_TAG, tag), write_transaction_(trans) {
 }
 
 bool MutableEntry::PutIsDel(bool is_del) {
   DCHECK(kernel_);
   write_transaction_->SaveOriginal(kernel_);
   if (is_del == kernel_->ref(IS_DEL)) {
     return true;
   }
   if (is_del) {
-    if (!UnlinkFromOrder()) {
-      return false;
-    }
-
     // If the server never knew about this item and it's deleted then we don't
     // need to keep it around.  Unsetting IS_UNSYNCED will:
     // - Ensure that the item is never committed to the server.
     // - Allow any items with the same UNIQUE_CLIENT_TAG created on other
     //   clients to override this entry.
     // - Let us delete this entry permanently through
     //   DirectoryBackingStore::DropDeletedEntries() when we next restart sync.
     //   This will save memory and avoid crbug.com/125381.
     if (!Get(ID).ServerKnows()) {
       Put(IS_UNSYNCED, false);
     }
   }
 
   {
     ScopedKernelLock lock(dir());
     // Some indices don't include deleted items and must be updated
     // upon a value change.
-    ScopedIndexUpdater<ParentIdAndHandleIndexer> updater(lock, kernel_,
-        dir()->kernel_->parent_id_child_index);
+    ScopedParentChildIndexUpdater updater(lock, kernel_,
+        dir()->kernel_->parent_child_index);
 
     kernel_->put(IS_DEL, is_del);
     kernel_->mark_dirty(dir()->kernel_->dirty_metahandles);
   }
 
-  if (!is_del)
-    // Restores position to the 0th index.
-    if (!PutPredecessor(Id())) {
-      // TODO(lipalani) : Propagate the error to caller. crbug.com/100444.
-      NOTREACHED();
-    }
-
   return true;
 }
 
 bool MutableEntry::Put(Int64Field field, const int64& value) {
   DCHECK(kernel_);
   write_transaction_->SaveOriginal(kernel_);
   if (kernel_->ref(field) != value) {
     ScopedKernelLock lock(dir());
     kernel_->put(field, value);
     kernel_->mark_dirty(dir()->kernel_->dirty_metahandles);
@@ skipping 12 matching lines @@
 }
 
 bool MutableEntry::Put(IdField field, const Id& value) {
   DCHECK(kernel_);
   write_transaction_->SaveOriginal(kernel_);
   if (kernel_->ref(field) != value) {
     if (ID == field) {
       if (!dir()->ReindexId(write_transaction(), kernel_, value))
         return false;
     } else if (PARENT_ID == field) {
-      PutParentIdPropertyOnly(value);  // Makes sibling order inconsistent.
-      // Fixes up the sibling order inconsistency.
-      if (!PutPredecessor(Id())) {
-        // TODO(lipalani) : Propagate the error to caller. crbug.com/100444.
-        NOTREACHED();
+      PutParentIdPropertyOnly(value);
+      if (!Get(IS_DEL)) {
+        if (!PutPredecessor(Id())) {
+          // TODO(lipalani) : Propagate the error to caller. crbug.com/100444.
+          NOTREACHED();
+        }
       }
     } else {
       kernel_->put(field, value);
     }
     kernel_->mark_dirty(dir()->kernel_->dirty_metahandles);
   }
   return true;
 }
 
-bool MutableEntry::Put(OrdinalField field, const NodeOrdinal& value) {
+bool MutableEntry::Put(UniquePositionField field, const UniquePosition& value) {
   DCHECK(kernel_);
-  DCHECK(value.IsValid());
   write_transaction_->SaveOriginal(kernel_);
   if(!kernel_->ref(field).Equals(value)) {
+    // We should never overwrite a valid position with an invalid one.
+    DCHECK(value.IsValid());
     ScopedKernelLock lock(dir());
-    if (SERVER_ORDINAL_IN_PARENT == field) {
-      ScopedIndexUpdater<ParentIdAndHandleIndexer> updater(
-          lock, kernel_, dir()->kernel_->parent_id_child_index);
+    if (UNIQUE_POSITION == field) {
+      ScopedParentChildIndexUpdater updater(
+          lock, kernel_, dir()->kernel_->parent_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) {
@@ skipping 135 matching lines @@
                       write_transaction())) {
         return false;
       }
     }
     kernel_->put(field, value);
     kernel_->mark_dirty(dir()->kernel_->dirty_metahandles);
   }
   return true;
 }
 
-bool MutableEntry::UnlinkFromOrder() {
-  ScopedKernelLock lock(dir());
-  return dir()->UnlinkEntryFromOrder(kernel_,
-                                     write_transaction(),
-                                     &lock,
-                                     NODE_MANIPULATION);
+void MutableEntry::PutUniqueBookmarkTag(const std::string& tag) {
+  // This unique tag will eventually be used as the unique suffix when adjusting
+  // this bookmark's position.  Let's make sure it's a valid suffix.
+  if (!UniquePosition::IsValidSuffix(tag)) {
+    NOTREACHED();
+    return;
+  }
+  kernel_->put(UNIQUE_BOOKMARK_TAG, tag);
+  kernel_->mark_dirty(dir()->kernel_->dirty_metahandles);
 }
 
 bool MutableEntry::PutPredecessor(const Id& predecessor_id) {
-  if (!UnlinkFromOrder())
+  MutableEntry predecessor(write_transaction_, GET_BY_ID, predecessor_id);
+  if (!predecessor.good())
     return false;
-
-  if (Get(IS_DEL)) {
-    DCHECK(predecessor_id.IsNull());
-    return true;
-  }
-
-  // TODO(ncarter): It should be possible to not maintain position for
-  // non-bookmark items.  However, we'd need to robustly handle all possible
-  // permutations of setting IS_DEL and the SPECIFICS to identify the
-  // object type; or else, we'd need to add a ModelType to the
-  // MutableEntry's Create ctor.
-  //   if (!ShouldMaintainPosition()) {
-  //     return false;
-  //   }
-
-  // This is classic insert-into-doubly-linked-list from CS 101 and your last
-  // job interview.  An "IsRoot" Id signifies the head or tail.
-  Id successor_id;
-  if (!predecessor_id.IsRoot()) {
-    MutableEntry predecessor(write_transaction(), GET_BY_ID, predecessor_id);
-    if (!predecessor.good()) {
-      LOG(ERROR) << "Predecessor is not good : "
-                 << predecessor_id.GetServerId();
-      return false;
-    }
-    if (predecessor.Get(PARENT_ID) != Get(PARENT_ID))
-      return false;
-    successor_id = predecessor.Get(NEXT_ID);
-    predecessor.Put(NEXT_ID, Get(ID));
-  } else {
-    syncable::Directory* dir = trans()->directory();
-    if (!dir->GetFirstChildId(trans(), Get(PARENT_ID), &successor_id)) {
-      return false;
-    }
-  }
-  if (!successor_id.IsRoot()) {
-    MutableEntry successor(write_transaction(), GET_BY_ID, successor_id);
-    if (!successor.good()) {
-      LOG(ERROR) << "Successor is not good: "
-                 << successor_id.GetServerId();
-      return false;
-    }
-    if (successor.Get(PARENT_ID) != Get(PARENT_ID))
-      return false;
-    successor.Put(PREV_ID, Get(ID));
-  }
-  DCHECK(predecessor_id != Get(ID));
-  DCHECK(successor_id != Get(ID));
-  Put(PREV_ID, predecessor_id);
-  Put(NEXT_ID, successor_id);
+  dir()->PutPredecessor(kernel_, predecessor.kernel_);
   return true;
 }
 
 bool MutableEntry::Put(BitTemp field, bool value) {
   DCHECK(kernel_);
   kernel_->put(field, value);
   return true;
 }
 
 // This function sets only the flags needed to get this entry to sync.
 bool MarkForSyncing(MutableEntry* e) {
   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