sync: Remove UpdateProgress and related code

sync/engine/apply_updates_command_unittest.cc

 // Copyright (c) 2012 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 <string>
 
 #include "base/location.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/stringprintf.h"
 #include "sync/engine/apply_updates_command.h"
@@ skipping 63 matching lines @@
   entry_factory_->CreateUnappliedNewItemWithParent("parent",
                                                    DefaultBookmarkSpecifics(),
                                                    root_server_id);
   entry_factory_->CreateUnappliedNewItemWithParent("child",
                                                    DefaultBookmarkSpecifics(),
                                                    "parent");
 
   ExpectGroupToChange(apply_updates_command_, GROUP_UI);
   apply_updates_command_.ExecuteImpl(session());
 
-  sessions::StatusController* status = session()->mutable_status_controller();
-
-  EXPECT_EQ(0, status->num_simple_conflicts())
+  const sessions::StatusController& status = session()->status_controller();
+  EXPECT_EQ(0, status.num_simple_conflicts())
       << "Simple update shouldn't result in conflicts";
-  EXPECT_EQ(0, status->num_encryption_conflicts())
+  EXPECT_EQ(0, status.num_encryption_conflicts())
       << "Simple update shouldn't result in conflicts";
-  EXPECT_EQ(0, status->num_hierarchy_conflicts())
+  EXPECT_EQ(0, status.num_hierarchy_conflicts())
       << "Simple update shouldn't result in conflicts";
