WIP: The Bookmark Position Megapatch

sync/internal_api/sync_manager_impl.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/internal_api/sync_manager_impl.h"
 
 #include <string>
 
 #include "base/base64.h"
 #include "base/bind.h"
@@ skipping 38 matching lines @@
 #include "sync/syncable/on_disk_directory_backing_store.h"
 
 using base::TimeDelta;
 using sync_pb::GetUpdatesCallerInfo;
 
 namespace syncer {
 
 using sessions::SyncSessionContext;
 using syncable::ImmutableWriteTransactionInfo;
 using syncable::SPECIFICS;
+using syncable::UNIQUE_POSITION;
 
 namespace {
 
 // Delays for syncer nudges.
 static const int kDefaultNudgeDelayMilliseconds = 200;
 static const int kPreferencesNudgeDelayMilliseconds = 2000;
 static const int kSyncRefreshDelayMsec = 500;
 static const int kSyncSchedulerDelayMsec = 250;
 
 // Maximum count and size for traffic recorder.
@@ skipping 145 matching lines @@
 SyncManagerImpl::NotificationInfo::NotificationInfo() : total_count(0) {}
 SyncManagerImpl::NotificationInfo::~NotificationInfo() {}
 
 DictionaryValue* SyncManagerImpl::NotificationInfo::ToValue() const {
   DictionaryValue* value = new DictionaryValue();
   value->SetInteger("totalCount", total_count);
   value->SetString("payload", payload);
   return value;
 }
 
-bool SyncManagerImpl::VisiblePositionsDiffer(
-    const syncable::EntryKernelMutation& mutation) const {
-  const syncable::EntryKernel& a = mutation.original;
-  const syncable::EntryKernel& b = mutation.mutated;
-  // If the datatype isn't one where the browser model cares about position,
-  // don't bother notifying that data model of position-only changes.
-  if (!ShouldMaintainPosition(GetModelTypeFromSpecifics(b.ref(SPECIFICS)))) {
-    return false;
-  }
-  if (a.ref(syncable::NEXT_ID) != b.ref(syncable::NEXT_ID))
-    return true;
-  if (a.ref(syncable::PARENT_ID) != b.ref(syncable::PARENT_ID))
-    return true;
-  return false;
-}
-
 bool SyncManagerImpl::VisiblePropertiesDiffer(
     const syncable::EntryKernelMutation& mutation,
     Cryptographer* cryptographer) const {
   const syncable::EntryKernel& a = mutation.original;
   const syncable::EntryKernel& b = mutation.mutated;
   const sync_pb::EntitySpecifics& a_specifics = a.ref(SPECIFICS);
   const sync_pb::EntitySpecifics& b_specifics = b.ref(SPECIFICS);
   DCHECK_EQ(GetModelTypeFromSpecifics(a_specifics),
             GetModelTypeFromSpecifics(b_specifics));
   ModelType model_type = GetModelTypeFromSpecifics(b_specifics);
   // Suppress updates to items that aren't tracked by any browser model.
   if (model_type < FIRST_REAL_MODEL_TYPE ||
       !a.ref(syncable::UNIQUE_SERVER_TAG).empty()) {
     return false;
   }
   if (a.ref(syncable::IS_DIR) != b.ref(syncable::IS_DIR))
     return true;
   if (!AreSpecificsEqual(cryptographer,
                          a.ref(syncable::SPECIFICS),
                          b.ref(syncable::SPECIFICS))) {
     return true;
   }
   // We only care if the name has changed if neither specifics is encrypted
   // (encrypted nodes blow away the NON_UNIQUE_NAME).
   if (!a_specifics.has_encrypted() && !b_specifics.has_encrypted() &&
       a.ref(syncable::NON_UNIQUE_NAME) != b.ref(syncable::NON_UNIQUE_NAME))
     return true;
-  if (VisiblePositionsDiffer(mutation))
+  if (!a.ref(UNIQUE_POSITION).Equals(b.ref(UNIQUE_POSITION)))
     return true;
   return false;
 }
 
 void SyncManagerImpl::ThrowUnrecoverableError() {
   DCHECK(thread_checker_.CalledOnValidThread());
   ReadTransaction trans(FROM_HERE, GetUserShare());
   trans.GetWrappedTrans()->OnUnrecoverableError(
       FROM_HERE, "Simulating unrecoverable error for testing purposes.");
 }
@@ skipping 617 matching lines @@
 
   ChangeReorderBuffer change_buffers[MODEL_TYPE_COUNT];
 
   Cryptographer* crypto = directory()->GetCryptographer(trans);
   const syncable::ImmutableEntryKernelMutationMap& mutations =
       write_transaction_info.Get().mutations;
   for (syncable::EntryKernelMutationMap::const_iterator it =
            mutations.Get().begin(); it != mutations.Get().end(); ++it) {
     bool existed_before = !it->second.original.ref(syncable::IS_DEL);
     bool exists_now = !it->second.mutated.ref(syncable::IS_DEL);
+    bool positions_differ = !it->second.original.ref(UNIQUE_POSITION).Equals(
+        it->second.mutated.ref(UNIQUE_POSITION));
 
     // Omit items that aren't associated with a model.
     ModelType type =
         GetModelTypeFromSpecifics(it->second.mutated.ref(SPECIFICS));
     if (type < FIRST_REAL_MODEL_TYPE)
       continue;
 
     int64 handle = it->first;
     if (exists_now && !existed_before)
       change_buffers[type].PushAddedItem(handle);
     else if (!exists_now && existed_before)
       change_buffers[type].PushDeletedItem(handle);
     else if (exists_now && existed_before &&
              VisiblePropertiesDiffer(it->second, crypto)) {
       change_buffers[type].PushUpdatedItem(
-          handle, VisiblePositionsDiffer(it->second));
+          handle, positions_differ);
     }
 
     SetExtraChangeRecordData(handle, type, &change_buffers[type], crypto,
                              it->second.original, existed_before, exists_now);
   }
 
   ReadTransaction read_trans(GetUserShare(), trans);
   for (int i = FIRST_REAL_MODEL_TYPE; i < MODEL_TYPE_COUNT; ++i) {
     if (!change_buffers[i].IsEmpty()) {
       if (change_buffers[i].GetAllChangesInTreeOrder(&read_trans,
@@ skipping 425 matching lines @@
 int SyncManagerImpl::GetDefaultNudgeDelay() {
   return kDefaultNudgeDelayMilliseconds;
 }
 
 // static.
 int SyncManagerImpl::GetPreferencesNudgeDelay() {
   return kPreferencesNudgeDelayMilliseconds;
 }
 
 }  // namespace syncer