[Sync] Made some sync session member functions const

chrome/browser/sync/engine/apply_updates_command_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.
 
 #include <string>
 
 #include "base/format_macros.h"
 #include "base/location.h"
 #include "base/stringprintf.h"
 #include "chrome/browser/sync/engine/apply_updates_command.h"
@@ skipping 144 matching lines @@
   string root_server_id = syncable::GetNullId().GetServerId();
   CreateUnappliedNewItemWithParent("parent",
                                    DefaultBookmarkSpecifics(),
                                    root_server_id);
   CreateUnappliedNewItemWithParent("child",
                                    DefaultBookmarkSpecifics(),
                                    "parent");
 
   apply_updates_command_.ExecuteImpl(session());
 
-  sessions::StatusController* status = session()->status_controller();
+  sessions::StatusController* status = session()->mutable_status_controller();
 
   sessions::ScopedModelSafeGroupRestriction r(status, GROUP_UI);
-  EXPECT_EQ(2, status->update_progress().AppliedUpdatesSize())
+  ASSERT_TRUE(status->update_progress());
+  EXPECT_EQ(2, status->update_progress()->AppliedUpdatesSize())
       << "All updates should have been attempted";
-  EXPECT_EQ(0, status->conflict_progress().ConflictingItemsSize())
+  ASSERT_TRUE(status->conflict_progress());
+  EXPECT_EQ(0, status->conflict_progress()->ConflictingItemsSize())
       << "Simple update shouldn't result in conflicts";
-  EXPECT_EQ(2, status->update_progress().SuccessfullyAppliedUpdateCount())
+  EXPECT_EQ(2, status->update_progress()->SuccessfullyAppliedUpdateCount())
       << "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();
   CreateUnappliedNewItemWithParent("a_child_created_first",
                                    DefaultBookmarkSpecifics(),
                                    "parent");
   CreateUnappliedNewItemWithParent("x_child_created_first",
                                    DefaultBookmarkSpecifics(),
                                    "parent");
   CreateUnappliedNewItemWithParent("parent",
                                    DefaultBookmarkSpecifics(),
                                    root_server_id);
   CreateUnappliedNewItemWithParent("a_child_created_second",
                                    DefaultBookmarkSpecifics(),
                                    "parent");
   CreateUnappliedNewItemWithParent("x_child_created_second",
                                    DefaultBookmarkSpecifics(),
                                    "parent");
 
   apply_updates_command_.ExecuteImpl(session());
 
-  sessions::StatusController* status = session()->status_controller();
+  sessions::StatusController* status = session()->mutable_status_controller();
   sessions::ScopedModelSafeGroupRestriction r(status, GROUP_UI);
-  EXPECT_EQ(5, status->update_progress().AppliedUpdatesSize())
+  ASSERT_TRUE(status->update_progress());
+  EXPECT_EQ(5, status->update_progress()->AppliedUpdatesSize())
       << "All updates should have been attempted";
-  EXPECT_EQ(0, status->conflict_progress().ConflictingItemsSize())
+  ASSERT_TRUE(status->conflict_progress());
+  EXPECT_EQ(0, status->conflict_progress()->ConflictingItemsSize())
       << "Simple update shouldn't result in conflicts, even if out-of-order";
