Relieve SyncerSession,SyncCycleState, SyncProcessState, SyncerSession, Syncer...

chrome/browser/sync/engine/conflict_resolver.cc

 // Copyright (c) 2009 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 entry.
 
 #include "chrome/browser/sync/engine/conflict_resolver.h"
 
 #include <map>
 #include <set>
 
 #include "chrome/browser/sync/engine/syncer.h"
 #include "chrome/browser/sync/engine/syncer_util.h"
 #include "chrome/browser/sync/protocol/service_constants.h"
+#include "chrome/browser/sync/sessions/status_controller.h"
 #include "chrome/browser/sync/syncable/directory_manager.h"
 #include "chrome/browser/sync/syncable/syncable.h"
 #include "chrome/browser/sync/util/character_set_converters.h"
 #include "chrome/browser/sync/util/event_sys-inl.h"
 #include "chrome/browser/sync/util/path_helpers.h"
 
 using std::map;
 using std::set;
 using syncable::BaseTransaction;
 using syncable::Directory;
 using syncable::Entry;
 using syncable::Id;
 using syncable::MutableEntry;
 using syncable::ScopedDirLookup;
 using syncable::WriteTransaction;
 
 namespace browser_sync {
 
+using sessions::ConflictProgress;
+using sessions::StatusController;
+
 const int SYNC_CYCLES_BEFORE_ADMITTING_DEFEAT = 8;
 
 ConflictResolver::ConflictResolver() {
 }
 
 ConflictResolver::~ConflictResolver() {
 }
 
 void ConflictResolver::IgnoreLocalChanges(MutableEntry* entry) {
   // An update matches local actions, merge the changes.
@@ skipping 12 matching lines @@
   // made our local client changes.
   // TODO(chron): This is really a general property clobber. We clobber
   // the server side property. Perhaps we should actually do property merging.
   entry->Put(syncable::BASE_VERSION, entry->Get(syncable::SERVER_VERSION));
   entry->Put(syncable::IS_UNAPPLIED_UPDATE, false);
   // METRIC conflict resolved by overwrite.
 }
 
 ConflictResolver::ProcessSimpleConflictResult
 ConflictResolver::ProcessSimpleConflict(WriteTransaction* trans,
-                                        Id id,
-                                        SyncerSession* session) {
+                                        const Id& id) {
   MutableEntry entry(trans, syncable::GET_BY_ID, id);
   // Must be good as the entry won't have been cleaned up.
   CHECK(entry.good());
   // If an update fails, locally we have to be in a set or unsynced. We're not
   // in a set here, so we must be unsynced.
   if (!entry.Get(syncable::IS_UNSYNCED)) {
     return NO_SYNC_PROGRESS;
   }
 
   if (!entry.Get(syncable::IS_UNAPPLIED_UPDATE)) {
@@ skipping 263 matching lines @@
       return true;
   }
   return false;
 }
 
 }  // namespace
 
 // TODO(sync): Eliminate conflict sets. They're not necessary.
 bool ConflictResolver::ProcessConflictSet(WriteTransaction* trans,
                                           ConflictSet* conflict_set,
-                                          int conflict_count,
-                                          SyncerSession* session) {
+                                          int conflict_count) {
   int set_size = conflict_set->size();
   if (set_size < 2) {
     LOG(WARNING) << "Skipping conflict set because it has size " << set_size;
     // We can end up with sets of size one if we have a new item in a set that
     // we tried to commit transactionally. This should not be a persistent
     // situation.
     return false;
   }
   if (conflict_count < 3) {
     // Avoid resolving sets that could be the result of transient conflicts.
@@ skipping 12 matching lines @@
     return true;
   return false;
 }
 
 template <typename InputIt>
 bool ConflictResolver::LogAndSignalIfConflictStuck(
     BaseTransaction* trans,
     int attempt_count,
     InputIt begin,
     InputIt end,
-    ConflictResolutionView* view) {
+    StatusController* status) {
   if (attempt_count < SYNC_CYCLES_BEFORE_ADMITTING_DEFEAT) {
     return false;
   }
 
   // Don't signal stuck if we're not up to date.
-  if (view->num_server_changes_remaining() > 0) {
+  if (status->change_progress().num_server_changes_remaining > 0) {
     return false;
   }
 
   LOG(ERROR) << "[BUG] Conflict set cannot be resolved, has "
              << end - begin << " items:";
   for (InputIt i = begin ; i != end ; ++i) {
     Entry e(trans, syncable::GET_BY_ID, *i);
     if (e.good())
       LOG(ERROR) << "  " << e;
     else
       LOG(ERROR) << "  Bad ID:" << *i;
   }
 
-  view->set_syncer_stuck(true);
+  status->set_syncer_stuck(true);
 
   return true;
   // TODO(sync): If we're stuck for a while we need to alert the user, clear
   // cache or reset syncing. At the very least we should stop trying something
   // that's obviously not working.
 }
 
 bool ConflictResolver::ResolveSimpleConflicts(const ScopedDirLookup& dir,
-                                              ConflictResolutionView* view,
-                                              SyncerSession* session) {
+                                              StatusController* status) {
   WriteTransaction trans(dir, syncable::SYNCER, __FILE__, __LINE__);
   bool forward_progress = false;
+  ConflictProgress const* progress = status->conflict_progress();
   // First iterate over simple conflict items (those that belong to no set).
   set<Id>::const_iterator conflicting_item_it;
-  for (conflicting_item_it = view->CommitConflictsBegin();
-       conflicting_item_it != view->CommitConflictsEnd();
+  for (conflicting_item_it = progress->ConflictingItemsBeginConst();
+       conflicting_item_it != progress->ConflictingItemsEnd();
        ++conflicting_item_it) {
     Id id = *conflicting_item_it;
     map<Id, ConflictSet*>::const_iterator item_set_it =
-        view->IdToConflictSetFind(id);
-    if (item_set_it == view->IdToConflictSetEnd() ||
+        progress->IdToConflictSetFind(id);
+    if (item_set_it == progress->IdToConflictSetEnd() ||
         0 == item_set_it->second) {
       // We have a simple conflict.
-      switch (ProcessSimpleConflict(&trans, id, session)) {
+      switch (ProcessSimpleConflict(&trans, id)) {
         case NO_SYNC_PROGRESS:
           {
             int conflict_count = (simple_conflict_count_map_[id] += 2);
             LogAndSignalIfConflictStuck(&trans, conflict_count,
-                                        &id, &id + 1, view);
+                                        &id, &id + 1, status);
             break;
           }
         case SYNC_PROGRESS:
           forward_progress = true;
           break;
       }
     }
   }
   // Reduce the simple_conflict_count for each item currently tracked.
   SimpleConflictCountMap::iterator i = simple_conflict_count_map_.begin();
   while (i != simple_conflict_count_map_.end()) {
     if (0 == --(i->second))
       simple_conflict_count_map_.erase(i++);
     else
       ++i;
   }
   return forward_progress;
 }
 
 bool ConflictResolver::ResolveConflicts(const ScopedDirLookup& dir,
-                                        ConflictResolutionView* view,
-                                        SyncerSession* session) {
+                                        StatusController* status) {
+  ConflictProgress const* progress = status->conflict_progress();
   bool rv = false;
-  if (ResolveSimpleConflicts(dir, view, session))
+  if (ResolveSimpleConflicts(dir, status))
     rv = true;
   WriteTransaction trans(dir, syncable::SYNCER, __FILE__, __LINE__);
   set<Id> children_of_dirs_merged_last_round;
   std::swap(children_of_merged_dirs_, children_of_dirs_merged_last_round);
   set<ConflictSet*>::const_iterator set_it;
-  for (set_it = view->ConflictSetsBegin();
-       set_it != view->ConflictSetsEnd();
+  for (set_it = progress->ConflictSetsBegin();
+       set_it != progress->ConflictSetsEnd();
        set_it++) {
     ConflictSet* conflict_set = *set_it;
     ConflictSetCountMapKey key = GetSetKey(conflict_set);
     conflict_set_count_map_[key] += 2;
     int conflict_count = conflict_set_count_map_[key];
     // Keep a metric for new sets.
     if (2 == conflict_count) {
       // METRIC conflict sets seen ++
     }
     // See if this set contains entries whose parents were merged last round.
     if (SortedCollectionsIntersect(children_of_dirs_merged_last_round.begin(),
                                    children_of_dirs_merged_last_round.end(),
                                    conflict_set->begin(),
                                    conflict_set->end())) {
       LOG(INFO) << "Accelerating resolution for hierarchical merge.";
       conflict_count += 2;
     }
     // See if we should process this set.
-    if (ProcessConflictSet(&trans, conflict_set, conflict_count, session)) {
+    if (ProcessConflictSet(&trans, conflict_set, conflict_count)) {
       rv = true;
     }
     LogAndSignalIfConflictStuck(&trans, conflict_count,
                                 conflict_set->begin(),
-                                conflict_set->end(), view);
+                                conflict_set->end(), status);
   }
   if (rv) {
     // This code means we don't signal that syncing is stuck when any conflict
     // resolution has occured.
     // TODO(sync): As this will also reduce our sensitivity to problem
     // conditions and increase the time for cascading resolutions we may have to
     // revisit this code later, doing something more intelligent.
     conflict_set_count_map_.clear();
     simple_conflict_count_map_.clear();
   }
   ConflictSetCountMap::iterator i = conflict_set_count_map_.begin();
   while (i != conflict_set_count_map_.end()) {
     if (0 == --i->second) {
       conflict_set_count_map_.erase(i++);
       // METRIC self resolved conflict sets ++.
     } else {
       ++i;
     }
   }
   return rv;
 }
 
 }  // namespace browser_sync