WIP: The Bookmark Position Megapatch

sync/engine/syncer_util.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/engine/syncer_util.h"
 
 #include <algorithm>
 #include <set>
 #include <string>
 #include <vector>
 
+#include "base/base64.h"
 #include "base/location.h"
 #include "base/metrics/histogram.h"
+#include "base/string_number_conversions.h"
 #include "sync/engine/conflict_resolver.h"
 #include "sync/engine/syncer_proto_util.h"
 #include "sync/engine/syncer_types.h"
 #include "sync/internal_api/public/base/model_type.h"
+#include "sync/internal_api/public/base/unique_position.h"
 #include "sync/protocol/bookmark_specifics.pb.h"
 #include "sync/protocol/password_specifics.pb.h"
 #include "sync/protocol/sync.pb.h"
 #include "sync/syncable/directory.h"
 #include "sync/syncable/entry.h"
 #include "sync/syncable/mutable_entry.h"
 #include "sync/syncable/read_transaction.h"
 #include "sync/syncable/syncable_changes_version.h"
 #include "sync/syncable/syncable_proto_util.h"
 #include "sync/syncable/syncable_util.h"
 #include "sync/syncable/write_transaction.h"
 #include "sync/util/cryptographer.h"
 #include "sync/util/time.h"
 
-// TODO(vishwath): Remove this include after node positions have
-// shifted to completely uing Ordinals.
-// See http://crbug.com/145412 .
-#include "sync/internal_api/public/base/node_ordinal.h"
-
 namespace syncer {
 
+using syncable::BASE_SERVER_SPECIFICS;
 using syncable::BASE_VERSION;
 using syncable::CHANGES_VERSION;
 using syncable::CREATE_NEW_UPDATE_ITEM;
 using syncable::CTIME;
 using syncable::Directory;
 using syncable::Entry;
 using syncable::GET_BY_HANDLE;
 using syncable::GET_BY_ID;
 using syncable::ID;
 using syncable::IS_DEL;
 using syncable::IS_DIR;
 using syncable::IS_UNAPPLIED_UPDATE;
 using syncable::IS_UNSYNCED;
 using syncable::Id;
 using syncable::META_HANDLE;
 using syncable::MTIME;
 using syncable::MutableEntry;
 using syncable::NON_UNIQUE_NAME;
-using syncable::BASE_SERVER_SPECIFICS;
 using syncable::PARENT_ID;
-using syncable::PREV_ID;
 using syncable::SERVER_CTIME;
 using syncable::SERVER_IS_DEL;
 using syncable::SERVER_IS_DIR;
 using syncable::SERVER_MTIME;
 using syncable::SERVER_NON_UNIQUE_NAME;
 using syncable::SERVER_PARENT_ID;
-using syncable::SERVER_ORDINAL_IN_PARENT;
 using syncable::SERVER_SPECIFICS;
+using syncable::SERVER_UNIQUE_POSITION;
 using syncable::SERVER_VERSION;
-using syncable::UNIQUE_CLIENT_TAG;
-using syncable::UNIQUE_SERVER_TAG;
 using syncable::SPECIFICS;
 using syncable::SYNCER;
+using syncable::UNIQUE_BOOKMARK_TAG;
+using syncable::UNIQUE_CLIENT_TAG;
+using syncable::UNIQUE_POSITION;
+using syncable::UNIQUE_SERVER_TAG;
 using syncable::WriteTransaction;
 
 syncable::Id FindLocalIdToUpdate(
     syncable::BaseTransaction* trans,
     const sync_pb::SyncEntity& update) {
   // Expected entry points of this function:
   // SyncEntity has NOT been applied to SERVER fields.
   // SyncEntity has NOT been applied to LOCAL fields.
   // DB has not yet been modified, no entries created for this update.
 
@@ skipping 184 matching lines @@
     DVLOG(2) << "Received an unencrypted "
              << ModelTypeToString(entry->GetServerModelType())
              << " update, applying normally.";
   }
 
   UpdateLocalDataFromServerData(trans, entry);
 
   return SUCCESS;
 }
 
+std::string GetUniqueBookmarkTagFromUpdate(const sync_pb::SyncEntity& update) {
+  if (!update.has_originator_cache_guid() ||
+      !update.has_originator_client_item_id()) {
+    return "";
+  }
+
+  return syncable::GenerateSyncableBookmarkHash(
+      update.originator_cache_guid(), update.originator_client_item_id());
+}
+
+UniquePosition GetUpdatePosition(const sync_pb::SyncEntity& update,
+                                 const std::string& suffix) {
+  DCHECK(UniquePosition::IsValidSuffix(suffix));
+  if (!ShouldMaintainPosition(GetModelType(update))) {
+    return UniquePosition::CreateInvalid();
+  } else if (update.has_unique_position()) {
+    return UniquePosition::FromBytes(update.unique_position());
+  } else if (update.has_position_in_parent()) {
+    return UniquePosition::FromInt64(update.position_in_parent(), suffix);
+  } else {
+    return UniquePosition::CreateInvalid();
+  }
+}
+
 namespace {
+
 // Helper to synthesize a new-style sync_pb::EntitySpecifics for use locally,
 // when the server speaks only the old sync_pb::SyncEntity_BookmarkData-based
 // protocol.
 void UpdateBookmarkSpecifics(const std::string& singleton_tag,
                              const std::string& url,
                              const std::string& favicon_bytes,
                              MutableEntry* local_entry) {
   // In the new-style protocol, the server no longer sends bookmark info for
   // the "google_chrome" folder.  Mimic that here.
   if (singleton_tag == "google_chrome")
     return;
   sync_pb::EntitySpecifics pb;
   sync_pb::BookmarkSpecifics* bookmark = pb.mutable_bookmark();
   if (!url.empty())
     bookmark->set_url(url);
   if (!favicon_bytes.empty())
     bookmark->set_favicon(favicon_bytes);
   local_entry->Put(SERVER_SPECIFICS, pb);
 }
 
 }  // namespace
 