-  EXPECT_EQ(5, status->update_progress().SuccessfullyAppliedUpdateCount())
+  EXPECT_EQ(5, status->update_progress()->SuccessfullyAppliedUpdateCount())
       << "All updates should have been successfully applied";
 }
 
 TEST_F(ApplyUpdatesCommandTest, NestedItemsWithUnknownParent) {
   // We shouldn't be able to do anything with either of these items.
   CreateUnappliedNewItemWithParent("some_item",
                                    DefaultBookmarkSpecifics(),
                                    "unknown_parent");
   CreateUnappliedNewItemWithParent("some_other_item",
                                    DefaultBookmarkSpecifics(),
                                    "some_item");
 
   apply_updates_command_.ExecuteImpl(session());
 
-  sessions::StatusController* status = session()->status_controller();
+  sessions::StatusController* status = session()->mutable_status_controller();
   sessions::ScopedModelSafeGroupRestriction r(status, GROUP_UI);
-  EXPECT_EQ(2, status->update_progress().AppliedUpdatesSize())
+  ASSERT_TRUE(status->update_progress());
+  EXPECT_EQ(2, status->update_progress()->AppliedUpdatesSize())
       << "All updates should have been attempted";
-  EXPECT_EQ(2, status->conflict_progress().ConflictingItemsSize())
+  ASSERT_TRUE(status->conflict_progress());
+  EXPECT_EQ(2, status->conflict_progress()->ConflictingItemsSize())
       << "All updates with an unknown ancestors should be in conflict";
-  EXPECT_EQ(0, status->update_progress().SuccessfullyAppliedUpdateCount())
+  EXPECT_EQ(0, status->update_progress()->SuccessfullyAppliedUpdateCount())
       << "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();
   CreateUnappliedNewItemWithParent("first_unknown_item",
                                    DefaultBookmarkSpecifics(),
                                    "unknown_parent");
   CreateUnappliedNewItemWithParent("first_known_item",
                                    DefaultBookmarkSpecifics(),
                                    root_server_id);
   CreateUnappliedNewItemWithParent("second_unknown_item",
                                    DefaultBookmarkSpecifics(),
                                    "unknown_parent");
   CreateUnappliedNewItemWithParent("second_known_item",
                                    DefaultBookmarkSpecifics(),
                                    "first_known_item");
   CreateUnappliedNewItemWithParent("third_known_item",
                                    DefaultBookmarkSpecifics(),
                                    "fourth_known_item");
   CreateUnappliedNewItemWithParent("fourth_known_item",
                                    DefaultBookmarkSpecifics(),
                                    root_server_id);
 
   apply_updates_command_.ExecuteImpl(session());
 
-  sessions::StatusController* status = session()->status_controller();
+  sessions::StatusController* status = session()->mutable_status_controller();
   sessions::ScopedModelSafeGroupRestriction r(status, GROUP_UI);
-  EXPECT_EQ(6, status->update_progress().AppliedUpdatesSize())
+  ASSERT_TRUE(status->update_progress());
+  EXPECT_EQ(6, status->update_progress()->AppliedUpdatesSize())
       << "All updates should have been attempted";
-  EXPECT_EQ(2, status->conflict_progress().ConflictingItemsSize())
+  ASSERT_TRUE(status->conflict_progress());
+  EXPECT_EQ(2, status->conflict_progress()->ConflictingItemsSize())
       << "The updates with unknown ancestors should be in conflict";
-  EXPECT_EQ(4, status->update_progress().SuccessfullyAppliedUpdateCount())
+  EXPECT_EQ(4, status->update_progress()->SuccessfullyAppliedUpdateCount())
       << "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.
       ScopedDirLookup dir(syncdb()->manager(), syncdb()->name());
       ASSERT_TRUE(dir.good());
       ReadTransaction trans(FROM_HERE, dir);
       cryptographer =
           session()->context()->directory_manager()->GetCryptographer(&trans);
   }
 
   browser_sync::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.MutableExtension(sync_pb::password)->mutable_encrypted());
   CreateUnappliedNewItem("item", specifics, false);
 
   apply_updates_command_.ExecuteImpl(session());
 
-  sessions::StatusController* status = session()->status_controller();
+  sessions::StatusController* status = session()->mutable_status_controller();
   sessions::ScopedModelSafeGroupRestriction r(status, GROUP_PASSWORD);
-  EXPECT_EQ(1, status->update_progress().AppliedUpdatesSize())
+  ASSERT_TRUE(status->update_progress());
+  EXPECT_EQ(1, status->update_progress()->AppliedUpdatesSize())
       << "All updates should have been attempted";
-  EXPECT_EQ(0, status->conflict_progress().ConflictingItemsSize())
+  ASSERT_TRUE(status->conflict_progress());
+  EXPECT_EQ(0, status->conflict_progress()->ConflictingItemsSize())
       << "No update should be in conflict because they're all decryptable";
-  EXPECT_EQ(1, status->update_progress().SuccessfullyAppliedUpdateCount())
+  EXPECT_EQ(1, status->update_progress()->SuccessfullyAppliedUpdateCount())
       << "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();
   AddDefaultExtensionValue(syncable::BOOKMARKS, &encrypted_bookmark);
   string root_server_id = syncable::GetNullId().GetServerId();
   CreateUnappliedNewItemWithParent("folder",
                                    encrypted_bookmark,
                                    root_server_id);
   CreateUnappliedNewItem("item2", encrypted_bookmark, false);
   sync_pb::EntitySpecifics encrypted_password;
   encrypted_password.MutableExtension(sync_pb::password);
   CreateUnappliedNewItem("item3", encrypted_password, false);
 
   apply_updates_command_.ExecuteImpl(session());
 
