FYI: Remove PerModelSafeGroupState + move ConflictResolution

sync/engine/apply_updates_command_unittest.cc

Index: sync/engine/apply_updates_command_unittest.cc
diff --git a/sync/engine/apply_updates_command_unittest.cc b/sync/engine/apply_updates_command_unittest.cc
index eee3edb7714de6b73d9044e463cd076028acf720..aa539bb00bc5712691ff9b37bf36afb20f838e62 100644
--- a/sync/engine/apply_updates_command_unittest.cc
+++ b/sync/engine/apply_updates_command_unittest.cc
@@ -83,18 +83,11 @@ TEST_F(ApplyUpdatesCommandTest, Simple) {
 
   sessions::StatusController* status = session()->mutable_status_controller();
 
-  sessions::ScopedModelSafeGroupRestriction r(status, GROUP_UI);
-  ASSERT_TRUE(status->update_progress());
-  EXPECT_EQ(2, status->update_progress()->AppliedUpdatesSize())
-      << "All updates should have been attempted";
-  ASSERT_TRUE(status->conflict_progress());
-  EXPECT_EQ(0, status->conflict_progress()->SimpleConflictingItemsSize())
+  EXPECT_EQ(0, status->num_encryption_conflicts())
       << "Simple update shouldn't result in conflicts";
-  EXPECT_EQ(0, status->conflict_progress()->EncryptionConflictingItemsSize())
+  EXPECT_EQ(0, status->num_hierarchy_conflicts())
       << "Simple update shouldn't result in conflicts";
-  EXPECT_EQ(0, status->conflict_progress()->HierarchyConflictingItemsSize())
-      << "Simple update shouldn't result in conflicts";
-  EXPECT_EQ(2, status->update_progress()->SuccessfullyAppliedUpdateCount())
+  EXPECT_EQ(2, status->num_updates_applied())
       << "All items should have been successfully applied";
 }
 
@@ -117,14 +110,7 @@ TEST_F(ApplyUpdatesCommandTest, UpdateWithChildrenBeforeParents) {
   apply_updates_command_.ExecuteImpl(session());
 
   sessions::StatusController* status = session()->mutable_status_controller();
-  sessions::ScopedModelSafeGroupRestriction r(status, GROUP_UI);
-  ASSERT_TRUE(status->update_progress());
-  EXPECT_EQ(5, status->update_progress()->AppliedUpdatesSize())
-      << "All updates should have been attempted";
-  ASSERT_TRUE(status->conflict_progress());
-  EXPECT_EQ(0, status->conflict_progress()->SimpleConflictingItemsSize())
-      << "Simple update shouldn't result in conflicts, even if out-of-order";
-  EXPECT_EQ(5, status->update_progress()->SuccessfullyAppliedUpdateCount())
+  EXPECT_EQ(5, status->num_updates_applied())
       << "All updates should have been successfully applied";
 }
 
@@ -139,10 +125,10 @@ TEST_F(ApplyUpdatesCommandTest, SimpleConflict) {
   apply_updates_command_.ExecuteImpl(session());
 
   sessions::StatusController* status = session()->mutable_status_controller();
-  sessions::ScopedModelSafeGroupRestriction r(status, GROUP_UI);
-  ASSERT_TRUE(status->conflict_progress());
-  EXPECT_EQ(1, status->conflict_progress()->SimpleConflictingItemsSize())
-      << "Unsynced and unapplied item should be a simple conflict";
+  EXPECT_EQ(1, status->num_server_overwrites())
+      << "Unsynced and unapplied item conflict should be resolved";
+  EXPECT_EQ(0, status->num_updates_applied())
+      << "Update should not be applied; we should override the server.";
 }
 
 // Runs the ApplyUpdatesCommand on an item that has both local and remote
@@ -169,15 +155,10 @@ TEST_F(ApplyUpdatesCommandTest, HierarchyAndSimpleConflict) {
   apply_updates_command_.ExecuteImpl(session());
 
   sessions::StatusController* status = session()->mutable_status_controller();
-  sessions::ScopedModelSafeGroupRestriction r(status, GROUP_UI);
-
-  EXPECT_EQ(1, status->update_progress()->AppliedUpdatesSize());
 
   // An update that is both a simple conflict and a hierarchy conflict should be
   // treated as a hierarchy conflict.
-  ASSERT_TRUE(status->conflict_progress());
-  EXPECT_EQ(1, status->conflict_progress()->HierarchyConflictingItemsSize());
-  EXPECT_EQ(0, status->conflict_progress()->SimpleConflictingItemsSize());
+  EXPECT_EQ(1, status->num_hierarchy_conflicts());
 }
 
 
