sync: Remove the remaining conflict sets code

chrome/browser/sync/sessions/session_state.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 "chrome/browser/sync/sessions/session_state.h"
 
 #include <map>
 #include <set>
 #include <string>
 #include <utility>
@@ skipping 169 matching lines @@
 std::string SyncSessionSnapshot::ToString() const {
   scoped_ptr<DictionaryValue> value(ToValue());
   std::string json;
   base::JSONWriter::Write(value.get(), true, &json);
   return json;
 }
 
 ConflictProgress::ConflictProgress(bool* dirty_flag) : dirty_(dirty_flag) {}
 
 ConflictProgress::~ConflictProgress() {
-  CleanupSets();
 }
 
 bool ConflictProgress::HasSimpleConflictItem(const syncable::Id& id) const {
-  return conflicting_item_ids_.count(id) > 0 &&
-         (IdToConflictSetFind(id) == IdToConflictSetEnd());
-}
-
-IdToConflictSetMap::const_iterator ConflictProgress::IdToConflictSetFind(
-    const syncable::Id& the_id) const {
-  return id_to_conflict_set_.find(the_id);
-}
-
-IdToConflictSetMap::const_iterator
-ConflictProgress::IdToConflictSetBegin() const {
-  return id_to_conflict_set_.begin();
-}
-
-IdToConflictSetMap::const_iterator
-ConflictProgress::IdToConflictSetEnd() const {
-  return id_to_conflict_set_.end();
-}
-
-IdToConflictSetMap::size_type ConflictProgress::IdToConflictSetSize() const {
-  return id_to_conflict_set_.size();
-}
-
-const ConflictSet* ConflictProgress::IdToConflictSetGet(
-    const syncable::Id& the_id) {
-  return id_to_conflict_set_[the_id];
-}
-
-std::set<ConflictSet*>::const_iterator
-ConflictProgress::ConflictSetsBegin() const {
-  return conflict_sets_.begin();
-}
-
-std::set<ConflictSet*>::const_iterator
-ConflictProgress::ConflictSetsEnd() const {
-  return conflict_sets_.end();
-}
-
-std::set<ConflictSet*>::size_type
-ConflictProgress::ConflictSetsSize() const {
-  return conflict_sets_.size();
+  return conflicting_item_ids_.count(id) > 0;
 }
 
 std::set<syncable::Id>::const_iterator
 ConflictProgress::ConflictingItemsBegin() const {
   return conflicting_item_ids_.begin();
 }
 std::set<syncable::Id>::const_iterator
 ConflictProgress::ConflictingItemsEnd() const {
   return conflicting_item_ids_.end();
 }
@@ skipping 12 matching lines @@
 }
 
 void ConflictProgress::AddNonblockingConflictingItemById(
     const syncable::Id& the_id) {
   std::pair<std::set<syncable::Id>::iterator, bool> ret =
       nonblocking_conflicting_item_ids_.insert(the_id);
   if (ret.second)
     *dirty_ = true;
 }
 
-void ConflictProgress::EraseNonblockingConflictingItemById(
+void ConflictProgress::AddHierarchyConflictingItemById(
     const syncable::Id& the_id) {
-  int items_erased = nonblocking_conflicting_item_ids_.erase(the_id);
-  if (items_erased != 0)
+  std::pair<std::set<syncable::Id>::iterator, bool> ret =
+      hierarchy_conflicting_item_ids_.insert(the_id);
+  if (ret.second)
     *dirty_ = true;
 }
 
-void ConflictProgress::MergeSets(const syncable::Id& id1,
-                                 const syncable::Id& id2) {
-  // There are no single item sets, we just leave those entries == 0
-  vector<syncable::Id>* set1 = id_to_conflict_set_[id1];
-  vector<syncable::Id>* set2 = id_to_conflict_set_[id2];
-  vector<syncable::Id>* rv = 0;
-  if (0 == set1 && 0 == set2) {
-    // Neither item currently has a set so we build one.
-    rv = new vector<syncable::Id>();
-    rv->push_back(id1);
-    if (id1 != id2) {
-      rv->push_back(id2);
-    } else {
-      LOG(WARNING) << "[BUG] Attempting to merge two identical conflict ids.";
-    }
-    conflict_sets_.insert(rv);
-  } else if (0 == set1) {
-    // Add the item to the existing set.
-    rv = set2;
-    rv->push_back(id1);
-  } else if (0 == set2) {
-    // Add the item to the existing set.
-    rv = set1;
-    rv->push_back(id2);
-  } else if (set1 == set2) {
-    // It's the same set already.
-    return;
-  } else {
-    // Merge the two sets.
-    rv = set1;
-    // Point all the second sets id's back to the first.
-    vector<syncable::Id>::iterator i;
-    for (i = set2->begin() ; i != set2->end() ; ++i) {
-      id_to_conflict_set_[*i] = rv;
-    }
-    // Copy the second set to the first.
-    rv->insert(rv->end(), set2->begin(), set2->end());
-    conflict_sets_.erase(set2);
-    delete set2;
-  }
-  id_to_conflict_set_[id1] = id_to_conflict_set_[id2] = rv;
-}
-
-void ConflictProgress::CleanupSets() {
-  // Clean up all the sets.
-  set<ConflictSet*>::iterator i;
-  for (i = conflict_sets_.begin(); i != conflict_sets_.end(); i++) {
-    delete *i;
-  }
-  conflict_sets_.clear();
-  id_to_conflict_set_.clear();
-}
-
 UpdateProgress::UpdateProgress() {}
 
 UpdateProgress::~UpdateProgress() {}
 
 void UpdateProgress::AddVerifyResult(const VerifyResult& verify_result,
                                      const sync_pb::SyncEntity& entity) {
   verified_updates_.push_back(std::make_pair(verify_result, entity));
 }
 
 void UpdateProgress::AddAppliedUpdate(const UpdateAttemptResponse& response,
@@ skipping 56 matching lines @@
 
 PerModelSafeGroupState::PerModelSafeGroupState(bool* dirty_flag)
     : conflict_progress(dirty_flag) {
 }
 
 PerModelSafeGroupState::~PerModelSafeGroupState() {
 }
 
 }  // namespace sessions
 }  // namespace browser_sync