-  sessions::ScopedModelSafeGroupRestriction r(status, GROUP_UI);
-  ASSERT_TRUE(status->update_progress());
-  EXPECT_EQ(2, status->update_progress()->AppliedUpdatesSize())
-      << "All updates should have been attempted";
-  EXPECT_EQ(2, status->update_progress()->SuccessfullyAppliedUpdateCount())
+  EXPECT_EQ(2, status.num_updates_applied())
       << "All items should have been successfully applied";
 }
 
 TEST_F(ApplyUpdatesCommandTest, UpdateWithChildrenBeforeParents) {
   // Set a bunch of updates which are difficult to apply in the order
   // they're received due to dependencies on other unseen items.
   string root_server_id = syncable::GetNullId().GetServerId();
   entry_factory_->CreateUnappliedNewItemWithParent(
       "a_child_created_first", DefaultBookmarkSpecifics(), "parent");
   entry_factory_->CreateUnappliedNewItemWithParent(
       "x_child_created_first", DefaultBookmarkSpecifics(), "parent");
   entry_factory_->CreateUnappliedNewItemWithParent(
       "parent", DefaultBookmarkSpecifics(), root_server_id);
   entry_factory_->CreateUnappliedNewItemWithParent(
       "a_child_created_second", DefaultBookmarkSpecifics(), "parent");
   entry_factory_->CreateUnappliedNewItemWithParent(
       "x_child_created_second", DefaultBookmarkSpecifics(), "parent");
 
   ExpectGroupToChange(apply_updates_command_, GROUP_UI);
   apply_updates_command_.ExecuteImpl(session());
 
-  sessions::StatusController* status = session()->mutable_status_controller();
-  EXPECT_EQ(0, status->num_simple_conflicts())
+  const sessions::StatusController& status = session()->status_controller();
+  EXPECT_EQ(0, status.num_simple_conflicts())
       << "Simple update shouldn't result in conflicts, even if out-of-order";
-  sessions::ScopedModelSafeGroupRestriction r(status, GROUP_UI);
-  ASSERT_TRUE(status->update_progress());
-  EXPECT_EQ(5, status->update_progress()->AppliedUpdatesSize())
-      << "All updates should have been attempted";
-  EXPECT_EQ(5, status->update_progress()->SuccessfullyAppliedUpdateCount())
+  EXPECT_EQ(5, status.num_updates_applied())
       << "All updates should have been successfully applied";
 }
 
 // Runs the ApplyUpdatesCommand on an item that has both local and remote
 // modifications (IS_UNSYNCED and IS_UNAPPLIED_UPDATE).  We expect the command
 // to detect that this update can't be applied because it is in a CONFLICT
 // state.
 TEST_F(ApplyUpdatesCommandTest, SimpleConflict) {
   entry_factory_->CreateUnappliedAndUnsyncedItem("item", BOOKMARKS);
 
   ExpectGroupToChange(apply_updates_command_, GROUP_UI);
   apply_updates_command_.ExecuteImpl(session());
 
-  sessions::StatusController* status = session()->mutable_status_controller();
-  EXPECT_EQ(1, status->num_simple_conflicts())
+  const sessions::StatusController& status = session()->status_controller();
+  EXPECT_EQ(1, status.num_simple_conflicts())
       << "Unsynced and unapplied item should be a simple conflict";
 }
 
 // Runs the ApplyUpdatesCommand on an item that has both local and remote
 // modifications *and* the remote modification cannot be applied without
 // violating the tree constraints.  We expect the command to detect that this
 // update can't be applied and that this situation can't be resolved with the
 // simple conflict processing logic; it is in a CONFLICT_HIERARCHY state.
 TEST_F(ApplyUpdatesCommandTest, HierarchyAndSimpleConflict) {
   // Create a simply-conflicting item.  It will start with valid parent ids.
   int64 handle = entry_factory_->CreateUnappliedAndUnsyncedItem(
       "orphaned_by_server", BOOKMARKS);
   {
     // Manually set the SERVER_PARENT_ID to bad value.
     // A bad parent indicates a hierarchy conflict.
     WriteTransaction trans(FROM_HERE, UNITTEST, directory());
     MutableEntry entry(&trans, syncable::GET_BY_HANDLE, handle);
     ASSERT_TRUE(entry.good());
 
     entry.Put(syncable::SERVER_PARENT_ID,
               TestIdFactory::MakeServer("bogus_parent"));
   }
 
   ExpectGroupToChange(apply_updates_command_, GROUP_UI);
   apply_updates_command_.ExecuteImpl(session());
 
-  sessions::StatusController* status = session()->mutable_status_controller();
+  const sessions::StatusController& status = session()->status_controller();
 
   // An update that is both a simple conflict and a hierarchy conflict should be
   // treated as a hierarchy conflict.
-  EXPECT_EQ(1, status->num_hierarchy_conflicts());
-  EXPECT_EQ(0, status->num_simple_conflicts());
-
-  sessions::ScopedModelSafeGroupRestriction r(status, GROUP_UI);
-  EXPECT_EQ(1, status->update_progress()->AppliedUpdatesSize());
+  EXPECT_EQ(1, status.num_hierarchy_conflicts());
+  EXPECT_EQ(0, status.num_simple_conflicts());
 }
 
 
 // Runs the ApplyUpdatesCommand on an item with remote modifications that would
 // create a directory loop if the update were applied.  We expect the command to
 // detect that this update can't be applied because it is in a
 // CONFLICT_HIERARCHY state.
 TEST_F(ApplyUpdatesCommandTest, HierarchyConflictDirectoryLoop) {
   // Item 'X' locally has parent of 'root'.  Server is updating it to have
   // parent of 'Y'.
@@ skipping 17 matching lines @@
       BOOKMARKS, NULL);
 
   // If the server's update were applied, we would have X be a child of Y, and Y
   // as a child of X.  That's a directory loop.  The UpdateApplicator should
   // prevent the update from being applied and note that this is a hierarchy
   // conflict.
 
   ExpectGroupToChange(apply_updates_command_, GROUP_UI);
   apply_updates_command_.ExecuteImpl(session());
 
-  sessions::StatusController* status = session()->mutable_status_controller();
+  const sessions::StatusController& status = session()->status_controller();
 
   // This should count as a hierarchy conflict.