-  sessions::StatusController* status = session()->status_controller();
+  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);
-    EXPECT_EQ(2, status->update_progress().AppliedUpdatesSize())
+    ASSERT_TRUE(status->update_progress());
+    EXPECT_EQ(2, status->update_progress()->AppliedUpdatesSize())
         << "All updates should have been attempted";
-    EXPECT_EQ(0, status->conflict_progress().ConflictingItemsSize())
+    ASSERT_TRUE(status->conflict_progress());
+    EXPECT_EQ(0, status->conflict_progress()->ConflictingItemsSize())
         << "The updates that can't be decrypted should not be in regular "
         << "conflict";
-    EXPECT_EQ(2, status->conflict_progress().NonblockingConflictingItemsSize())
+    EXPECT_EQ(2, status->conflict_progress()->NonblockingConflictingItemsSize())
         << "The updates that can't be decrypted should be in nonblocking "
         << "conflict";
-    EXPECT_EQ(0, status->update_progress().SuccessfullyAppliedUpdateCount())
+    EXPECT_EQ(0, status->update_progress()->SuccessfullyAppliedUpdateCount())
         << "No update that can't be decrypted should be applied";
   }
   {
     sessions::ScopedModelSafeGroupRestriction r(status, GROUP_PASSWORD);
-    EXPECT_EQ(1, status->update_progress().AppliedUpdatesSize())
+    ASSERT_TRUE(status->update_progress());
+    EXPECT_EQ(1, status->update_progress()->AppliedUpdatesSize())
         << "All updates should have been attempted";
-    EXPECT_EQ(0, status->conflict_progress().ConflictingItemsSize())
+  ASSERT_TRUE(status->conflict_progress());
+    EXPECT_EQ(0, status->conflict_progress()->ConflictingItemsSize())
         << "The updates that can't be decrypted should not be in regular "
         << "conflict";
-    EXPECT_EQ(1, status->conflict_progress().NonblockingConflictingItemsSize())
+    EXPECT_EQ(1, status->conflict_progress()->NonblockingConflictingItemsSize())
         << "The updates that can't be decrypted should be in nonblocking "
         << "conflict";
-    EXPECT_EQ(0, status->update_progress().SuccessfullyAppliedUpdateCount())
+    EXPECT_EQ(0, status->update_progress()->SuccessfullyAppliedUpdateCount())
         << "No update that can't be decrypted should be applied";
   }
 }
 
 TEST_F(ApplyUpdatesCommandTest, SomeUndecryptablePassword) {
   // Only decryptable password updates should be applied.
   {
     sync_pb::EntitySpecifics specifics;
     sync_pb::PasswordSpecificsData data;
     data.set_origin("http://example.com/1");
@@ skipping 22 matching lines @@
     sync_pb::PasswordSpecificsData data;
     data.set_origin("http://example.com/2");
 
     cryptographer.Encrypt(data,
         specifics.MutableExtension(sync_pb::password)->mutable_encrypted());
     CreateUnappliedNewItem("item2", specifics, false);
   }
 
   apply_updates_command_.ExecuteImpl(session());
 
-  sessions::StatusController* status = session()->status_controller();
+  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);
-    EXPECT_EQ(2, status->update_progress().AppliedUpdatesSize())
+    ASSERT_TRUE(status->update_progress());
+    EXPECT_EQ(2, status->update_progress()->AppliedUpdatesSize())
         << "All updates should have been attempted";
-    EXPECT_EQ(0, status->conflict_progress().ConflictingItemsSize())
+    ASSERT_TRUE(status->conflict_progress());
+    EXPECT_EQ(0, status->conflict_progress()->ConflictingItemsSize())
         << "The updates that can't be decrypted should not be in regular "
         << "conflict";
-    EXPECT_EQ(1, status->conflict_progress().NonblockingConflictingItemsSize())
+    EXPECT_EQ(1, status->conflict_progress()->NonblockingConflictingItemsSize())
         << "The updates that can't be decrypted should be in nonblocking "
         << "conflict";
