[Sync] Adding integration tests for USS encryption and fixing a worker bug.

components/sync/engine_impl/model_type_worker_unittest.cc

Index: components/sync/engine_impl/model_type_worker_unittest.cc
diff --git a/components/sync/engine_impl/model_type_worker_unittest.cc b/components/sync/engine_impl/model_type_worker_unittest.cc
index f9029eda2abd0e8c9745b005919237e854abac35..fccad4fb12fdd01c7569a14e548de7cc35c4f401 100644
--- a/components/sync/engine_impl/model_type_worker_unittest.cc
+++ b/components/sync/engine_impl/model_type_worker_unittest.cc
@@ -281,11 +281,10 @@ class ModelTypeWorkerTest : public ::testing::Test {
 
   void TriggerTypeRootUpdateFromServer() {
     sync_pb::SyncEntity entity = mock_server_.TypeRootUpdate();
-    StatusController dummy_status;
     worker_->ProcessGetUpdatesResponse(mock_server_.GetProgress(),
                                        mock_server_.GetContext(), {&entity},
-                                       &dummy_status);
-    worker_->PassiveApplyUpdates(&dummy_status);
+                                       nullptr);
+    worker_->PassiveApplyUpdates(nullptr);
   }
 
   void TriggerPartialUpdateFromServer(int64_t version_offset,
@@ -299,18 +298,16 @@ class ModelTypeWorkerTest : public ::testing::Test {
                     entity.mutable_specifics());
     }
 
-    StatusController dummy_status;
     worker_->ProcessGetUpdatesResponse(mock_server_.GetProgress(),
                                        mock_server_.GetContext(), {&entity},
-                                       &dummy_status);
+                                       nullptr);
   }
 
   void TriggerUpdateFromServer(int64_t version_offset,
                                const std::string& tag,
                                const std::string& value) {
     TriggerPartialUpdateFromServer(version_offset, tag, value);
-    StatusController dummy_status;
-    worker_->ApplyUpdates(&dummy_status);
+    worker_->ApplyUpdates(nullptr);
   }
 
   void TriggerTombstoneFromServer(int64_t version_offset,
@@ -323,11 +320,10 @@ class ModelTypeWorkerTest : public ::testing::Test {
                     entity.mutable_specifics());
     }
 
-    StatusController dummy_status;
     worker_->ProcessGetUpdatesResponse(mock_server_.GetProgress(),
                                        mock_server_.GetContext(), {&entity},
-                                       &dummy_status);
-    worker_->ApplyUpdates(&dummy_status);
+                                       nullptr);
+    worker_->ApplyUpdates(nullptr);
   }
 
   // Delivers specified protos as updates.
