sync: Populate debug counters for directory types

sync/engine/conflict_resolver.cc

 // Copyright 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/engine/conflict_resolver.h"
 
 #include <list>
 #include <set>
 #include <string>
 
 #include "base/metrics/histogram.h"
 #include "sync/engine/conflict_util.h"
 #include "sync/engine/syncer_util.h"
+#include "sync/internal_api/public/sessions/update_counters.h"
 #include "sync/sessions/status_controller.h"
 #include "sync/syncable/directory.h"
 #include "sync/syncable/mutable_entry.h"
 #include "sync/syncable/syncable_write_transaction.h"
 #include "sync/util/cryptographer.h"
 
 using std::list;
 using std::set;
 
 namespace syncer {
 
 using sessions::StatusController;
 using syncable::Directory;
 using syncable::Entry;
 using syncable::Id;
 using syncable::MutableEntry;
 using syncable::WriteTransaction;
 
 ConflictResolver::ConflictResolver() {
 }
 
 ConflictResolver::~ConflictResolver() {
 }
 
 void ConflictResolver::ProcessSimpleConflict(WriteTransaction* trans,
                                              const Id& id,
                                              const Cryptographer* cryptographer,
-                                             StatusController* status) {
+                                             StatusController* status,
+                                             UpdateCounters* counters) {
   MutableEntry entry(trans, syncable::GET_BY_ID, id);
   // Must be good as the entry won't have been cleaned up.
   CHECK(entry.good());
 
   // This function can only resolve simple conflicts.  Simple conflicts have
   // both IS_UNSYNCED and IS_UNAPPLIED_UDPATE set.
   if (!entry.GetIsUnappliedUpdate() || !entry.GetIsUnsynced()) {
     // This is very unusual, but it can happen in tests.  We may be able to
     // assert NOTREACHED() here when those tests are updated.
     return;
@@ skipping 99 matching lines @@
       DVLOG(1) << "Resolving simple conflict, everything matches, ignoring "
                << "changes for: " << entry;
       conflict_util::IgnoreConflict(&entry);
       UMA_HISTOGRAM_ENUMERATION("Sync.ResolveSimpleConflict",
                                 CHANGES_MATCH,
                                 CONFLICT_RESOLUTION_SIZE);
     } else if (base_server_specifics_match) {
       DVLOG(1) << "Resolving simple conflict, ignoring server encryption "
                << " changes for: " << entry;
       status->increment_num_server_overwrites();
+      counters->num_server_overwrites++;
       conflict_util::OverwriteServerChanges(&entry);
       UMA_HISTOGRAM_ENUMERATION("Sync.ResolveSimpleConflict",
                                 IGNORE_ENCRYPTION,
                                 CONFLICT_RESOLUTION_SIZE);
     } else if (entry_deleted || !name_matches || !parent_matches) {
       // NOTE: The update application logic assumes that conflict resolution
       // will never result in changes to the local hierarchy.  The entry_deleted
       // and !parent_matches cases here are critical to maintaining that
       // assumption.
       conflict_util::OverwriteServerChanges(&entry);
       status->increment_num_server_overwrites();
+      counters->num_server_overwrites++;
       DVLOG(1) << "Resolving simple conflict, overwriting server changes "
                << "for: " << entry;
       UMA_HISTOGRAM_ENUMERATION("Sync.ResolveSimpleConflict",
                                 OVERWRITE_SERVER,
                                 CONFLICT_RESOLUTION_SIZE);
     } else {
       DVLOG(1) << "Resolving simple conflict, ignoring local changes for: "
                << entry;
       conflict_util::IgnoreLocalChanges(&entry);
       status->increment_num_local_overwrites();
+      counters->num_local_overwrites++;
       UMA_HISTOGRAM_ENUMERATION("Sync.ResolveSimpleConflict",
                                 OVERWRITE_LOCAL,
                                 CONFLICT_RESOLUTION_SIZE);
     }
     // Now that we've resolved the conflict, clear the prev server
     // specifics.
     entry.PutBaseServerSpecifics(sync_pb::EntitySpecifics());
   } else {  // SERVER_IS_DEL is true
     if (entry.GetIsDir()) {
       Directory::Metahandles children;
       trans->directory()->GetChildHandlesById(trans,
                                               entry.GetId(),
                                               &children);
       // If a server deleted folder has local contents it should be a hierarchy
       // conflict.  Hierarchy conflicts should not be processed by this
       // function.
       DCHECK(children.empty());
     }
 
     // The entry is deleted on the server but still exists locally.
     // We undelete it by overwriting the server's tombstone with the local
     // data.
     conflict_util::OverwriteServerChanges(&entry);
     status->increment_num_server_overwrites();
+    counters->num_server_overwrites++;
     DVLOG(1) << "Resolving simple conflict, undeleting server entry: "
              << entry;
     UMA_HISTOGRAM_ENUMERATION("Sync.ResolveSimpleConflict",
                               UNDELETE,
                               CONFLICT_RESOLUTION_SIZE);
   }
 }
 
 void ConflictResolver::ResolveConflicts(
     syncable::WriteTransaction* trans,
     const Cryptographer* cryptographer,
     const std::set<syncable::Id>& simple_conflict_ids,
-    sessions::StatusController* status) {
+    sessions::StatusController* status,
+    UpdateCounters* counters) {
   // Iterate over simple conflict items.
   set<Id>::const_iterator it;
   for (it = simple_conflict_ids.begin();
        it != simple_conflict_ids.end();
        ++it) {
     // We don't resolve conflicts for control types here.
     Entry conflicting_node(trans, syncable::GET_BY_ID, *it);
     CHECK(conflicting_node.good());
     if (IsControlType(
         GetModelTypeFromSpecifics(conflicting_node.GetSpecifics()))) {
       continue;
     }
 
-    ProcessSimpleConflict(trans, *it, cryptographer, status);
+    ProcessSimpleConflict(trans, *it, cryptographer, status, counters);
   }
   return;
 }
 
 }  // namespace syncer