-    EXPECT_EQ(1, status->update_progress().SuccessfullyAppliedUpdateCount())
+    EXPECT_EQ(1, status->update_progress()->SuccessfullyAppliedUpdateCount())
         << "The undecryptable password update shouldn't be applied";
   }
 }
 
 TEST_F(ApplyUpdatesCommandTest, NigoriUpdate) {
   // Storing the cryptographer separately is bad, but for this test we
   // know it's safe.
   Cryptographer* cryptographer;
   syncable::ModelTypeSet encrypted_types;
   encrypted_types.insert(syncable::PASSWORDS);
@@ skipping 17 matching lines @@
       specifics.MutableExtension(sync_pb::nigori);
   other_cryptographer.GetKeys(nigori->mutable_encrypted());
   nigori->set_encrypt_bookmarks(true);
   encrypted_types.insert(syncable::BOOKMARKS);
   CreateUnappliedNewItem(syncable::ModelTypeToRootTag(syncable::NIGORI),
                          specifics, true);
   EXPECT_FALSE(cryptographer->has_pending_keys());
 
   apply_updates_command_.ExecuteImpl(session());
 
-  sessions::StatusController* status = session()->status_controller();
+  sessions::StatusController* status = session()->mutable_status_controller();
   sessions::ScopedModelSafeGroupRestriction r(status, GROUP_PASSIVE);
-  EXPECT_EQ(1, status->update_progress().AppliedUpdatesSize())
+  ASSERT_TRUE(status->update_progress());
+  EXPECT_EQ(1, status->update_progress()->AppliedUpdatesSize())
       << "All updates should have been attempted";
-  EXPECT_EQ(0, status->conflict_progress().ConflictingItemsSize())
+  ASSERT_TRUE(status->conflict_progress());
+  EXPECT_EQ(0, status->conflict_progress()->ConflictingItemsSize())
       << "The nigori update shouldn't be in conflict";
-  EXPECT_EQ(1, status->update_progress().SuccessfullyAppliedUpdateCount())
+  EXPECT_EQ(1, status->update_progress()->SuccessfullyAppliedUpdateCount())
       << "The nigori update should be applied";
 
   EXPECT_FALSE(cryptographer->is_ready());
   EXPECT_TRUE(cryptographer->has_pending_keys());
   EXPECT_EQ(GetAllRealModelTypes(), cryptographer->GetEncryptedTypes());
 }
 
 TEST_F(ApplyUpdatesCommandTest, NigoriUpdateForDisabledTypes) {
   // Storing the cryptographer separately is bad, but for this test we
   // know it's safe.
@@ skipping 22 matching lines @@
   nigori->set_encrypt_sessions(true);
   nigori->set_encrypt_themes(true);
   encrypted_types.insert(syncable::SESSIONS);
   encrypted_types.insert(syncable::THEMES);
   CreateUnappliedNewItem(syncable::ModelTypeToRootTag(syncable::NIGORI),
                          specifics, true);
   EXPECT_FALSE(cryptographer->has_pending_keys());
 
   apply_updates_command_.ExecuteImpl(session());
 
-  sessions::StatusController* status = session()->status_controller();
+  sessions::StatusController* status = session()->mutable_status_controller();
   sessions::ScopedModelSafeGroupRestriction r(status, GROUP_PASSIVE);
-  EXPECT_EQ(1, status->update_progress().AppliedUpdatesSize())
+  ASSERT_TRUE(status->update_progress());
+  EXPECT_EQ(1, status->update_progress()->AppliedUpdatesSize())
       << "All updates should have been attempted";
-  EXPECT_EQ(0, status->conflict_progress().ConflictingItemsSize())
+  ASSERT_TRUE(status->conflict_progress());
+  EXPECT_EQ(0, status->conflict_progress()->ConflictingItemsSize())
       << "The nigori update shouldn't be in conflict";
-  EXPECT_EQ(1, status->update_progress().SuccessfullyAppliedUpdateCount())
+  EXPECT_EQ(1, status->update_progress()->SuccessfullyAppliedUpdateCount())
       << "The nigori update should be applied";
 
   EXPECT_FALSE(cryptographer->is_ready());
   EXPECT_TRUE(cryptographer->has_pending_keys());
   EXPECT_EQ(GetAllRealModelTypes(), cryptographer->GetEncryptedTypes());
 }
 
 TEST_F(ApplyUpdatesCommandTest, EncryptUnsyncedChanges) {
   // Storing the cryptographer separately is bad, but for this test we
   // know it's safe.
@@ skipping 58 matching lines @@
     ReadTransaction trans(FROM_HERE, dir);
     EXPECT_FALSE(VerifyUnsyncedChangesAreEncrypted(&trans, encrypted_types));
 
     Syncer::UnsyncedMetaHandles handles;
     SyncerUtil::GetUnsyncedEntries(&trans, &handles);
     EXPECT_EQ(2*batch_s+1, handles.size());
   }
 
   apply_updates_command_.ExecuteImpl(session());
 
