WIP: The Bookmark Position Megapatch

sync/engine/process_updates_command.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/process_updates_command.h"
 
 #include <vector>
 
 #include "base/basictypes.h"
 #include "base/location.h"
 #include "sync/engine/syncer.h"
 #include "sync/engine/syncer_proto_util.h"
 #include "sync/engine/syncer_util.h"
 #include "sync/sessions/sync_session.h"
 #include "sync/syncable/directory.h"
 #include "sync/syncable/mutable_entry.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"
 
-// TODO(vishwath): Remove this include after node positions have
-// shifted to completely using Ordinals.
-// See http://crbug.com/145412 .
-#include "sync/internal_api/public/base/node_ordinal.h"
-
 using std::vector;
 
 namespace syncer {
 
 using sessions::SyncSession;
 using sessions::StatusController;
 
 using syncable::GET_BY_ID;
 
 ProcessUpdatesCommand::ProcessUpdatesCommand() {}
@@ skipping 270 matching lines @@
     }
     // Force application of this update, no matter what.
     target_entry.Put(syncable::IS_UNAPPLIED_UPDATE, true);
   }
 
   // If this is a newly received undecryptable update, and the only thing that
   // has changed are the specifics, store the original decryptable specifics,
   // (on which any current or future local changes are based) before we
   // overwrite SERVER_SPECIFICS.
   // MTIME, CTIME, and NON_UNIQUE_NAME are not enforced.
+
+  bool position_matches = true;
+  if (target_entry.GetModelType() == BOOKMARKS && !update.deleted()) {
+    std::string update_tag = GetUniqueBookmarkTagFromUpdate(update);
+    if (UniquePosition::IsValidSuffix(update_tag)) {
+      position_matches = GetUpdatePosition(update, update_tag).Equals(
+          target_entry.Get(syncable::SERVER_UNIQUE_POSITION));
+    } else {
+      NOTREACHED();
+      position_matches = false;
+    }
+  }
+
   if (!update.deleted() && !target_entry.Get(syncable::SERVER_IS_DEL) &&
       (SyncableIdFromProto(update.parent_id_string()) ==
           target_entry.Get(syncable::SERVER_PARENT_ID)) &&
-      (update.position_in_parent() ==
-       NodeOrdinalToInt64(
-           target_entry.Get(syncable::SERVER_ORDINAL_IN_PARENT))) &&
+      position_matches &&
       update.has_specifics() && update.specifics().has_encrypted() &&
       !cryptographer->CanDecrypt(update.specifics().encrypted())) {
     sync_pb::EntitySpecifics prev_specifics =
         target_entry.Get(syncable::SERVER_SPECIFICS);
     // We only store the old specifics if they were decryptable and applied and
     // there is no BASE_SERVER_SPECIFICS already. Else do nothing.
     if (!target_entry.Get(syncable::IS_UNAPPLIED_UPDATE) &&
         !IsRealDataType(GetModelTypeFromSpecifics(
             target_entry.Get(syncable::BASE_SERVER_SPECIFICS))) &&
         (!prev_specifics.has_encrypted() ||
@@ skipping 10 matching lines @@
     target_entry.Put(syncable::BASE_SERVER_SPECIFICS,
                      sync_pb::EntitySpecifics());
   }
 
   UpdateServerFieldsFromUpdate(&target_entry, update, name);
 
   return SUCCESS_PROCESSED;
 }
 
 }  // namespace syncer