[Sync] Add nigori node conflict resolution.

chrome/browser/sync/engine/syncer_unittest.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.
 //
 // Syncer unit tests. Unfortunately a lot of these tests
 // are outdated and need to be reworked and updated.
 
 #include <algorithm>
 #include <limits>
 #include <list>
@@ skipping 14 matching lines @@
 #include "chrome/browser/sync/engine/model_safe_worker.h"
 #include "chrome/browser/sync/engine/net/server_connection_manager.h"
 #include "chrome/browser/sync/engine/process_updates_command.h"
 #include "chrome/browser/sync/engine/nigori_util.h"
 #include "chrome/browser/sync/engine/syncer.h"
 #include "chrome/browser/sync/engine/syncer_proto_util.h"
 #include "chrome/browser/sync/engine/syncer_util.h"
 #include "chrome/browser/sync/engine/syncproto.h"
 #include "chrome/browser/sync/protocol/sync.pb.h"
 #include "chrome/browser/sync/protocol/bookmark_specifics.pb.h"
+#include "chrome/browser/sync/protocol/nigori_specifics.pb.h"
 #include "chrome/browser/sync/sessions/sync_session_context.h"
 #include "chrome/browser/sync/syncable/directory_manager.h"
 #include "chrome/browser/sync/syncable/model_type.h"
 #include "chrome/browser/sync/syncable/syncable.h"
 #include "chrome/browser/sync/test/engine/fake_model_worker.h"
 #include "chrome/browser/sync/test/engine/mock_connection_manager.h"
 #include "chrome/browser/sync/test/engine/test_directory_setter_upper.h"
 #include "chrome/browser/sync/test/engine/test_id_factory.h"
 #include "chrome/browser/sync/test/engine/test_syncable_utils.h"
+#include "chrome/browser/sync/util/cryptographer.h"
 #include "chrome/browser/sync/util/time.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using base::TimeDelta;
 
 using std::map;
 using std::multimap;
 using std::set;
 using std::string;
 
@@ skipping 135 matching lines @@
       should_loop = SyncShareAsDelegate();
     } while (should_loop);
   }
 
   virtual void SetUp() {
     syncdb_.SetUp();
 
     mock_server_.reset(
         new MockConnectionManager(syncdb_.manager(), syncdb_.name()));
     EnableDatatype(syncable::BOOKMARKS);
+    EnableDatatype(syncable::NIGORI);
     worker_ = new FakeModelWorker(GROUP_PASSIVE);
     std::vector<SyncEngineEventListener*> listeners;
     listeners.push_back(this);
     context_.reset(new SyncSessionContext(mock_server_.get(),
         syncdb_.manager(), this, listeners, NULL));
     context_->set_account_name(syncdb_.name());
     ASSERT_FALSE(context_->resolver());
     syncer_ = new Syncer();
     session_.reset(MakeSession());
 
@@ skipping 528 matching lines @@
     ASSERT_TRUE(entryC.good());
     EXPECT_FALSE(entryC.Get(IS_UNSYNCED));
     EXPECT_FALSE(entryC.Get(IS_UNAPPLIED_UPDATE));
     Entry entryD(&rtrans, syncable::GET_BY_ID, ids_.FromNumber(4));
     ASSERT_TRUE(entryD.good());
     EXPECT_FALSE(entryD.Get(IS_UNSYNCED));
     EXPECT_FALSE(entryD.Get(IS_UNAPPLIED_UPDATE));
   }
 }
 