-  sessions::StatusController* status = session()->status_controller();
+  sessions::StatusController* status = session()->mutable_status_controller();
   sessions::ScopedModelSafeGroupRestriction r(status, GROUP_PASSIVE);
-  EXPECT_EQ(1, status->update_progress().AppliedUpdatesSize())
+  ASSERT_TRUE(status->update_progress());
+  EXPECT_EQ(1, status->update_progress()->AppliedUpdatesSize())
       << "All updates should have been attempted";
-  EXPECT_EQ(0, status->conflict_progress().ConflictingItemsSize())
+  ASSERT_TRUE(status->conflict_progress());
+  EXPECT_EQ(0, status->conflict_progress()->ConflictingItemsSize())
       << "No updates should be in conflict";
-  EXPECT_EQ(0, status->conflict_progress().NonblockingConflictingItemsSize())
+  EXPECT_EQ(0, status->conflict_progress()->NonblockingConflictingItemsSize())
       << "No updates should be in conflict";
-  EXPECT_EQ(1, status->update_progress().SuccessfullyAppliedUpdateCount())
+  EXPECT_EQ(1, status->update_progress()->SuccessfullyAppliedUpdateCount())
       << "The nigori update should be applied";
   EXPECT_FALSE(cryptographer->has_pending_keys());
   EXPECT_TRUE(cryptographer->is_ready());
   {
     ScopedDirLookup dir(syncdb()->manager(), syncdb()->name());
     ASSERT_TRUE(dir.good());
     ReadTransaction trans(FROM_HERE, dir);
 
     // If ProcessUnsyncedChangesForEncryption worked, all our unsynced changes
     // should be encrypted now.
@@ skipping 71 matching lines @@
     ASSERT_TRUE(dir.good());
     ReadTransaction trans(FROM_HERE, dir);
     EXPECT_FALSE(VerifyUnsyncedChangesAreEncrypted(&trans, encrypted_types));
     Syncer::UnsyncedMetaHandles handles;
     SyncerUtil::GetUnsyncedEntries(&trans, &handles);
     EXPECT_EQ(2*batch_s+1, handles.size());
   }
 
   apply_updates_command_.ExecuteImpl(session());
 
-  sessions::StatusController* status = session()->status_controller();
+  sessions::StatusController* status = session()->mutable_status_controller();
   sessions::ScopedModelSafeGroupRestriction r(status, GROUP_PASSIVE);
-  EXPECT_EQ(1, status->update_progress().AppliedUpdatesSize())
+  ASSERT_TRUE(status->update_progress());
+  EXPECT_EQ(1, status->update_progress()->AppliedUpdatesSize())
       << "All updates should have been attempted";
-  EXPECT_EQ(0, status->conflict_progress().ConflictingItemsSize())
+  ASSERT_TRUE(status->conflict_progress());
+  EXPECT_EQ(0, status->conflict_progress()->ConflictingItemsSize())
       << "The unsynced changes don't trigger a blocking conflict with the "
       << "nigori update.";
-  EXPECT_EQ(1, status->conflict_progress().NonblockingConflictingItemsSize())
+  EXPECT_EQ(1, status->conflict_progress()->NonblockingConflictingItemsSize())
       << "The unsynced changes trigger a non-blocking conflict with the "
       << "nigori update.";
-  EXPECT_EQ(0, status->update_progress().SuccessfullyAppliedUpdateCount())
+  EXPECT_EQ(0, status->update_progress()->SuccessfullyAppliedUpdateCount())
       << "The nigori update should not be applied";
   EXPECT_FALSE(cryptographer->is_ready());
   EXPECT_TRUE(cryptographer->has_pending_keys());
   {
     // Ensure the unsynced nodes are still not encrypted.
     ScopedDirLookup dir(syncdb()->manager(), syncdb()->name());
     ASSERT_TRUE(dir.good());
     ReadTransaction trans(FROM_HERE, dir);
 
     // Since we're in conflict, the specifics don't reflect the unapplied
     // changes.
     EXPECT_FALSE(VerifyUnsyncedChangesAreEncrypted(&trans, encrypted_types));
     encrypted_types.clear();
     encrypted_types.insert(syncable::PASSWORDS);
     encrypted_types.insert(syncable::BOOKMARKS);
     EXPECT_EQ(GetAllRealModelTypes(), cryptographer->GetEncryptedTypes());
 
     Syncer::UnsyncedMetaHandles handles;
     SyncerUtil::GetUnsyncedEntries(&trans, &handles);
     EXPECT_EQ(2*batch_s+1, handles.size());
   }
 }
 
 }  // namespace browser_sync