Detect & destroy dead conflictresolver paths.

chrome/browser/sync/engine/conflict_resolver.cc

 // Copyright (c) 2011 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/engine/conflict_resolver.h"
 
 #include <algorithm>
 #include <map>
 #include <set>
 
+#include "base/metrics/histogram.h"
 #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/common/deprecated/event_sys-inl.h"
 
 using std::map;
 using std::set;
@@ skipping 155 matching lines @@
   std::stringstream rv;
   for (ConflictSet::iterator i = set->begin() ; i != set->end() ; ++i )
     rv << *i << ".";
   return rv.str();
 }
 
 namespace {
 
 bool AttemptToFixCircularConflict(WriteTransaction* trans,
                                   ConflictSet* conflict_set) {
+  UMA_HISTOGRAM_COUNTS("Sync.ConflictFixCircularity", 1);
   ConflictSet::const_iterator i, j;
   for (i = conflict_set->begin() ; i != conflict_set->end() ; ++i) {
     MutableEntry entryi(trans, syncable::GET_BY_ID, *i);
     if (entryi.Get(syncable::PARENT_ID) ==
             entryi.Get(syncable::SERVER_PARENT_ID) ||
         !entryi.Get(syncable::IS_UNAPPLIED_UPDATE) ||
         !entryi.Get(syncable::IS_DIR)) {
       continue;
     }
     Id parentid = entryi.Get(syncable::SERVER_PARENT_ID);
@@ skipping 144 matching lines @@
     entry.Put(syncable::PARENT_ID, parent_id);
     entry.Put(syncable::IS_DEL, false);
     id = entry.Get(syncable::PARENT_ID);
     // METRIC conflict resolved by recreating dir tree.
   }
   return true;
 }
 
 bool AttemptToFixRemovedDirectoriesWithContent(WriteTransaction* trans,
                                                ConflictSet* conflict_set) {
+  UMA_HISTOGRAM_COUNTS("Sync.ConflictFixRemovedDirectoriesWithContent", 1);
   ConflictSet::const_iterator i, j;
   for (i = conflict_set->begin() ; i != conflict_set->end() ; ++i) {
     Entry entry(trans, syncable::GET_BY_ID, *i);
     if (AttemptToFixUnsyncedEntryInDeletedServerTree(trans,
         conflict_set, entry)) {
       return true;
     }
     if (AttemptToFixUpdateEntryInDeletedLocalTree(trans, conflict_set, entry))
       return true;
   }
@@ skipping 52 matching lines @@
              << 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;
   }
 
   status->set_syncer_stuck(true);
+  UMA_HISTOGRAM_COUNTS("Sync.SyncerConflictStuck", 1);
 
   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,
                                               StatusController* status) {
   WriteTransaction trans(dir, syncable::SYNCER, __FILE__, __LINE__);
@@ skipping 35 matching lines @@
   return forward_progress;
 }
 
 bool ConflictResolver::ResolveConflicts(const ScopedDirLookup& dir,
                                         StatusController* status) {
   const ConflictProgress& progress = status->conflict_progress();
   bool rv = false;
   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 = 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())) {
-      VLOG(1) << "Accelerating resolution for hierarchical merge.";
-      conflict_count += 2;
-    }
     // See if we should process this set.
     if (ProcessConflictSet(&trans, conflict_set, conflict_count)) {
       rv = true;
     }
     LogAndSignalIfConflictStuck(&trans, conflict_count,
                                 conflict_set->begin(),
                                 conflict_set->end(), status);
   }
   if (rv) {
     // This code means we don't signal that syncing is stuck when any conflict
@@ skipping 10 matching lines @@
       conflict_set_count_map_.erase(i++);
       // METRIC self resolved conflict sets ++.
     } else {
       ++i;
     }
   }
   return rv;
 }
 
 }  // namespace browser_sync