@@ -216,14 +197,9 @@ TEST_F(ApplyUpdatesCommandTest, HierarchyConflictDirectoryLoop) {
   apply_updates_command_.ExecuteImpl(session());
 
   sessions::StatusController* status = session()->mutable_status_controller();
-  sessions::ScopedModelSafeGroupRestriction r(status, GROUP_UI);
-
-  EXPECT_EQ(1, status->update_progress()->AppliedUpdatesSize());
 
   // This should count as a hierarchy conflict.
-  ASSERT_TRUE(status->conflict_progress());
-  EXPECT_EQ(1, status->conflict_progress()->HierarchyConflictingItemsSize());
-  EXPECT_EQ(0, status->conflict_progress()->SimpleConflictingItemsSize());
+  EXPECT_EQ(1, status->num_hierarchy_conflicts());
 }
 
 // Runs the ApplyUpdatesCommand on a directory where the server sent us an
@@ -254,12 +230,7 @@ TEST_F(ApplyUpdatesCommandTest, HierarchyConflictDeletedParent) {
   apply_updates_command_.ExecuteImpl(session());
 
   sessions::StatusController* status = session()->mutable_status_controller();
-  sessions::ScopedModelSafeGroupRestriction r(status, GROUP_UI);
-
-  // This should count as a hierarchy conflict.
-  ASSERT_TRUE(status->conflict_progress());
-  EXPECT_EQ(1, status->conflict_progress()->HierarchyConflictingItemsSize());
-  EXPECT_EQ(0, status->conflict_progress()->SimpleConflictingItemsSize());
+  EXPECT_EQ(1, status->num_hierarchy_conflicts());
 }
 
 // Runs the ApplyUpdatesCommand on a directory where the server is trying to
@@ -296,12 +267,8 @@ TEST_F(ApplyUpdatesCommandTest, HierarchyConflictDeleteNonEmptyDirectory) {
   apply_updates_command_.ExecuteImpl(session());
 
   sessions::StatusController* status = session()->mutable_status_controller();
-  sessions::ScopedModelSafeGroupRestriction r(status, GROUP_UI);
-
   // This should count as a hierarchy conflict.
-  ASSERT_TRUE(status->conflict_progress());
-  EXPECT_EQ(1, status->conflict_progress()->HierarchyConflictingItemsSize());
-  EXPECT_EQ(0, status->conflict_progress()->SimpleConflictingItemsSize());
+  EXPECT_EQ(1, status->num_hierarchy_conflicts());
 }
 
 // Runs the ApplyUpdatesCommand on a server-created item that has a locally
@@ -318,17 +285,10 @@ TEST_F(ApplyUpdatesCommandTest, HierarchyConflictUnknownParent) {
   apply_updates_command_.ExecuteImpl(session());
 
   sessions::StatusController* status = session()->mutable_status_controller();
-  sessions::ScopedModelSafeGroupRestriction r(status, GROUP_UI);
-  ASSERT_TRUE(status->update_progress());
-  EXPECT_EQ(2, status->update_progress()->AppliedUpdatesSize())
-      << "All updates should have been attempted";
-  ASSERT_TRUE(status->conflict_progress());
-  EXPECT_EQ(0, status->conflict_progress()->SimpleConflictingItemsSize())
-      << "Updates with unknown parent should not be treated as 'simple'"
-      << " conflicts";
-  EXPECT_EQ(2, status->conflict_progress()->HierarchyConflictingItemsSize())
+
+  EXPECT_EQ(2, status->num_hierarchy_conflicts())
       << "All updates with an unknown ancestors should be in conflict";
-  EXPECT_EQ(0, status->update_progress()->SuccessfullyAppliedUpdateCount())
+  EXPECT_EQ(0, status->num_updates_applied())
       << "No item with an unknown ancestor should be applied";
 }
 
@@ -352,14 +312,10 @@ TEST_F(ApplyUpdatesCommandTest, ItemsBothKnownAndUnknown) {
   apply_updates_command_.ExecuteImpl(session());
 
   sessions::StatusController* status = session()->mutable_status_controller();
-  sessions::ScopedModelSafeGroupRestriction r(status, GROUP_UI);
-  ASSERT_TRUE(status->update_progress());
-  EXPECT_EQ(6, status->update_progress()->AppliedUpdatesSize())
-      << "All updates should have been attempted";
-  ASSERT_TRUE(status->conflict_progress());
-  EXPECT_EQ(2, status->conflict_progress()->HierarchyConflictingItemsSize())
+
+  EXPECT_EQ(2, status->num_hierarchy_conflicts())
       << "The updates with unknown ancestors should be in conflict";
-  EXPECT_EQ(4, status->update_progress()->SuccessfullyAppliedUpdateCount())
+  EXPECT_EQ(4, status->num_updates_applied())
       << "The updates with known ancestors should be successfully applied";
 }
 