@@ -336,11 +332,9 @@ class ModelTypeWorkerTest : public ::testing::Test {
   // writing test cases that require entities that don't fit the normal sync
   // protocol. Try to use the other, higher level methods if possible.
   void DeliverRawUpdates(const SyncEntityList& list) {
-    StatusController dummy_status;
-    worker_->ProcessGetUpdatesResponse(mock_server_.GetProgress(),
-                                       mock_server_.GetContext(), list,
-                                       &dummy_status);
-    worker_->ApplyUpdates(&dummy_status);
+    worker_->ProcessGetUpdatesResponse(
+        mock_server_.GetProgress(), mock_server_.GetContext(), list, nullptr);
+    worker_->ApplyUpdates(nullptr);
   }
 
   // By default, this harness behaves as if all tasks posted to the model
@@ -385,8 +379,7 @@ class ModelTypeWorkerTest : public ::testing::Test {
     sync_pb::ClientToServerResponse response =
         mock_server_.DoSuccessfulCommit(message);
 
-    StatusController dummy_status;
-    contribution->ProcessCommitResponse(response, &dummy_status);
+    contribution->ProcessCommitResponse(response, nullptr);
     contribution->CleanUp();
   }
 
@@ -695,6 +688,18 @@ TEST_F(ModelTypeWorkerTest, ReceiveMultiPartUpdates) {
   EXPECT_EQ(GenerateTagHash(kTag3), updates[0].entity->client_tag_hash);
 }
 
+// Test that updates with no entities behave correctly.
+TEST_F(ModelTypeWorkerTest, EmptyUpdates) {
+  NormalInitialize();
+
+  server()->SetProgressMarkerToken("token2");
+  DeliverRawUpdates(SyncEntityList());
+  ASSERT_EQ(1U, processor()->GetNumUpdateResponses());
+  ASSERT_EQ(
+      server()->GetProgress().SerializeAsString(),
+      processor()->GetNthUpdateState(0).progress_marker().SerializeAsString());
+}
+
 // Test commit of encrypted updates.
 TEST_F(ModelTypeWorkerTest, EncryptedCommit) {
   NormalInitialize();
@@ -728,6 +733,54 @@ TEST_F(ModelTypeWorkerTest, EncryptedCommit) {
   EXPECT_FALSE(tag1_entity.specifics().preference().has_value());
 }
 
+// Test creating multiple encryption keys. Even when if the cryptographer thinks
+// the world is okay, if we have an entity that is not decryptable, everything
+// should still be blocked.
+TEST_F(ModelTypeWorkerTest, MultipleEncryptionKeys) {
+  NormalInitialize();
+
+  SetUpdateEncryptionFilter(2);
+  server()->SetProgressMarkerToken("token2");
+  TriggerUpdateFromServer(10, kTag1, kValue1);
+  ASSERT_EQ(0U, processor()->GetNumUpdateResponses());
+
+  NewForeignEncryptionKey();
+  UpdateLocalCryptographer();
+  ASSERT_EQ(0U, processor()->GetNumUpdateResponses());
+
+  NewForeignEncryptionKey();
+  UpdateLocalCryptographer();
+  ASSERT_EQ(1U, processor()->GetNumUpdateResponses());
+  UpdateResponseDataList updates_list = processor()->GetNthUpdateResponse(0);
+  EXPECT_EQ(1U, updates_list.size());
+  ASSERT_EQ(
+      server()->GetProgress().SerializeAsString(),
+      processor()->GetNthUpdateState(0).progress_marker().SerializeAsString());
+}
+
+// Test that updates are not delivered to the processor when encryption is
+// required but unavailable.
+TEST_F(ModelTypeWorkerTest, EncryptionBlocksUpdates) {
+  NormalInitialize();
+
+  // Update encryption key name, should be blocked.
+  NewForeignEncryptionKey();
+  ASSERT_EQ(0U, processor()->GetNumUpdateResponses());
+
+  // Update progress marker, should be blocked.
+  server()->SetProgressMarkerToken("token2");
+  DeliverRawUpdates(SyncEntityList());
+  ASSERT_EQ(0U, processor()->GetNumUpdateResponses());
+
+  // Update local cryptographer, verify everything is pushed to processor.
+  UpdateLocalCryptographer();
+  ASSERT_EQ(1U, processor()->GetNumUpdateResponses());
+  UpdateResponseDataList updates_list = processor()->GetNthUpdateResponse(0);
+  ASSERT_EQ(
+      server()->GetProgress().SerializeAsString(),
+      processor()->GetNthUpdateState(0).progress_marker().SerializeAsString());
+}
+
 // Test items are not committed when encryption is required but unavailable.
 TEST_F(ModelTypeWorkerTest, EncryptionBlocksCommits) {
   NormalInitialize();
@@ -821,11 +874,8 @@ TEST_F(ModelTypeWorkerTest, ReceiveUndecryptableEntries) {
   TriggerUpdateFromServer(10, kTag1, kValue1);
 
   // At this point, the cryptographer does not have access to the key, so the
-  // updates will be undecryptable. They'll be transfered to the model thread
-  // for safe-keeping as pending updates.
-  ASSERT_EQ(1U, processor()->GetNumUpdateResponses());
-  UpdateResponseDataList updates_list = processor()->GetNthUpdateResponse(0);
-  EXPECT_EQ(0U, updates_list.size());
+  // updates will be undecryptable. This will block all updates.
+  ASSERT_EQ(0U, processor()->GetNumUpdateResponses());
 
   // The update will be delivered as soon as decryption becomes possible.
   UpdateLocalCryptographer();
@@ -846,7 +896,9 @@ TEST_F(ModelTypeWorkerTest, EncryptedUpdateOverridesPendingCommit) {
 
   // Receive an encrypted update for that item.
   SetUpdateEncryptionFilter(1);
+  NewForeignEncryptionKey();
   TriggerUpdateFromServer(10, kTag1, kValue1);
+  UpdateLocalCryptographer();
 
   // The pending commit state should be cleared.
   EXPECT_FALSE(WillCommit());
@@ -854,7 +906,7 @@ TEST_F(ModelTypeWorkerTest, EncryptedUpdateOverridesPendingCommit) {
   // The encrypted update will be delivered to the model thread.
   ASSERT_EQ(1U, processor()->GetNumUpdateResponses());
   UpdateResponseDataList updates_list = processor()->GetNthUpdateResponse(0);
-  EXPECT_EQ(0U, updates_list.size());
+  EXPECT_EQ(1U, updates_list.size());
 }
 
 // Commit twice, both times with the kUncommittedVersion base version. Then