FYI: Remove PerModelSafeGroupState + move ConflictResolution

sync/engine/conflict_resolver.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/conflict_resolver.h"
 
 #include <algorithm>
 #include <list>
 #include <map>
 #include <set>
 
 #include "base/location.h"
 #include "base/metrics/histogram.h"
 #include "sync/engine/conflict_util.h"
 #include "sync/engine/syncer.h"
 #include "sync/engine/syncer_util.h"
 #include "sync/sessions/status_controller.h"
 #include "sync/syncable/directory.h"
 #include "sync/syncable/mutable_entry.h"
 #include "sync/syncable/nigori_handler.h"
 #include "sync/syncable/write_transaction.h"
 #include "sync/util/cryptographer.h"
 
 using std::list;
 using std::map;
 using std::set;
 
 namespace syncer {
 
-using sessions::ConflictProgress;
 using sessions::StatusController;
 using syncable::BaseTransaction;
 using syncable::Directory;
 using syncable::Entry;
 using syncable::Id;
 using syncable::MutableEntry;
 using syncable::WriteTransaction;
 
 namespace {
 
@@ skipping 243 matching lines @@
             entry.Get(syncable::META_HANDLE))
           << server_update << entry;
       UMA_HISTOGRAM_ENUMERATION("Sync.ResolveSimpleConflict",
                                 UNDELETE,
                                 CONFLICT_RESOLUTION_SIZE);
     }
     return SYNC_PROGRESS;
   }
 }
 
-bool ConflictResolver::ResolveConflicts(syncable::WriteTransaction* trans,
-                                        const Cryptographer* cryptographer,
-                                        const ConflictProgress& progress,
-                                        sessions::StatusController* status) {
+bool ConflictResolver::ResolveConflicts(
+    syncable::WriteTransaction* trans,
+    const Cryptographer* cryptographer,
+    const std::set<syncable::Id>& simple_conflict_ids,
+    sessions::StatusController* status) {
   bool forward_progress = false;
   // Iterate over simple conflict items.
   set<Id>::const_iterator conflicting_item_it;
   set<Id> processed_items;
-  for (conflicting_item_it = progress.SimpleConflictingItemsBegin();
-       conflicting_item_it != progress.SimpleConflictingItemsEnd();
+  for (conflicting_item_it = simple_conflict_ids.begin();
+       conflicting_item_it != simple_conflict_ids.end();
        ++conflicting_item_it) {
     Id id = *conflicting_item_it;
     if (processed_items.count(id) > 0)
       continue;
 
     // We don't resolve conflicts for control types here.
     Entry conflicting_node(trans, syncable::GET_BY_ID, id);
     CHECK(conflicting_node.good());
     if (IsControlType(
         GetModelTypeFromSpecifics(conflicting_node.Get(syncable::SPECIFICS)))) {
@@ skipping 10 matching lines @@
     do {
       predecessors.push_back(prev_id);
       Entry entry(trans, syncable::GET_BY_ID, prev_id);
       // Any entry in conflict must be valid.
       CHECK(entry.good());
       Id new_prev_id = entry.Get(syncable::PREV_ID);
       if (new_prev_id == prev_id)
         break;
       prev_id = new_prev_id;
     } while (processed_items.count(prev_id) == 0 &&
-             progress.HasSimpleConflictItem(prev_id));  // Excludes root.
+             simple_conflict_ids.count(prev_id) > 0);  // Excludes root.
     while (!predecessors.empty()) {
       id = predecessors.back();
       predecessors.pop_back();
       switch (ProcessSimpleConflict(trans, id, cryptographer, status)) {
         case NO_SYNC_PROGRESS:
           break;
         case SYNC_PROGRESS:
           forward_progress = true;
           break;
       }
       processed_items.insert(id);
     }
   }
   return forward_progress;
 }
 
 }  // namespace syncer