[Sync] Add nigori node 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>
 
 #include "base/location.h"
 #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/nigori_specifics.pb.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/cryptographer.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;
 
 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.
+  NIGORI_MERGE,              // Resolved by merging nigori nodes.
   CONFLICT_RESOLUTION_SIZE,
 };
 
 }  // namespace
 
 ConflictResolver::ConflictResolver() {
 }
 
 ConflictResolver::~ConflictResolver() {
 }
@@ skipping 15 matching lines @@
   // TODO(chron): This is really a general property clobber. We clobber
   // the server side property. Perhaps we should actually do property merging.
   DVLOG(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);
 }
 
 ConflictResolver::ProcessSimpleConflictResult
 ConflictResolver::ProcessSimpleConflict(WriteTransaction* trans,
                                         const Id& id,
+                                        const Cryptographer* cryptographer,
                                         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
   // in a set here, so we must be unsynced.
   if (!entry.Get(syncable::IS_UNSYNCED)) {
     return NO_SYNC_PROGRESS;
   }
 
@@ skipping 26 matching lines @@
     // be nice if we could route this back to ModelAssociator code to pick one
     // of three options: CLIENT, SERVER, or MERGE.  Some datatypes (autofill)
     // are easily mergeable.
     // See http://crbug.com/77339.
     bool name_matches = entry.Get(syncable::NON_UNIQUE_NAME) ==
                         entry.Get(syncable::SERVER_NON_UNIQUE_NAME);
     bool parent_matches = entry.Get(syncable::PARENT_ID) ==
                                     entry.Get(syncable::SERVER_PARENT_ID);
     bool entry_deleted = entry.Get(syncable::IS_DEL);
 
-    if (!entry_deleted && name_matches && parent_matches) {
+    // We manually merge nigori data.
+    // TODO(zea): Find a better way of doing this. As it stands, we have to

[tim (not reviewing), 2011/12/20 17:54:05]

Maybe move this comment down to the set_sync_tabs bit?

[Nicolas Zea, 2011/12/20 19:54:10]

Done.

+    // update this code whenever we add a new non-cryptographer related field to
+    // the nigori node.
+    if (entry.GetModelType() == syncable::NIGORI) {
+      // Create a new set of specifics based on the server specifics (which
+      // preserves their encryption keys).
+      sync_pb::EntitySpecifics specifics =
+          entry.Get(syncable::SERVER_SPECIFICS);
+      sync_pb::NigoriSpecifics* nigori =
+          specifics.MutableExtension(sync_pb::nigori);
+      // Store the merged set of encrypted types (cryptographer->Update(..) will
+      // have merged the local types already).
+      cryptographer->UpdateNigoriFromEncryptedTypes(nigori);
+      // The local set of keys is already merged with the server's set within
+      // the cryptographer. If we don't have pending keys we can store the
+      // merged set back immediately. Else we preserve the server keys and will
+      // update the nigori when the user provides the pending passphrase via
+      // SetPassphrase(..).
+      if (cryptographer->is_ready()) {
+        cryptographer->GetKeys(nigori->mutable_encrypted());
+      }
+      if (entry.Get(syncable::SPECIFICS).GetExtension(sync_pb::nigori)
+              .sync_tabs()) {
+        nigori->set_sync_tabs(true);
+      }
+      entry.Put(syncable::SPECIFICS, specifics);
+      DVLOG(1) << "Resovling simple conflict, merging nigori nodes: " << entry;
+      status->increment_num_server_overwrites();
+      OverwriteServerChanges(trans, &entry);
+      UMA_HISTOGRAM_ENUMERATION("Sync.ResolveSimpleConflict",
+                                NIGORI_MERGE,
+                                CONFLICT_RESOLUTION_SIZE);
+    } else 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
       DVLOG(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);
@@ skipping 315 matching lines @@
   // 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,
     const ConflictProgress& progress,
     sessions::StatusController* status) {
   WriteTransaction trans(FROM_HERE, syncable::SYNCER, dir);
+  Cryptographer* cryptographer = dir.manager()->GetCryptographer(&trans);

[tim (not reviewing), 2011/12/20 17:54:05]

Is manager() or the cryptographer really not available any other way?

[Nicolas Zea, 2011/12/20 19:54:10]

Neither the status controller nor the conflict progress have access to the
manager/cryptographer. Another option would be to plumb in the manager as an
additional parameter from the ResolveConflicts command and ResolveConflict
method, in addition to the ScopedDirLookup, but this seemed simpler, since the
ScopedDirLookup wraps around the manager already.

   bool forward_progress = false;
   // First iterate over simple conflict items (those that belong to no set).
   set<Id>::const_iterator conflicting_item_it;
   for (conflicting_item_it = progress.ConflictingItemsBegin();
        conflicting_item_it != progress.ConflictingItemsEnd();
        ++conflicting_item_it) {
     Id id = *conflicting_item_it;
     map<Id, ConflictSet*>::const_iterator item_set_it =
         progress.IdToConflictSetFind(id);
     if (item_set_it == progress.IdToConflictSetEnd() ||
         0 == item_set_it->second) {
       // We have a simple conflict.
-      switch (ProcessSimpleConflict(&trans, id, status)) {
+      switch (ProcessSimpleConflict(&trans, id, cryptographer, status)) {
         case NO_SYNC_PROGRESS:
           {
             int conflict_count = (simple_conflict_count_map_[id] += 2);
             LogAndSignalIfConflictStuck(&trans, conflict_count,
                                         &id, &id + 1, status);
             break;
           }
         case SYNC_PROGRESS:
           forward_progress = true;
           break;
@@ skipping 53 matching lines @@
       conflict_set_count_map_.erase(i++);
       // METRIC self resolved conflict sets ++.
     } else {
       ++i;
     }
   }
   return rv;
 }
 
 }  // namespace browser_sync