[Sync] Add histograms for simple conflict resolution.

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>
 
@@ skipping 14 matching lines @@
 using syncable::Id;
 using syncable::MutableEntry;
 using syncable::ScopedDirLookup;
 using syncable::WriteTransaction;
 
 namespace browser_sync {
 
 using sessions::ConflictProgress;
 using sessions::StatusController;
 
+namespace {
+
 const int SYNC_CYCLES_BEFORE_ADMITTING_DEFEAT = 8;
 
+// Enumeration of different conflict resolutions. Used for histogramming.
+enum SimpleConflictResolutions {
+  OVERWRITE_LOCAL,           // Resolved by overwriting local changes.
+  OVERWRITE_SERVER,          // Resolved by overwriting server changes.
+  UNDELETE,                  // Resolved by undeleting local item.
+  IGNORE_ENCRYPTION,         // Resolved by ignoring an encryption-only server
+                             // change. TODO(zea): implement and use this.
+  CONFLICT_RESOLUTION_SIZE,
+};
+
+}  // namespace
+
 ConflictResolver::ConflictResolver() {
 }
 
 ConflictResolver::~ConflictResolver() {
 }
 
 void ConflictResolver::IgnoreLocalChanges(MutableEntry* entry) {
   // An update matches local actions, merge the changes.
   // This is a little fishy because we don't actually merge them.
   // In the future we should do a 3-way merge.
-  VLOG(1) << "Server and local changes match, merging:" << entry;
+  VLOG(1) << "Resolving conflict by ignoring local changes:" << entry;
   // With IS_UNSYNCED false, changes should be merged.
-  // METRIC simple conflict resolved by merge.
   entry->Put(syncable::IS_UNSYNCED, false);
 }
 
 void ConflictResolver::OverwriteServerChanges(WriteTransaction* trans,
                                               MutableEntry * entry) {
   // This is similar to an overwrite from the old client.
   // This is equivalent to a scenario where we got the update before we'd
   // 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.
+  VLOG(1) << "Resolving conflict by ignoring server changes:" << entry;
   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,
                                         const Id& id,
                                         StatusController* status) {
   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
@@ skipping 39 matching lines @@
     bool entry_deleted = entry.Get(syncable::IS_DEL);
 
     if (!entry_deleted && name_matches && parent_matches) {
       // TODO(zea): We may prefer to choose the local changes over the server
       // if we know the local changes happened before (or vice versa).
       // See http://crbug.com/76596
       VLOG(1) << "Resolving simple conflict, ignoring local changes for:"
               << entry;
       IgnoreLocalChanges(&entry);
       status->increment_num_local_overwrites();
+      UMA_HISTOGRAM_ENUMERATION("Sync.ResolveSimpleConflict",
+                                OVERWRITE_LOCAL,
+                                CONFLICT_RESOLUTION_SIZE);
     } else {
       VLOG(1) << "Resolving simple conflict, overwriting server changes for:"
               << entry;
       OverwriteServerChanges(trans, &entry);
       status->increment_num_server_overwrites();
+      UMA_HISTOGRAM_ENUMERATION("Sync.ResolveSimpleConflict",
+                                OVERWRITE_SERVER,
+                                CONFLICT_RESOLUTION_SIZE);
     }
     return SYNC_PROGRESS;
   } else {  // SERVER_IS_DEL is true
     // If a server deleted folder has local contents we should be in a set.
     if (entry.Get(syncable::IS_DIR)) {
       Directory::ChildHandles children;
       trans->directory()->GetChildHandlesById(trans,
                                               entry.Get(syncable::ID),
                                               &children);
       if (0 != children.size()) {
         VLOG(1) << "Entry is a server deleted directory with local contents, "
                    "should be in a set. (race condition).";
         return NO_SYNC_PROGRESS;
       }
     }
 
     // The entry is deleted on the server but still exists locally.
     if (!entry.Get(syncable::UNIQUE_CLIENT_TAG).empty()) {
       // If we've got a client-unique tag, we can undelete while retaining
       // our present ID.
       DCHECK_EQ(entry.Get(syncable::SERVER_VERSION), 0) << "For the server to "
           "know to re-create, client-tagged items should revert to version 0 "
           "when server-deleted.";
       OverwriteServerChanges(trans, &entry);
       status->increment_num_server_overwrites();
+      UMA_HISTOGRAM_ENUMERATION("Sync.ResolveSimpleConflict",
+                                OVERWRITE_SERVER,
+                                CONFLICT_RESOLUTION_SIZE);
       // Clobber the versions, just in case the above DCHECK is violated.
       entry.Put(syncable::SERVER_VERSION, 0);
       entry.Put(syncable::BASE_VERSION, 0);
     } else {
       // Otherwise, we've got to undelete by creating a new locally
       // uncommitted entry.
       SyncerUtil::SplitServerInformationIntoNewEntry(trans, &entry);
 
       MutableEntry server_update(trans, syncable::GET_BY_ID, id);
       CHECK(server_update.good());
       CHECK(server_update.Get(syncable::META_HANDLE) !=
             entry.Get(syncable::META_HANDLE))
           << server_update << entry;
+      UMA_HISTOGRAM_ENUMERATION("Sync.ResolveSimpleConflict",
+                                UNDELETE,
+                                CONFLICT_RESOLUTION_SIZE);
     }
     return SYNC_PROGRESS;
   }
 }
 
 ConflictResolver::ConflictSetCountMapKey ConflictResolver::GetSetKey(
     ConflictSet* set) {
   // TODO(sync): Come up with a better scheme for set hashing. This scheme
   // will make debugging easy.
   // If this call to sort is removed, we need to add one before we use
@@ skipping 338 matching lines @@
       conflict_set_count_map_.erase(i++);
       // METRIC self resolved conflict sets ++.
     } else {
       ++i;
     }
   }
   return rv;
 }
 
 }  // namespace browser_sync