@@ -388,14 +344,8 @@ TEST_F(ApplyUpdatesCommandTest, DecryptablePassword) {
   apply_updates_command_.ExecuteImpl(session());
 
   sessions::StatusController* status = session()->mutable_status_controller();
-  sessions::ScopedModelSafeGroupRestriction r(status, GROUP_PASSWORD);
-  ASSERT_TRUE(status->update_progress());
-  EXPECT_EQ(1, status->update_progress()->AppliedUpdatesSize())
-      << "All updates should have been attempted";
-  ASSERT_TRUE(status->conflict_progress());
-  EXPECT_EQ(0, status->conflict_progress()->SimpleConflictingItemsSize())
-      << "No update should be in conflict because they're all decryptable";
-  EXPECT_EQ(1, status->update_progress()->SuccessfullyAppliedUpdateCount())
+
+  EXPECT_EQ(1, status->num_updates_applied())
       << "The updates that can be decrypted should be applied";
 }
 
@@ -416,39 +366,10 @@ TEST_F(ApplyUpdatesCommandTest, UndecryptableData) {
   apply_updates_command_.ExecuteImpl(session());
 
   sessions::StatusController* status = session()->mutable_status_controller();
-  EXPECT_TRUE(status->HasConflictingUpdates())
-    << "Updates that can't be decrypted should trigger the syncer to have "
-    << "conflicting updates.";
-  {
-    sessions::ScopedModelSafeGroupRestriction r(status, GROUP_UI);
-    ASSERT_TRUE(status->update_progress());
-    EXPECT_EQ(2, status->update_progress()->AppliedUpdatesSize())
-        << "All updates should have been attempted";
-    ASSERT_TRUE(status->conflict_progress());
-    EXPECT_EQ(0, status->conflict_progress()->SimpleConflictingItemsSize())
-        << "The updates that can't be decrypted should not be in regular "
-        << "conflict";
-    EXPECT_EQ(2, status->conflict_progress()->EncryptionConflictingItemsSize())
-        << "The updates that can't be decrypted should be in encryption "
-        << "conflict";
-    EXPECT_EQ(0, status->update_progress()->SuccessfullyAppliedUpdateCount())
-        << "No update that can't be decrypted should be applied";
-  }
-  {
-    sessions::ScopedModelSafeGroupRestriction r(status, GROUP_PASSWORD);
-    ASSERT_TRUE(status->update_progress());
-    EXPECT_EQ(1, status->update_progress()->AppliedUpdatesSize())
-        << "All updates should have been attempted";
-    ASSERT_TRUE(status->conflict_progress());
-    EXPECT_EQ(0, status->conflict_progress()->SimpleConflictingItemsSize())
-        << "The updates that can't be decrypted should not be in regular "
-        << "conflict";
-    EXPECT_EQ(1, status->conflict_progress()->EncryptionConflictingItemsSize())
-        << "The updates that can't be decrypted should be in encryption "
-        << "conflict";
-    EXPECT_EQ(0, status->update_progress()->SuccessfullyAppliedUpdateCount())
-        << "No update that can't be decrypted should be applied";
-  }
+  EXPECT_EQ(3, status->num_encryption_conflicts())
+      << "Updates that can't be decrypted should be in encryption conflict";
+  EXPECT_EQ(0, status->num_updates_applied())
+      << "No update that can't be decrypted should be applied";
 }
 
 TEST_F(ApplyUpdatesCommandTest, SomeUndecryptablePassword) {
@@ -489,22 +410,11 @@ TEST_F(ApplyUpdatesCommandTest, SomeUndecryptablePassword) {
   apply_updates_command_.ExecuteImpl(session());
 
   sessions::StatusController* status = session()->mutable_status_controller();
-  EXPECT_TRUE(status->HasConflictingUpdates())
-    << "Updates that can't be decrypted should trigger the syncer to have "
-    << "conflicting updates.";
   {
-    sessions::ScopedModelSafeGroupRestriction r(status, GROUP_PASSWORD);
-    ASSERT_TRUE(status->update_progress());
-    EXPECT_EQ(2, status->update_progress()->AppliedUpdatesSize())
-        << "All updates should have been attempted";
-    ASSERT_TRUE(status->conflict_progress());
-    EXPECT_EQ(0, status->conflict_progress()->SimpleConflictingItemsSize())
-        << "The updates that can't be decrypted should not be in regular "
-        << "conflict";
-    EXPECT_EQ(1, status->conflict_progress()->EncryptionConflictingItemsSize())
+    EXPECT_EQ(1, status->num_encryption_conflicts())
         << "The updates that can't be decrypted should be in encryption "
         << "conflict";
-    EXPECT_EQ(1, status->update_progress()->SuccessfullyAppliedUpdateCount())
+    EXPECT_EQ(1, status->num_updates_applied())
         << "The undecryptable password update shouldn't be applied";
   }
 }