sync: Remove the remaining conflict sets code

chrome/browser/sync/engine/syncer_util.cc

 // Copyright (c) 2011 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 "chrome/browser/sync/engine/syncer_util.h"
 
 #include <algorithm>
 #include <set>
 #include <string>
 #include <vector>
@@ skipping 293 matching lines @@
       syncable::ProcessUnsyncedChangesForEncryption(trans,
                                                     cryptographer);
     }
   }
 
   // Only apply updates that we can decrypt. If we can't decrypt the update, it
   // is likely because the passphrase has not arrived yet. Because the
   // passphrase may not arrive within this GetUpdates, we can't just return
   // conflict, else we try to perform normal conflict resolution prematurely or
   // the syncer may get stuck. As such, we return CONFLICT_ENCRYPTION, which is
   // treated as a non-blocking conflict. See the description in syncer_types.h.

[Nicolas Zea, 2012/02/02 21:53:41]

non-blocking -> unresolvable

[rlarocque, 2012/02/03 22:31:15]

Done.

   // This prevents any unsynced changes from commiting and postpones conflict
   // resolution until all data can be decrypted.
   if (specifics.has_encrypted() &&
       !cryptographer->CanDecrypt(specifics.encrypted())) {
     // We can't decrypt this node yet.
     DVLOG(1) << "Received an undecryptable "
              << syncable::ModelTypeToString(entry->GetServerModelType())
              << " update, returning encryption_conflict.";
     return CONFLICT_ENCRYPTION;
   } else if (specifics.HasExtension(sync_pb::password) &&
              entry->Get(UNIQUE_SERVER_TAG).empty()) {
     // Passwords use their own legacy encryption scheme.
     const sync_pb::PasswordSpecifics& password =
         specifics.GetExtension(sync_pb::password);
     if (!cryptographer->CanDecrypt(password.encrypted())) {
       DVLOG(1) << "Received an undecryptable password update, returning "
                << "encryption_conflict.";
       return CONFLICT_ENCRYPTION;
     }
   }
 
-  if (entry->Get(IS_UNSYNCED)) {
-    DVLOG(1) << "Skipping update, returning conflict for: " << id
-             << " ; it's unsynced.";
-    return CONFLICT;
-  }
   if (!entry->Get(SERVER_IS_DEL)) {
     syncable::Id new_parent = entry->Get(SERVER_PARENT_ID);
     Entry parent(trans, GET_BY_ID,  new_parent);
     // A note on non-directory parents:
     // We catch most unfixable tree invariant errors at update receipt time,
     // however we deal with this case here because we may receive the child
     // first then the illegal parent. Instead of dealing with it twice in
     // different ways we deal with it once here to reduce the amount of code and
     // potential errors.
     if (!parent.good() || parent.Get(IS_DEL) || !parent.Get(IS_DIR)) {
-      return CONFLICT;
+      return CONFLICT_HIERARCHY;
     }
     if (entry->Get(PARENT_ID) != new_parent) {
       if (!entry->Get(IS_DEL) && !IsLegalNewParent(trans, id, new_parent)) {
         DVLOG(1) << "Not updating item " << id
                  << ", illegal new parent (would cause loop).";
-        return CONFLICT;
+        return CONFLICT_HIERARCHY;
       }
     }
   } else if (entry->Get(IS_DIR)) {
     Directory::ChildHandles handles;
     trans->directory()->GetChildHandlesById(trans, id, &handles);
     if (!handles.empty()) {
       // If we have still-existing children, then we need to deal with
       // them before we can process this change.
       DVLOG(1) << "Not deleting directory; it's not empty " << *entry;
-      return CONFLICT;
+      return CONFLICT_HIERARCHY;
     }
   }
 
+  if (entry->Get(IS_UNSYNCED)) {
+    DVLOG(1) << "Skipping update, returning conflict for: " << id
+             << " ; it's unsynced.";
+    return CONFLICT_SIMPLE;
+  }
+
   if (specifics.has_encrypted()) {
     DVLOG(2) << "Received a decryptable "
              << syncable::ModelTypeToString(entry->GetServerModelType())
              << " update, applying normally.";
   } else {
     DVLOG(2) << "Received an unencrypted "
              << syncable::ModelTypeToString(entry->GetServerModelType())
              << " update, applying normally.";
   }
 
@@ skipping 390 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 browser_sync