FYI: Remove PerModelSafeGroupState + move ConflictResolution

sync/sessions/sync_session.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/sessions/sync_session.h"
 
 #include <algorithm>
 #include <iterator>
 
 #include "base/logging.h"
@@ skipping 127 matching lines @@
   std::vector<ModelSafeWorker*> temp;
   std::set_intersection(workers_.begin(), workers_.end(),
                  session.workers_.begin(), session.workers_.end(),
                  std::back_inserter(temp));
   workers_.swap(temp);
 
   // Now update enabled groups.
   enabled_groups_ = ComputeEnabledGroups(routing_info_, workers_);
 }
 
-void SyncSession::PrepareForAnotherSyncCycle() {
-  finished_ = false;
-  source_.updates_source =
-      sync_pb::GetUpdatesCallerInfo::SYNC_CYCLE_CONTINUATION;
-  status_controller_.reset(new StatusController(routing_info_));
-}
-
 SyncSessionSnapshot SyncSession::TakeSnapshot() const {
   syncable::Directory* dir = context_->directory();
 
   bool is_share_useable = true;
   ModelTypeSet initial_sync_ended;
   ModelTypeStateMap download_progress_markers;
   for (int i = FIRST_REAL_MODEL_TYPE; i < MODEL_TYPE_COUNT; ++i) {
     ModelType type(ModelTypeFromInt(i));
     if (routing_info_.count(type) != 0) {
       if (dir->initial_sync_ended_for_type(type))
         initial_sync_ended.Put(type);
       else
         is_share_useable = false;
     }
     // TODO(dcheng): Is this correct? I'm guessing GetDownloadProgressAsString()
     // shouldn't care about the ack handle...
     dir->GetDownloadProgressAsString(type,
                                      &download_progress_markers[type].payload);
   }
 
   return SyncSessionSnapshot(
       status_controller_->model_neutral_state(),
       is_share_useable,
       initial_sync_ended,
       download_progress_markers,
-      HasMoreToSync(),
+      false, // FIXME: clean up.
       delegate_->IsSyncingCurrentlySilenced(),
-      status_controller_->TotalNumEncryptionConflictingItems(),
-      status_controller_->TotalNumHierarchyConflictingItems(),
-      status_controller_->TotalNumSimpleConflictingItems(),
-      status_controller_->TotalNumServerConflictingItems(),
+      status_controller_->num_encryption_conflicts(),
+      status_controller_->num_hierarchy_conflicts(),
+      0, // FIXME: clean up.
+      status_controller_->num_server_conflicts(),
       source_,
       context_->notifications_enabled(),
       dir->GetEntriesCount(),
       status_controller_->sync_start_time(),
       !Succeeded());
 }
 
 void SyncSession::SendEventNotification(SyncEngineEvent::EventCause cause) {
   SyncEngineEvent event(cause);
   event.snapshot = TakeSnapshot();
 
   DVLOG(1) << "Sending event with snapshot: " << event.snapshot.ToString();
   context()->NotifyListeners(event);
 }
 
-bool SyncSession::HasMoreToSync() const {
-  const StatusController* status = status_controller_.get();
-  return status->conflicts_resolved();
-}
-
 const std::set<ModelSafeGroup>& SyncSession::GetEnabledGroups() const {
   return enabled_groups_;
 }
 
-std::set<ModelSafeGroup> SyncSession::GetEnabledGroupsWithConflicts() const {
-  const std::set<ModelSafeGroup>& enabled_groups = GetEnabledGroups();
-  std::set<ModelSafeGroup> enabled_groups_with_conflicts;
-  for (std::set<ModelSafeGroup>::const_iterator it =
-           enabled_groups.begin(); it != enabled_groups.end(); ++it) {
-    const sessions::ConflictProgress* conflict_progress =
-        status_controller_->GetUnrestrictedConflictProgress(*it);
-    if (conflict_progress &&
-        (conflict_progress->SimpleConflictingItemsBegin() !=
-         conflict_progress->SimpleConflictingItemsEnd())) {
-      enabled_groups_with_conflicts.insert(*it);
-    }
-  }
-  return enabled_groups_with_conflicts;
-}
-
-std::set<ModelSafeGroup>
-    SyncSession::GetEnabledGroupsWithVerifiedUpdates() const {
-  const std::set<ModelSafeGroup>& enabled_groups = GetEnabledGroups();
-  std::set<ModelSafeGroup> enabled_groups_with_verified_updates;
-  for (std::set<ModelSafeGroup>::const_iterator it =
-           enabled_groups.begin(); it != enabled_groups.end(); ++it) {
-    const UpdateProgress* update_progress =
-        status_controller_->GetUnrestrictedUpdateProgress(*it);
-    if (update_progress &&
-        (update_progress->VerifiedUpdatesBegin() !=
-         update_progress->VerifiedUpdatesEnd())) {
-      enabled_groups_with_verified_updates.insert(*it);
-    }
-  }
-
-  return enabled_groups_with_verified_updates;
-}
-
 namespace {
 
 // Returns false iff one of the command results had an error.
 bool HadErrors(const ModelNeutralState& state) {
   const bool get_key_error = SyncerErrorIsError(state.last_get_key_result);
   const bool download_updates_error =
       SyncerErrorIsError(state.last_download_updates_result);
   const bool commit_error = SyncerErrorIsError(state.commit_result);
   return get_key_error || download_updates_error || commit_error;
 }
@@ skipping 13 matching lines @@
   // with the server. Therefore, we verify no errors and at least one SYNCER_OK.
   return reached_server && !HadErrors(state);
 }
 
 void SyncSession::SetFinished() {
   finished_ = true;
 }
 
 }  // namespace sessions
 }  // namespace syncer