session_state.cc revision c407dc5cd9bdc5668497f21b26b09d988ab439de
1// Copyright (c) 2009 The Chromium Authors. All rights reserved. 2// Use of this source code is governed by a BSD-style license that can be 3// found in the LICENSE file. 4 5#include "chrome/browser/sync/sessions/session_state.h" 6 7#include <set> 8#include <vector> 9 10using std::set; 11using std::vector; 12 13namespace browser_sync { 14namespace sessions { 15 16IdToConflictSetMap::const_iterator ConflictProgress::IdToConflictSetFind( 17 const syncable::Id& the_id) const { 18 return id_to_conflict_set_.find(the_id); 19} 20 21IdToConflictSetMap::const_iterator 22ConflictProgress::IdToConflictSetBegin() const { 23 return id_to_conflict_set_.begin(); 24} 25 26IdToConflictSetMap::const_iterator 27ConflictProgress::IdToConflictSetEnd() const { 28 return id_to_conflict_set_.end(); 29} 30 31IdToConflictSetMap::size_type ConflictProgress::IdToConflictSetSize() const { 32 return id_to_conflict_set_.size(); 33} 34 35const ConflictSet* ConflictProgress::IdToConflictSetGet( 36 const syncable::Id& the_id) { 37 return id_to_conflict_set_[the_id]; 38} 39 40std::set<ConflictSet*>::const_iterator 41ConflictProgress::ConflictSetsBegin() const { 42 return conflict_sets_.begin(); 43} 44 45std::set<ConflictSet*>::const_iterator 46ConflictProgress::ConflictSetsEnd() const { 47 return conflict_sets_.end(); 48} 49 50std::set<ConflictSet*>::size_type 51ConflictProgress::ConflictSetsSize() const { 52 return conflict_sets_.size(); 53} 54 55std::set<syncable::Id>::iterator 56ConflictProgress::ConflictingItemsBegin() { 57 return conflicting_item_ids_.begin(); 58} 59std::set<syncable::Id>::const_iterator 60ConflictProgress::ConflictingItemsBeginConst() const { 61 return conflicting_item_ids_.begin(); 62} 63std::set<syncable::Id>::const_iterator 64ConflictProgress::ConflictingItemsEnd() const { 65 return conflicting_item_ids_.end(); 66} 67 68void ConflictProgress::AddConflictingItemById(const syncable::Id& the_id) { 69 std::pair<std::set<syncable::Id>::iterator, bool> ret = 70 conflicting_item_ids_.insert(the_id); 71 if (ret.second) 72 *dirty_ = true; 73} 74 75void ConflictProgress::EraseConflictingItemById(const syncable::Id& the_id) { 76 int items_erased = conflicting_item_ids_.erase(the_id); 77 if (items_erased != 0) 78 *dirty_ = true; 79} 80 81void ConflictProgress::MergeSets(const syncable::Id& id1, 82 const syncable::Id& id2) { 83 // There are no single item sets, we just leave those entries == 0 84 vector<syncable::Id>* set1 = id_to_conflict_set_[id1]; 85 vector<syncable::Id>* set2 = id_to_conflict_set_[id2]; 86 vector<syncable::Id>* rv = 0; 87 if (0 == set1 && 0 == set2) { 88 // Neither item currently has a set so we build one. 89 rv = new vector<syncable::Id>(); 90 rv->push_back(id1); 91 if (id1 != id2) { 92 rv->push_back(id2); 93 } else { 94 LOG(WARNING) << "[BUG] Attempting to merge two identical conflict ids."; 95 } 96 conflict_sets_.insert(rv); 97 } else if (0 == set1) { 98 // Add the item to the existing set. 99 rv = set2; 100 rv->push_back(id1); 101 } else if (0 == set2) { 102 // Add the item to the existing set. 103 rv = set1; 104 rv->push_back(id2); 105 } else if (set1 == set2) { 106 // It's the same set already. 107 return; 108 } else { 109 // Merge the two sets. 110 rv = set1; 111 // Point all the second sets id's back to the first. 112 vector<syncable::Id>::iterator i; 113 for (i = set2->begin() ; i != set2->end() ; ++i) { 114 id_to_conflict_set_[*i] = rv; 115 } 116 // Copy the second set to the first. 117 rv->insert(rv->end(), set2->begin(), set2->end()); 118 conflict_sets_.erase(set2); 119 delete set2; 120 } 121 id_to_conflict_set_[id1] = id_to_conflict_set_[id2] = rv; 122} 123 124void ConflictProgress::CleanupSets() { 125 // Clean up all the sets. 126 set<ConflictSet*>::iterator i; 127 for (i = conflict_sets_.begin(); i != conflict_sets_.end(); i++) { 128 delete *i; 129 } 130 conflict_sets_.clear(); 131 id_to_conflict_set_.clear(); 132} 133 134void UpdateProgress::AddVerifyResult(const VerifyResult& verify_result, 135 const sync_pb::SyncEntity& entity) { 136 verified_updates_.push_back(std::make_pair(verify_result, entity)); 137} 138 139void UpdateProgress::AddAppliedUpdate(const UpdateAttemptResponse& response, 140 const syncable::Id& id) { 141 applied_updates_.push_back(std::make_pair(response, id)); 142} 143 144std::vector<AppliedUpdate>::iterator UpdateProgress::AppliedUpdatesBegin() { 145 return applied_updates_.begin(); 146} 147 148std::vector<VerifiedUpdate>::const_iterator 149UpdateProgress::VerifiedUpdatesBegin() const { 150 return verified_updates_.begin(); 151} 152 153std::vector<AppliedUpdate>::const_iterator 154UpdateProgress::AppliedUpdatesEnd() const { 155 return applied_updates_.end(); 156} 157 158std::vector<VerifiedUpdate>::const_iterator 159UpdateProgress::VerifiedUpdatesEnd() const { 160 return verified_updates_.end(); 161} 162 163int UpdateProgress::SuccessfullyAppliedUpdateCount() const { 164 int count = 0; 165 for (std::vector<AppliedUpdate>::const_iterator it = 166 applied_updates_.begin(); 167 it != applied_updates_.end(); 168 ++it) { 169 if (it->first == SUCCESS) 170 count++; 171 } 172 return count; 173} 174 175// Returns true if at least one update application failed due to a conflict 176// during this sync cycle. 177bool UpdateProgress::HasConflictingUpdates() const { 178 std::vector<AppliedUpdate>::const_iterator it; 179 for (it = applied_updates_.begin(); it != applied_updates_.end(); ++it) { 180 if (it->first == CONFLICT) { 181 return true; 182 } 183 } 184 return false; 185} 186 187} // namespace sessions 188} // namespace browser_sync 189