-  EXPECT_EQ(1, status->num_hierarchy_conflicts());
-  EXPECT_EQ(0, status->num_simple_conflicts());
-
-  sessions::ScopedModelSafeGroupRestriction r(status, GROUP_UI);
-  EXPECT_EQ(1, status->update_progress()->AppliedUpdatesSize());
+  EXPECT_EQ(1, status.num_hierarchy_conflicts());
+  EXPECT_EQ(0, status.num_simple_conflicts());
 }
 
 // Runs the ApplyUpdatesCommand on a directory where the server sent us an
 // update to add a child to a locally deleted (and unsynced) parent.  We expect
 // the command to not apply the update and to indicate the update is in a
 // CONFLICT_HIERARCHY state.
 TEST_F(ApplyUpdatesCommandTest, HierarchyConflictDeletedParent) {
   // Create a locally deleted parent item.
   int64 parent_handle;
   entry_factory_->CreateUnsyncedItem(
       Id::CreateFromServerId("parent"), TestIdFactory::root(),
       "parent", true, BOOKMARKS, &parent_handle);
   {
     WriteTransaction trans(FROM_HERE, UNITTEST, directory());
     MutableEntry entry(&trans, syncable::GET_BY_HANDLE, parent_handle);
     entry.Put(syncable::IS_DEL, true);
   }
 
   // Create an incoming child from the server.
   entry_factory_->CreateUnappliedNewItemWithParent(
       "child", DefaultBookmarkSpecifics(), "parent");
 
   // The server's update may seem valid to some other client, but on this client
   // that new item's parent no longer exists.  The update should not be applied
   // and the update applicator should indicate this is a hierarchy conflict.
 
   ExpectGroupToChange(apply_updates_command_, GROUP_UI);
   apply_updates_command_.ExecuteImpl(session());
 
-  sessions::StatusController* status = session()->mutable_status_controller();
-  EXPECT_EQ(1, status->num_hierarchy_conflicts());
-  EXPECT_EQ(0, status->num_simple_conflicts());
+  const sessions::StatusController& status = session()->status_controller();
+  EXPECT_EQ(1, status.num_hierarchy_conflicts());
+  EXPECT_EQ(0, status.num_simple_conflicts());
 }
 
 // Runs the ApplyUpdatesCommand on a directory where the server is trying to
 // delete a folder that has a recently added (and unsynced) child.  We expect
 // the command to not apply the update because it is in a CONFLICT_HIERARCHY
 // state.
 TEST_F(ApplyUpdatesCommandTest, HierarchyConflictDeleteNonEmptyDirectory) {
   // Create a server-deleted directory.
   {
     // Create it as a child of root node.
@@ skipping 15 matching lines @@
   entry_factory_->CreateUnsyncedItem(
       TestIdFactory::MakeServer("child"), TestIdFactory::MakeServer("parent"),
       "child", false, BOOKMARKS, NULL);
 
   // The server's request to delete the directory must be ignored, otherwise our
   // unsynced new child would be orphaned.  This is a hierarchy conflict.
 
   ExpectGroupToChange(apply_updates_command_, GROUP_UI);
   apply_updates_command_.ExecuteImpl(session());
 
-  sessions::StatusController* status = session()->mutable_status_controller();
+  const sessions::StatusController& status = session()->status_controller();
   // This should count as a hierarchy conflict.
-  EXPECT_EQ(1, status->num_hierarchy_conflicts());
-  EXPECT_EQ(0, status->num_simple_conflicts());
+  EXPECT_EQ(1, status.num_hierarchy_conflicts());
+  EXPECT_EQ(0, status.num_simple_conflicts());
 }
 
 // Runs the ApplyUpdatesCommand on a server-created item that has a locally
 // unknown parent.  We expect the command to not apply the update because the
 // item is in a CONFLICT_HIERARCHY state.
 TEST_F(ApplyUpdatesCommandTest, HierarchyConflictUnknownParent) {
   // We shouldn't be able to do anything with either of these items.
   entry_factory_->CreateUnappliedNewItemWithParent(
       "some_item", DefaultBookmarkSpecifics(), "unknown_parent");
   entry_factory_->CreateUnappliedNewItemWithParent(
       "some_other_item", DefaultBookmarkSpecifics(), "some_item");
 
   ExpectGroupToChange(apply_updates_command_, GROUP_UI);
   apply_updates_command_.ExecuteImpl(session());
 
-  sessions::StatusController* status = session()->mutable_status_controller();
-
-  EXPECT_EQ(0, status->num_simple_conflicts())
+  const sessions::StatusController& status = session()->status_controller();
+  EXPECT_EQ(0, status.num_simple_conflicts())
       << "Updates with unknown parent should not be treated as 'simple'"
       << " conflicts";
-  EXPECT_EQ(2, status->num_hierarchy_conflicts())
+  EXPECT_EQ(2, status.num_hierarchy_conflicts())
       << "All updates with an unknown ancestors should be in conflict";
-
-  sessions::ScopedModelSafeGroupRestriction r(status, GROUP_UI);
-  ASSERT_TRUE(status->update_progress());
-  EXPECT_EQ(2, status->update_progress()->AppliedUpdatesSize())
-      << "All updates should have been attempted";
-  EXPECT_EQ(0, status->update_progress()->SuccessfullyAppliedUpdateCount())
+  EXPECT_EQ(0, status.num_updates_applied())
       << "No item with an unknown ancestor should be applied";
 }
 
 TEST_F(ApplyUpdatesCommandTest, ItemsBothKnownAndUnknown) {
   // See what happens when there's a mixture of good and bad updates.
   string root_server_id = syncable::GetNullId().GetServerId();
   entry_factory_->CreateUnappliedNewItemWithParent(
       "first_unknown_item", DefaultBookmarkSpecifics(), "unknown_parent");
   entry_factory_->CreateUnappliedNewItemWithParent(
       "first_known_item", DefaultBookmarkSpecifics(), root_server_id);
   entry_factory_->CreateUnappliedNewItemWithParent(
       "second_unknown_item", DefaultBookmarkSpecifics(), "unknown_parent");
   entry_factory_->CreateUnappliedNewItemWithParent(
       "second_known_item", DefaultBookmarkSpecifics(), "first_known_item");
   entry_factory_->CreateUnappliedNewItemWithParent(
       "third_known_item", DefaultBookmarkSpecifics(), "fourth_known_item");
   entry_factory_->CreateUnappliedNewItemWithParent(
       "fourth_known_item", DefaultBookmarkSpecifics(), root_server_id);
 
   ExpectGroupToChange(apply_updates_command_, GROUP_UI);
   apply_updates_command_.ExecuteImpl(session());
 
-  sessions::StatusController* status = session()->mutable_status_controller();
-
-  EXPECT_EQ(2, status->num_hierarchy_conflicts())
+  const sessions::StatusController& status = session()->status_controller();
+  EXPECT_EQ(2, status.num_hierarchy_conflicts())
       << "The updates with unknown ancestors should be in conflict";
-
-  sessions::ScopedModelSafeGroupRestriction r(status, GROUP_UI);
-  ASSERT_TRUE(status->update_progress());
-  EXPECT_EQ(6, status->update_progress()->AppliedUpdatesSize())
-      << "All updates should have been attempted";
-  EXPECT_EQ(4, status->update_progress()->SuccessfullyAppliedUpdateCount())
+  EXPECT_EQ(4, status.num_updates_applied())
       << "The updates with known ancestors should be successfully applied";
 }
 
 TEST_F(ApplyUpdatesCommandTest, DecryptablePassword) {
   // Decryptable password updates should be applied.
   Cryptographer* cryptographer;
   {
     // Storing the cryptographer separately is bad, but for this test we
     // know it's safe.
     syncable::ReadTransaction trans(FROM_HERE, directory());
     cryptographer = directory()->GetCryptographer(&trans);
   }
 
   KeyParams params = {"localhost", "dummy", "foobar"};
   cryptographer->AddKey(params);
 
   sync_pb::EntitySpecifics specifics;
   sync_pb::PasswordSpecificsData data;
   data.set_origin("http://example.com");
 
   cryptographer->Encrypt(data,
                          specifics.mutable_password()->mutable_encrypted());
   entry_factory_->CreateUnappliedNewItem("item", specifics, false);
 
   ExpectGroupToChange(apply_updates_command_, GROUP_PASSWORD);
   apply_updates_command_.ExecuteImpl(session());
 
-  sessions::StatusController* status = session()->mutable_status_controller();
-
-  EXPECT_EQ(0, status->num_simple_conflicts())
+  const sessions::StatusController& status = session()->status_controller();
+  EXPECT_EQ(0, status.num_simple_conflicts())
       << "No update should be in conflict because they're all decryptable";
-
-  sessions::ScopedModelSafeGroupRestriction r(status, GROUP_PASSWORD);
-  ASSERT_TRUE(status->update_progress());
-  EXPECT_EQ(1, status->update_progress()->AppliedUpdatesSize())
-      << "All updates should have been attempted";
-  EXPECT_EQ(1, status->update_progress()->SuccessfullyAppliedUpdateCount())
+  EXPECT_EQ(1, status.num_updates_applied())
       << "The updates that can be decrypted should be applied";
 }
 
 TEST_F(ApplyUpdatesCommandTest, UndecryptableData) {
   // Undecryptable updates should not be applied.
   sync_pb::EntitySpecifics encrypted_bookmark;
   encrypted_bookmark.mutable_encrypted();
   AddDefaultFieldValue(BOOKMARKS, &encrypted_bookmark);
   string root_server_id = syncable::GetNullId().GetServerId();
   entry_factory_->CreateUnappliedNewItemWithParent(
       "folder", encrypted_bookmark, root_server_id);
   entry_factory_->CreateUnappliedNewItem("item2", encrypted_bookmark, false);
   sync_pb::EntitySpecifics encrypted_password;
   encrypted_password.mutable_password();
   entry_factory_->CreateUnappliedNewItem("item3", encrypted_password, false);
 
   ExpectGroupsToChange(apply_updates_command_, GROUP_UI, GROUP_PASSWORD);
   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.";
-  EXPECT_EQ(0, status->num_simple_conflicts())
+  const sessions::StatusController& status = session()->status_controller();
+  EXPECT_TRUE(status.HasConflictingUpdates())
+      << "Updates that can't be decrypted should trigger the syncer to have "
+      << "conflicting updates.";
+  EXPECT_EQ(0, status.num_simple_conflicts())
       << "Updates that can't be decrypted should not be in regular conflict";
-  EXPECT_EQ(3, status->num_encryption_conflicts())
+  EXPECT_EQ(3, status.num_encryption_conflicts())
       << "Updates that can't be decrypted should be in encryption conflict";
-  {
-    sessions::ScopedModelSafeGroupRestriction r(status, GROUP_UI);
-    ASSERT_TRUE(status->update_progress());
-    EXPECT_EQ(2, status->update_progress()->AppliedUpdatesSize())
-        << "All updates should have been attempted";
-    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";
-    EXPECT_EQ(0, status->update_progress()->SuccessfullyAppliedUpdateCount())
-        << "No update that can't be decrypted should be applied";
-  }
+  EXPECT_EQ(0, status.num_updates_applied())
+      << "No update that can't be decrypted should be applied";
 }
 
 TEST_F(ApplyUpdatesCommandTest, SomeUndecryptablePassword) {
   Cryptographer* cryptographer;
   // Only decryptable password updates should be applied.
   {
     sync_pb::EntitySpecifics specifics;
     sync_pb::PasswordSpecificsData data;
     data.set_origin("http://example.com/1");
     {
@@ skipping 19 matching lines @@
     data.set_origin("http://example.com/2");
 
     other_cryptographer.Encrypt(data,
         specifics.mutable_password()->mutable_encrypted());
     entry_factory_->CreateUnappliedNewItem("item2", specifics, false);
   }
 
   ExpectGroupToChange(apply_updates_command_, GROUP_PASSWORD);
   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.";
-  {
-    EXPECT_EQ(0, status->num_simple_conflicts())
-        << "The updates that can't be decrypted should not be in regular "
-        << "conflict";
-    EXPECT_EQ(1, status->num_encryption_conflicts())
-        << "The updates that can't be decrypted should be in encryption "
-        << "conflict";
-
-    sessions::ScopedModelSafeGroupRestriction r(status, GROUP_PASSWORD);
-    ASSERT_TRUE(status->update_progress());
-    EXPECT_EQ(2, status->update_progress()->AppliedUpdatesSize())
-        << "All updates should have been attempted";
-    EXPECT_EQ(1, status->update_progress()->SuccessfullyAppliedUpdateCount())
-        << "The undecryptable password update shouldn't be applied";
-  }
+  const sessions::StatusController& status = session()->status_controller();
+  EXPECT_TRUE(status.HasConflictingUpdates())
+      << "Updates that can't be decrypted should trigger the syncer to have "
+      << "conflicting updates.";
+  EXPECT_EQ(0, status.num_simple_conflicts())
+      << "The updates that can't be decrypted should not be in regular "
+      << "conflict";
+  EXPECT_EQ(1, status.num_encryption_conflicts())
+      << "The updates that can't be decrypted should be in encryption "
+      << "conflict";
+  EXPECT_EQ(1, status.num_updates_applied())
+      << "The undecryptable password update shouldn't be applied";
 }
 
 }  // namespace syncer