+TEST_F(SyncerTest, NigoriConflicts) {
+  ScopedDirLookup dir(syncdb_.manager(), syncdb_.name());
+  ASSERT_TRUE(dir.good());
+  KeyParams local_key_params = {"localhost", "dummy", "blargle"};
+  KeyParams other_key_params = {"localhost", "dummy", "foobar"};
+  browser_sync::Cryptographer other_cryptographer;
+  other_cryptographer.AddKey(other_key_params);
+  syncable::ModelTypeSet encrypted_types(syncable::PASSWORDS, syncable::NIGORI);
+  sync_pb::EntitySpecifics initial_nigori_specifics;
+  initial_nigori_specifics.MutableExtension(sync_pb::nigori);
+  mock_server_->SetNigori(1, 10, 10, initial_nigori_specifics);
+
+  // Data for testing encryption/decryption.
+  sync_pb::EntitySpecifics other_encrypted_specifics;
+  other_encrypted_specifics.MutableExtension(sync_pb::bookmark)->
+      set_title("title");
+  other_cryptographer.Encrypt(
+      other_encrypted_specifics,
+      other_encrypted_specifics.mutable_encrypted());
+  sync_pb::EntitySpecifics our_encrypted_specifics;
+  our_encrypted_specifics.MutableExtension(sync_pb::bookmark)->
+      set_title("title2");
+
+  // Receive the initial nigori node.
+  SyncShareAsDelegate();
+  encrypted_types = syncable::ModelTypeSet::All();
+  {
+    // Local changes with different passphrase, different types, and sync_tabs.
+    WriteTransaction wtrans(FROM_HERE, UNITTEST, dir);
+    sync_pb::EntitySpecifics specifics;
+    sync_pb::NigoriSpecifics* nigori =
+        specifics.MutableExtension(sync_pb::nigori);
+    syncdb_.manager()->GetCryptographer(&wtrans)->AddKey(local_key_params);
+    syncdb_.manager()->GetCryptographer(&wtrans)->Encrypt(
+        our_encrypted_specifics,
+        our_encrypted_specifics.mutable_encrypted());
+    syncdb_.manager()->GetCryptographer(&wtrans)->GetKeys(
+        nigori->mutable_encrypted());
+    syncdb_.manager()->GetCryptographer(&wtrans)->
+        UpdateNigoriFromEncryptedTypes(nigori);
+    nigori->set_sync_tabs(true);
+    syncdb_.manager()->GetCryptographer(&wtrans)->set_encrypt_everything();
+    MutableEntry nigori_entry(&wtrans, GET_BY_SERVER_TAG,
+                              syncable::ModelTypeToRootTag(syncable::NIGORI));
+    ASSERT_TRUE(nigori_entry.good());
+    nigori_entry.Put(SPECIFICS, specifics);
+    nigori_entry.Put(IS_UNSYNCED, true);
+    EXPECT_FALSE(syncdb_.manager()->GetCryptographer(&wtrans)->
+        has_pending_keys());
+    EXPECT_TRUE(encrypted_types.Equals(
+        syncdb_.manager()->GetCryptographer(&wtrans)->GetEncryptedTypes()));
+  }
+  {
+    sync_pb::EntitySpecifics specifics;
+    sync_pb::NigoriSpecifics* nigori =
+        specifics.MutableExtension(sync_pb::nigori);
+    other_cryptographer.GetKeys(nigori->mutable_encrypted());
+    nigori->set_encrypt_bookmarks(true);
+    nigori->set_encrypt_preferences(true);
+    nigori->set_encrypt_everything(false);
+    mock_server_->SetNigori(1, 20, 20, specifics);
+  }
+
+  // Will result in downloading the server nigori, which puts the local nigori
+  // in a state of conflict. This is resolved by merging the local and server
+  // data (with priority given to the server's encryption keys if they are
+  // undecryptable), which we then commit. The cryptographer should have pending
+  // keys and merge the set of encrypted types.
+  SyncShareAsDelegate();  // Resolve conflict in this cycle.
+  SyncShareAsDelegate();  // Commit local change in this cycle.
+  {
+    // Ensure the nigori data merged (encrypted types, sync_tabs).
+    WriteTransaction wtrans(FROM_HERE, UNITTEST, dir);
+    MutableEntry nigori_entry(&wtrans, GET_BY_SERVER_TAG,
+                              syncable::ModelTypeToRootTag(syncable::NIGORI));
+    ASSERT_TRUE(nigori_entry.good());
+    EXPECT_FALSE(nigori_entry.Get(IS_UNAPPLIED_UPDATE));
+    EXPECT_FALSE(nigori_entry.Get(IS_UNSYNCED));
+    sync_pb::EntitySpecifics specifics = nigori_entry.Get(SPECIFICS);
+    EXPECT_TRUE(syncdb_.manager()->GetCryptographer(&wtrans)->
+        has_pending_keys());
+    EXPECT_TRUE(encrypted_types.Equals(
+        syncdb_.manager()->GetCryptographer(&wtrans)->GetEncryptedTypes()));
+    EXPECT_TRUE(syncdb_.manager()->GetCryptographer(&wtrans)->
+        encrypt_everything());
+    EXPECT_TRUE(specifics.GetExtension(sync_pb::nigori).sync_tabs());
+    // Supply the pending keys. Afterwards, we should be able to decrypt both
+    // our own encrypted data and data encrypted by the other cryptographer,
+    // but the key provided by the other cryptographer should be the default.
+    EXPECT_TRUE(syncdb_.manager()->GetCryptographer(&wtrans)->
+        DecryptPendingKeys(other_key_params));
+    EXPECT_FALSE(syncdb_.manager()->GetCryptographer(&wtrans)->
+        has_pending_keys());
+    sync_pb::NigoriSpecifics* nigori =
+        specifics.MutableExtension(sync_pb::nigori);
+    syncdb_.manager()->GetCryptographer(&wtrans)->GetKeys(
+        nigori->mutable_encrypted());
+    syncdb_.manager()->GetCryptographer(&wtrans)->
+        UpdateNigoriFromEncryptedTypes(nigori);
+    // Normally this would be written as part of SetPassphrase, but we do it
+    // manually for the test.
+    nigori_entry.Put(SPECIFICS, specifics);
+    nigori_entry.Put(IS_UNSYNCED, true);
+  }
+
+  SyncShareAsDelegate();
+  {
+    // Ensure everything is committed and stable now. The cryptographer
+    // should be able to decrypt both sets of keys, sync_tabs should be true,
+    // and the encrypted types should have been unioned.
+    WriteTransaction wtrans(FROM_HERE, UNITTEST, dir);
+    MutableEntry nigori_entry(&wtrans, GET_BY_SERVER_TAG,
+                              syncable::ModelTypeToRootTag(syncable::NIGORI));
+    ASSERT_TRUE(nigori_entry.good());
+    EXPECT_FALSE(nigori_entry.Get(IS_UNAPPLIED_UPDATE));
+    EXPECT_FALSE(nigori_entry.Get(IS_UNSYNCED));
+    EXPECT_TRUE(syncdb_.manager()->GetCryptographer(&wtrans)->CanDecrypt(
+        our_encrypted_specifics.encrypted()));
+    EXPECT_FALSE(syncdb_.manager()->GetCryptographer(&wtrans)->
+        CanDecryptUsingDefaultKey(our_encrypted_specifics.encrypted()));
+    EXPECT_TRUE(syncdb_.manager()->GetCryptographer(&wtrans)->CanDecrypt(
+        other_encrypted_specifics.encrypted()));
+    EXPECT_TRUE(syncdb_.manager()->GetCryptographer(&wtrans)->
+        CanDecryptUsingDefaultKey(other_encrypted_specifics.encrypted()));
+    EXPECT_TRUE(nigori_entry.Get(SPECIFICS).GetExtension(sync_pb::nigori)
+        .sync_tabs());
+  }
+}
+
+
 // TODO(chron): More corner case unit tests around validation.
 TEST_F(SyncerTest, TestCommitMetahandleIterator) {
   ScopedDirLookup dir(syncdb_.manager(), syncdb_.name());
   ASSERT_TRUE(dir.good());
   StatusController* status = session_->mutable_status_controller();
   const vector<int64>& unsynced(status->unsynced_handles());
 
   {
     WriteTransaction wtrans(FROM_HERE, UNITTEST, dir);
     ScopedSetSessionWriteTransaction set_trans(session_.get(), &wtrans);
@@ skipping 3792 matching lines @@
   Add(low_id_);
   Add(high_id_);
   SyncShareAsDelegate();
   ExpectLocalOrderIsByServerId();
 }
 
 const SyncerTest::CommitOrderingTest
 SyncerTest::CommitOrderingTest::LAST_COMMIT_ITEM = {-1, TestIdFactory::root()};
 
 }  // namespace browser_sync