sync: Remove the remaining conflict sets code

chrome/browser/sync/engine/update_applicator.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/update_applicator.h"
 
 #include <vector>
 
 #include "base/logging.h"
 #include "chrome/browser/sync/engine/syncer_util.h"
@@ skipping 53 matching lines @@
 
   syncable::MutableEntry entry(trans, syncable::GET_BY_HANDLE, *pointer_);
   UpdateAttemptResponse updateResponse = SyncerUtil::AttemptToUpdateEntry(
       trans, &entry, resolver_, cryptographer_);
   switch (updateResponse) {
     case SUCCESS:
       Advance();
       progress_ = true;
       application_results_.AddSuccess(entry.Get(syncable::ID));
       break;
-    case CONFLICT:
+    case CONFLICT_SIMPLE:
       pointer_++;
-      application_results_.AddConflict(entry.Get(syncable::ID));
+      application_results_.AddSimpleConflict(entry.Get(syncable::ID));
       break;
     case CONFLICT_ENCRYPTION:
       pointer_++;
       application_results_.AddEncryptionConflict(entry.Get(syncable::ID));
       break;
+    case CONFLICT_HIERARCHY:
+      pointer_++;
+      application_results_.AddHierarchyConflict(entry.Get(syncable::ID));
+      break;
     default:
       NOTREACHED();
       break;
   }
   DVLOG(1) << "Apply Status for " << entry.Get(syncable::META_HANDLE)
            << " is " << updateResponse;
 
   return true;
 }
 
@@ skipping 34 matching lines @@
   application_results_.SaveProgress(conflict_progress, update_progress);
 }
 
 UpdateApplicator::ResultTracker::ResultTracker(size_t num_results) {
   successful_ids_.reserve(num_results);
 }
 
 UpdateApplicator::ResultTracker::~ResultTracker() {
 }
 
-void UpdateApplicator::ResultTracker::AddConflict(syncable::Id id) {
+void UpdateApplicator::ResultTracker::AddSimpleConflict(syncable::Id id) {
   conflicting_ids_.push_back(id);
 }
 
 void UpdateApplicator::ResultTracker::AddEncryptionConflict(syncable::Id id) {
   encryption_conflict_ids_.push_back(id);
 }
 
+void UpdateApplicator::ResultTracker::AddHierarchyConflict(syncable::Id id) {
+  hierarchy_conflict_ids_.push_back(id);
+}
+
 void UpdateApplicator::ResultTracker::AddSuccess(syncable::Id id) {
   successful_ids_.push_back(id);
 }
 
 void UpdateApplicator::ResultTracker::SaveProgress(
     sessions::ConflictProgress* conflict_progress,
     sessions::UpdateProgress* update_progress) {
   vector<syncable::Id>::const_iterator i;
   for (i = conflicting_ids_.begin(); i != conflicting_ids_.end(); ++i) {
-    conflict_progress->AddConflictingItemById(*i);
-    update_progress->AddAppliedUpdate(CONFLICT, *i);
+    conflict_progress->AddSimpleConflictingItemById(*i);
+    update_progress->AddAppliedUpdate(CONFLICT_SIMPLE, *i);
   }
   for (i = encryption_conflict_ids_.begin();
        i != encryption_conflict_ids_.end(); ++i) {
     // Encryption conflicts should not put the syncer into a stuck state. We
     // mark as conflict, so that we reattempt to apply updates, but add it to
     // the list of nonblocking conflicts instead of normal conflicts.

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

blocking -> unresolvable

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

"Fixed" by removing these comments.  This is not the right place to explain what
we're doing or why.

The "why" can be better explained at the point where we detect conflicts and
choose which type of conflict to return (CONFLICT_ENCRYPTION, CONFLICT_SIMPLE,
etc.).

The "what" can be better explained in the context of the ConflictResolver's
function documentation.

Any comments left here are less likely to be read and more likely to grow stale
over time.

-    conflict_progress->AddNonblockingConflictingItemById(*i);
-    update_progress->AddAppliedUpdate(CONFLICT, *i);
+    conflict_progress->AddEncryptionConflictingItemById(*i);
+    update_progress->AddAppliedUpdate(CONFLICT_ENCRYPTION, *i);
+  }
+  for (i = hierarchy_conflict_ids_.begin();
+       i != hierarchy_conflict_ids_.end(); ++i) {
+    // There's nothing we can do locally to make progress on these conflicts.
+    // We add them to the list of non-blocking conflicts, along with the

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

list of unresolvable conflicts

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

See above comment.

+    // encryption conflicts.
+    conflict_progress->AddHierarchyConflictingItemById(*i);
+    update_progress->AddAppliedUpdate(CONFLICT_HIERARCHY, *i);
   }
   for (i = successful_ids_.begin(); i != successful_ids_.end(); ++i) {
-    conflict_progress->EraseConflictingItemById(*i);
+    conflict_progress->EraseSimpleConflictingItemById(*i);
     update_progress->AddAppliedUpdate(SUCCESS, *i);
   }
 }
 
 void UpdateApplicator::ResultTracker::ClearConflicts() {
   conflicting_ids_.clear();
   encryption_conflict_ids_.clear();
+  hierarchy_conflict_ids_.clear();
 }
 
 bool UpdateApplicator::ResultTracker::no_conflicts() const {
   return conflicting_ids_.empty();
 }
 
 }  // namespace browser_sync