-// Pass in name and checksum because of UTF8 conversion.
 void UpdateServerFieldsFromUpdate(
     MutableEntry* target,
     const sync_pb::SyncEntity& update,
     const std::string& name) {
   if (update.deleted()) {
     if (target->Get(SERVER_IS_DEL)) {
       // If we already think the item is server-deleted, we're done.
       // Skipping these cases prevents our committed deletions from coming
       // back and overriding subsequent undeletions.  For non-deleted items,
       // the version number check has a similar effect.
@@ skipping 38 matching lines @@
         << "Storing unrecognized datatype in sync database.";
     target->Put(SERVER_SPECIFICS, update.specifics());
   } else if (update.has_bookmarkdata()) {
     // Legacy protocol response for bookmark data.
     const sync_pb::SyncEntity::BookmarkData& bookmark = update.bookmarkdata();
     UpdateBookmarkSpecifics(update.server_defined_unique_tag(),
                             bookmark.bookmark_url(),
                             bookmark.bookmark_favicon(),
                             target);
   }
-  if (update.has_position_in_parent())
-    target->Put(SERVER_ORDINAL_IN_PARENT,
-                Int64ToNodeOrdinal(update.position_in_parent()));
+  if (GetModelType(update) == BOOKMARKS &&
+      !update.has_server_defined_unique_tag()) {
+    // Update our unique bookmark tag.  This is usually unnecessary, but there
+    // will be some legacy bookmarks out theere with less than ideal tags.
+    // This will fix them, eventually.
+    std::string bookmark_tag = GetUniqueBookmarkTagFromUpdate(update);
+    if (UniquePosition::IsValidSuffix(bookmark_tag)) {
+      target->PutUniqueBookmarkTag(bookmark_tag);
+    }
+
+    // Update our position.
+    UniquePosition update_pos =
+        GetUpdatePosition(update, target->Get(UNIQUE_BOOKMARK_TAG));
+    if (update_pos.IsValid())
+      target->Put(syncable::SERVER_UNIQUE_POSITION, update_pos);
+    // TODO(rlarocque): Throw an UnrecoverableError if this fails.
+  }
 
   target->Put(SERVER_IS_DEL, update.deleted());
   // We only mark the entry as unapplied if its version is greater than the
   // local data. If we're processing the update that corresponds to one of our
   // commit we don't apply it as time differences may occur.
   if (update.version() > target->Get(BASE_VERSION)) {
     target->Put(IS_UNAPPLIED_UPDATE, true);
   }
 }
 
 // Creates a new Entry iff no Entry exists with the given id.
 void CreateNewEntry(syncable::WriteTransaction *trans,
                     const syncable::Id& id) {
   syncable::MutableEntry entry(trans, GET_BY_ID, id);
   if (!entry.good()) {
     syncable::MutableEntry new_entry(trans, syncable::CREATE_NEW_UPDATE_ITEM,
                                      id);
   }
 }
 
-void SplitServerInformationIntoNewEntry(
-    syncable::WriteTransaction* trans,
-    syncable::MutableEntry* entry) {
-  syncable::Id id = entry->Get(ID);
-  ChangeEntryIDAndUpdateChildren(trans, entry, trans->directory()->NextId());
-  entry->Put(BASE_VERSION, 0);
-
-  MutableEntry new_entry(trans, CREATE_NEW_UPDATE_ITEM, id);
-  CopyServerFields(entry, &new_entry);
-  ClearServerData(entry);
-
-  DVLOG(1) << "Splitting server information, local entry: " << *entry
-           << " server entry: " << new_entry;
-}
-
 // This function is called on an entry when we can update the user-facing data
 // from the server data.
 void UpdateLocalDataFromServerData(
     syncable::WriteTransaction* trans,
     syncable::MutableEntry* entry) {
   DCHECK(!entry->Get(IS_UNSYNCED));
   DCHECK(entry->Get(IS_UNAPPLIED_UPDATE));
 
   DVLOG(2) << "Updating entry : " << *entry;
   // Start by setting the properties that determine the model_type.
   entry->Put(SPECIFICS, entry->Get(SERVER_SPECIFICS));
   // Clear the previous server specifics now that we're applying successfully.
   entry->Put(BASE_SERVER_SPECIFICS, sync_pb::EntitySpecifics());
   entry->Put(IS_DIR, entry->Get(SERVER_IS_DIR));
   // This strange dance around the IS_DEL flag avoids problems when setting
   // the name.
   // TODO(chron): Is this still an issue? Unit test this codepath.
   if (entry->Get(SERVER_IS_DEL)) {
     entry->Put(IS_DEL, true);
   } else {
     entry->Put(NON_UNIQUE_NAME, entry->Get(SERVER_NON_UNIQUE_NAME));
     entry->Put(PARENT_ID, entry->Get(SERVER_PARENT_ID));
+    entry->Put(UNIQUE_POSITION, entry->Get(SERVER_UNIQUE_POSITION));
     CHECK(entry->Put(IS_DEL, false));
-    Id new_predecessor =
-        entry->ComputePrevIdFromServerPosition(entry->Get(SERVER_PARENT_ID));
-    CHECK(entry->PutPredecessor(new_predecessor))
-        << " Illegal predecessor after converting from server position.";
   }
 
   entry->Put(CTIME, entry->Get(SERVER_CTIME));
   entry->Put(MTIME, entry->Get(SERVER_MTIME));
   entry->Put(BASE_VERSION, entry->Get(SERVER_VERSION));
   entry->Put(IS_DEL, entry->Get(SERVER_IS_DEL));
   entry->Put(IS_UNAPPLIED_UPDATE, false);
 }
 
 VerifyCommitResult ValidateCommitEntry(syncable::Entry* entry) {
   syncable::Id id = entry->Get(ID);
   if (id == entry->Get(PARENT_ID)) {
     CHECK(id.IsRoot()) << "Non-root item is self parenting." << *entry;
     // If the root becomes unsynced it can cause us problems.
     LOG(ERROR) << "Root item became unsynced " << *entry;
     return VERIFY_UNSYNCABLE;
   }
   if (entry->IsRoot()) {
     LOG(ERROR) << "Permanent item became unsynced " << *entry;
     return VERIFY_UNSYNCABLE;
   }
   if (entry->Get(IS_DEL) && !entry->Get(ID).ServerKnows()) {
     // Drop deleted uncommitted entries.
     return VERIFY_UNSYNCABLE;
   }
   return VERIFY_OK;
 }
 
-bool AddItemThenPredecessors(
-    syncable::BaseTransaction* trans,
-    syncable::Entry* item,
-    syncable::IndexedBitField inclusion_filter,
-    syncable::MetahandleSet* inserted_items,
-    std::vector<syncable::Id>* commit_ids) {
-
-  if (!inserted_items->insert(item->Get(META_HANDLE)).second)
-    return false;
-  commit_ids->push_back(item->Get(ID));
-  if (item->Get(IS_DEL))
-    return true;  // Deleted items have no predecessors.
-
-  Id prev_id = item->Get(PREV_ID);
-  while (!prev_id.IsRoot()) {
-    Entry prev(trans, GET_BY_ID, prev_id);
-    CHECK(prev.good()) << "Bad id when walking predecessors.";
-    if (!prev.Get(inclusion_filter))
-      break;
-    if (!inserted_items->insert(prev.Get(META_HANDLE)).second)
-      break;
-    commit_ids->push_back(prev_id);
-    prev_id = prev.Get(PREV_ID);
-  }
-  return true;
-}
-
-void AddPredecessorsThenItem(
-    syncable::BaseTransaction* trans,
-    syncable::Entry* item,
-    syncable::IndexedBitField inclusion_filter,
-    syncable::MetahandleSet* inserted_items,
-    std::vector<syncable::Id>* commit_ids) {
-  size_t initial_size = commit_ids->size();
-  if (!AddItemThenPredecessors(trans, item, inclusion_filter, inserted_items,
-                               commit_ids))
-    return;
-  // Reverse what we added to get the correct order.
-  std::reverse(commit_ids->begin() + initial_size, commit_ids->end());
-}
-
 void MarkDeletedChildrenSynced(
     syncable::Directory* dir,
     std::set<syncable::Id>* deleted_folders) {
   // There's two options here.
   // 1. Scan deleted unsynced entries looking up their pre-delete tree for any
   //    of the deleted folders.
   // 2. Take each folder and do a tree walk of all entries underneath it.
   // #2 has a lower big O cost, but writing code to limit the time spent inside
   // the transaction during each step is simpler with 1. Changing this decision
   // may be sensible if this code shows up in profiling.
@@ skipping 148 matching lines @@
   if (update.version() < target->Get(SERVER_VERSION)) {
     LOG(WARNING) << "Update older than current server version for "
                  << *target << " Update:"
                  << SyncerProtoUtil::SyncEntityDebugString(update);
     return VERIFY_SUCCESS;  // Expected in new sync protocol.
   }
   return VERIFY_UNDECIDED;
 }
 
 }  // namespace syncer