[Sync] Made some sync session member functions const

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 195 matching lines @@
     context_->set_account_name(syncdb_.name());
     ASSERT_FALSE(context_->resolver());
     syncer_ = new Syncer();
     session_.reset(MakeSession());
 
     ScopedDirLookup dir(syncdb_.manager(), syncdb_.name());
     CHECK(dir.good());
     ReadTransaction trans(FROM_HERE, dir);
     syncable::Directory::ChildHandles children;
     dir->GetChildHandlesById(&trans, trans.root_id(), &children);
-    ASSERT_TRUE(0 == children.size());
+    ASSERT_EQ(0u, children.size());
     saw_syncer_event_ = false;
     root_id_ = TestIdFactory::root();
     parent_id_ = ids_.MakeServer("parent id");
     child_id_ = ids_.MakeServer("child id");
   }
 
   virtual void TearDown() {
     mock_server_.reset();
     delete syncer_;
     syncer_ = NULL;
@@ skipping 117 matching lines @@
           }
         }
         test++;
       }
     }
     LoopSyncShare();
     ASSERT_TRUE(expected_positions.size() ==
                 mock_server_->committed_ids().size());
     // If this test starts failing, be aware other sort orders could be valid.
     for (size_t i = 0; i < expected_positions.size(); ++i) {
-      EXPECT_TRUE(1 == expected_positions.count(i));
+      EXPECT_EQ(1u, expected_positions.count(i));
       EXPECT_TRUE(expected_positions[i] == mock_server_->committed_ids()[i]);
     }
   }
 
   void DoTruncationTest(const ScopedDirLookup& dir,
                         const vector<int64>& unsynced_handle_view,
                         const vector<syncable::Id>& expected_id_order) {
     // The expected order is "x", "b", "c", "e", truncated appropriately.
     for (size_t limit = expected_id_order.size() + 2; limit > 0; --limit) {
-      StatusController* status = session_->status_controller();
+      StatusController* status = session_->mutable_status_controller();
       WriteTransaction wtrans(FROM_HERE, UNITTEST, dir);
       ScopedSetSessionWriteTransaction set_trans(session_.get(), &wtrans);
       status->set_unsynced_handles(unsynced_handle_view);
 
       ModelSafeRoutingInfo routes;
       GetModelSafeRoutingInfo(&routes);
       GetCommitIdsCommand command(limit);
-      command.BuildCommitIds(session_->status_controller()->unsynced_handles(),
+      command.BuildCommitIds(
+          session_->status_controller().unsynced_handles(),
           session_->write_transaction(), routes);
       vector<syncable::Id> output =
           command.ordered_commit_set_->GetAllCommitIds();
       size_t truncated_size = std::min(limit, expected_id_order.size());
       ASSERT_TRUE(truncated_size == output.size());
       for (size_t i = 0; i < truncated_size; ++i) {
         ASSERT_TRUE(expected_id_order[i] == output[i])
             << "At index " << i << " with batch size limited to " << limit;
       }
       sessions::OrderedCommitSet::Projection proj;
@@ skipping 119 matching lines @@
 
 TEST_F(SyncerTest, TestCallGatherUnsyncedEntries) {
   ScopedDirLookup dir(syncdb_.manager(), syncdb_.name());
   ASSERT_TRUE(dir.good());
   {
     Syncer::UnsyncedMetaHandles handles;
     {
       ReadTransaction trans(FROM_HERE, dir);
       SyncerUtil::GetUnsyncedEntries(&trans, &handles);
     }
-    ASSERT_TRUE(0 == handles.size());
+    ASSERT_EQ(0u, handles.size());
   }
   // TODO(sync): When we can dynamically connect and disconnect the mock
   // ServerConnectionManager test disconnected GetUnsyncedEntries here. It's a
   // regression for a very old bug.
 }
 
 TEST_F(SyncerTest, GetCommitIdsCommandTruncates) {
   ScopedDirLookup dir(syncdb_.manager(), syncdb_.name());
   ASSERT_TRUE(dir.good());
   int64 handle_c = CreateUnsyncedDirectory("C", ids_.MakeLocal("c"));
@@ skipping 81 matching lines @@
     MutableEntry D(&wtrans, GET_BY_ID, ids_.FromNumber(4));
     ASSERT_TRUE(D.good());
     D.Put(IS_UNSYNCED, true);
     D.Put(SPECIFICS, encrypted_bookmark);
     D.Put(NON_UNIQUE_NAME, "not encrypted");
   }
   SyncShareAsDelegate();
   {
     // We remove any unready entries from the status controller's unsynced
     // handles, so this should remain 0 even though the entries didn't commit.
-    ASSERT_EQ(0U, session_->status_controller()->unsynced_handles().size());
+    ASSERT_EQ(0U, session_->status_controller().unsynced_handles().size());
     // Nothing should have commited due to bookmarks being encrypted and
     // the cryptographer having pending keys. A would have been resolved
     // as a simple conflict, but still be unsynced until the next sync cycle.
     ReadTransaction rtrans(FROM_HERE, dir);
     Entry entryA(&rtrans, syncable::GET_BY_ID, ids_.FromNumber(1));
     ASSERT_TRUE(entryA.good());
     EXPECT_TRUE(entryA.Get(IS_UNSYNCED));
     Entry entryB(&rtrans, syncable::GET_BY_ID, ids_.FromNumber(2));
     ASSERT_TRUE(entryB.good());
     EXPECT_TRUE(entryB.Get(IS_UNSYNCED));
     Entry entryC(&rtrans, syncable::GET_BY_ID, ids_.FromNumber(3));
     ASSERT_TRUE(entryC.good());
     EXPECT_TRUE(entryC.Get(IS_UNSYNCED));
     Entry entryD(&rtrans, syncable::GET_BY_ID, ids_.FromNumber(4));
     ASSERT_TRUE(entryD.good());
     EXPECT_TRUE(entryD.Get(IS_UNSYNCED));
 
     // Resolve the pending keys.
     syncdb_.manager()->GetCryptographer(&rtrans)->DecryptPendingKeys(
         key_params);
   }
   SyncShareAsDelegate();
   {
-    ASSERT_EQ(0U, session_->status_controller()->unsynced_handles().size());
+    ASSERT_EQ(0U, session_->status_controller().unsynced_handles().size());
     // All properly encrypted and non-conflicting items should commit. "A" was
     // conflicting, but last sync cycle resolved it as simple conflict, so on
     // this sync cycle it committed succesfullly.
     ReadTransaction rtrans(FROM_HERE, dir);
     // Committed successfully.
     Entry entryA(&rtrans, syncable::GET_BY_ID, ids_.FromNumber(1));
     ASSERT_TRUE(entryA.good());
     EXPECT_FALSE(entryA.Get(IS_UNSYNCED));
     EXPECT_FALSE(entryA.Get(IS_UNAPPLIED_UPDATE));
     // Committed successfully.
@@ skipping 19 matching lines @@
     ASSERT_TRUE(C.good());
     C.Put(SPECIFICS, encrypted_bookmark);
     C.Put(NON_UNIQUE_NAME, kEncryptedString);
     MutableEntry D(&wtrans, GET_BY_ID, ids_.FromNumber(4));
     ASSERT_TRUE(D.good());
     D.Put(SPECIFICS, encrypted_bookmark);
     D.Put(NON_UNIQUE_NAME, kEncryptedString);
   }
   SyncShareAsDelegate();
   {
-    ASSERT_EQ(0U, session_->status_controller()->unsynced_handles().size());
+    ASSERT_EQ(0U, session_->status_controller().unsynced_handles().size());
     // None should be unsynced anymore.
     ReadTransaction rtrans(FROM_HERE, dir);
     Entry entryA(&rtrans, syncable::GET_BY_ID, ids_.FromNumber(1));
     ASSERT_TRUE(entryA.good());
     EXPECT_FALSE(entryA.Get(IS_UNSYNCED));
     EXPECT_FALSE(entryA.Get(IS_UNAPPLIED_UPDATE));
     Entry entryB(&rtrans, syncable::GET_BY_ID, ids_.FromNumber(2));
     ASSERT_TRUE(entryB.good());
     EXPECT_FALSE(entryB.Get(IS_UNSYNCED));
     EXPECT_FALSE(entryB.Get(IS_UNAPPLIED_UPDATE));
     Entry entryC(&rtrans, syncable::GET_BY_ID, ids_.FromNumber(3));
     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));
   }
 }
 
 // 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_->status_controller();
+  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);
 
     sessions::OrderedCommitSet commit_set(session_->routing_info());
     GetCommitIdsCommand::CommitMetahandleIterator iterator(unsynced, &wtrans,
         &commit_set);
     EXPECT_FALSE(iterator.Valid());
@@ skipping 42 matching lines @@
     parent.Put(syncable::SPECIFICS, DefaultBookmarkSpecifics());
     parent.Put(syncable::BASE_VERSION, 1);
     parent.Put(syncable::ID, parent_id_);
     MutableEntry child(&wtrans, syncable::CREATE, parent_id_, "Pete");
     ASSERT_TRUE(child.good());
     child.Put(syncable::ID, child_id_);
     child.Put(syncable::BASE_VERSION, 1);
     WriteTestDataToEntry(&wtrans, &child);
   }
 
-  StatusController* status = session_->status_controller();
+  const StatusController& status = session_->status_controller();
   syncer_->SyncShare(session_.get(), SYNCER_BEGIN, SYNCER_END);
-  EXPECT_TRUE(2 == status->unsynced_handles().size());
-  ASSERT_TRUE(2 == mock_server_->committed_ids().size());
+  EXPECT_EQ(2u, status.unsynced_handles().size());
+  ASSERT_EQ(2u, mock_server_->committed_ids().size());
   // If this test starts failing, be aware other sort orders could be valid.
   EXPECT_TRUE(parent_id_ == mock_server_->committed_ids()[0]);
   EXPECT_TRUE(child_id_ == mock_server_->committed_ids()[1]);
   {
     ReadTransaction rt(FROM_HERE, dir);
     Entry entry(&rt, syncable::GET_BY_ID, child_id_);
     ASSERT_TRUE(entry.good());
     VerifyTestDataInEntry(&rt, &entry);
   }
 }
@@ skipping 24 matching lines @@
     parent2.Put(syncable::IS_DIR, true);
     parent2.Put(syncable::SPECIFICS, DefaultPreferencesSpecifics());
     parent2.Put(syncable::BASE_VERSION, 1);
     parent2.Put(syncable::ID, pref_node_id);
   }
 
   std::set<syncable::ModelType> types_to_purge;
   types_to_purge.insert(syncable::PREFERENCES);
   dir->PurgeEntriesWithTypeIn(types_to_purge);
 
-  StatusController* status = session_->status_controller();
+  const StatusController& status = session_->status_controller();
   syncer_->SyncShare(session_.get(), SYNCER_BEGIN, SYNCER_END);
-  EXPECT_EQ(2U, status->unsynced_handles().size());
+  EXPECT_EQ(2U, status.unsynced_handles().size());
   ASSERT_EQ(2U, mock_server_->committed_ids().size());
   // If this test starts failing, be aware other sort orders could be valid.
   EXPECT_TRUE(parent_id_ == mock_server_->committed_ids()[0]);
   EXPECT_TRUE(child_id_ == mock_server_->committed_ids()[1]);
   {
     ReadTransaction rt(FROM_HERE, dir);
     Entry entry(&rt, syncable::GET_BY_ID, child_id_);
     ASSERT_TRUE(entry.good());
     VerifyTestDataInEntry(&rt, &entry);
   }
@@ skipping 223 matching lines @@
       grandchild.Put(syncable::ID, ids_.FromNumber(105));
       grandchild.Put(syncable::IS_DEL, true);
       grandchild.Put(syncable::IS_DIR, false);
       grandchild.Put(syncable::SPECIFICS, DefaultBookmarkSpecifics());
       grandchild.Put(syncable::BASE_VERSION, 1);
       grandchild.Put(syncable::MTIME, now_minus_2h);
     }
   }
 
   syncer_->SyncShare(session_.get(), SYNCER_BEGIN, SYNCER_END);
-  EXPECT_TRUE(6 == session_->status_controller()->unsynced_handles().size());
-  ASSERT_TRUE(6 == mock_server_->committed_ids().size());
+  EXPECT_EQ(6u, session_->status_controller().unsynced_handles().size());
+  ASSERT_EQ(6u, mock_server_->committed_ids().size());
   // This test will NOT unroll deletes because SERVER_PARENT_ID is not set.
   // It will treat these like moves.
   vector<syncable::Id> commit_ids(mock_server_->committed_ids());
   EXPECT_TRUE(ids_.FromNumber(100) == commit_ids[0]);
   EXPECT_TRUE(ids_.FromNumber(101) == commit_ids[1]);
   EXPECT_TRUE(ids_.FromNumber(102) == commit_ids[2]);
   // We don't guarantee the delete orders in this test, only that they occur
   // at the end.
   std::sort(commit_ids.begin() + 3, commit_ids.end());
   EXPECT_TRUE(ids_.FromNumber(103) == commit_ids[3]);
@@ skipping 48 matching lines @@
     MutableEntry child(&wtrans, syncable::CREATE, child_id_, "B");
     ASSERT_TRUE(child.good());
     child.Put(syncable::IS_UNSYNCED, true);
     child.Put(syncable::IS_DIR, true);
     child.Put(syncable::SPECIFICS, DefaultBookmarkSpecifics());
     child.Put(syncable::ID, ids_.FromNumber(105));
     child.Put(syncable::BASE_VERSION, 1);
   }
 
   syncer_->SyncShare(session_.get(), SYNCER_BEGIN, SYNCER_END);
-  EXPECT_TRUE(6 == session_->status_controller()->unsynced_handles().size());
-  ASSERT_TRUE(6 == mock_server_->committed_ids().size());
+  EXPECT_EQ(6u, session_->status_controller().unsynced_handles().size());
+  ASSERT_EQ(6u, mock_server_->committed_ids().size());
   // If this test starts failing, be aware other sort orders could be valid.
   EXPECT_TRUE(parent_id_ == mock_server_->committed_ids()[0]);
   EXPECT_TRUE(child_id_ == mock_server_->committed_ids()[1]);
   EXPECT_TRUE(ids_.FromNumber(102) == mock_server_->committed_ids()[2]);
   EXPECT_TRUE(ids_.FromNumber(-103) == mock_server_->committed_ids()[3]);
   EXPECT_TRUE(ids_.FromNumber(-104) == mock_server_->committed_ids()[4]);
   EXPECT_TRUE(ids_.FromNumber(105) == mock_server_->committed_ids()[5]);
 }
 
 TEST_F(SyncerTest, TestCommitListOrderingCounterexample) {
@@ skipping 20 matching lines @@
     child2.Put(syncable::IS_UNSYNCED, true);
     child2.Put(syncable::SPECIFICS, DefaultBookmarkSpecifics());
     child2.Put(syncable::ID, child2_id);
 
     parent.Put(syncable::BASE_VERSION, 1);
     child1.Put(syncable::BASE_VERSION, 1);
     child2.Put(syncable::BASE_VERSION, 1);
   }
 
   syncer_->SyncShare(session_.get(), SYNCER_BEGIN, SYNCER_END);
-  EXPECT_TRUE(3 == session_->status_controller()->unsynced_handles().size());
-  ASSERT_TRUE(3 == mock_server_->committed_ids().size());
+  EXPECT_EQ(3u, session_->status_controller().unsynced_handles().size());
+  ASSERT_EQ(3u, mock_server_->committed_ids().size());
   // If this test starts failing, be aware other sort orders could be valid.
   EXPECT_TRUE(parent_id_ == mock_server_->committed_ids()[0]);
   EXPECT_TRUE(child_id_ == mock_server_->committed_ids()[1]);
   EXPECT_TRUE(child2_id == mock_server_->committed_ids()[2]);
 }
 
 TEST_F(SyncerTest, TestCommitListOrderingAndNewParent) {
   ScopedDirLookup dir(syncdb_.manager(), syncdb_.name());
   ASSERT_TRUE(dir.good());
 
@@ skipping 27 matching lines @@
     MutableEntry child(&wtrans, syncable::CREATE, parent2_id, child_name);
     ASSERT_TRUE(child.good());
     child.Put(syncable::IS_UNSYNCED, true);
     child.Put(syncable::IS_DIR, true);
     child.Put(syncable::SPECIFICS, DefaultBookmarkSpecifics());
     child.Put(syncable::ID, child_id);
     child.Put(syncable::BASE_VERSION, 1);
   }
 
   syncer_->SyncShare(session_.get(), SYNCER_BEGIN, SYNCER_END);
-  EXPECT_TRUE(3 == session_->status_controller()->unsynced_handles().size());
-  ASSERT_TRUE(3 == mock_server_->committed_ids().size());
+  EXPECT_EQ(3u, session_->status_controller().unsynced_handles().size());
+  ASSERT_EQ(3u, mock_server_->committed_ids().size());
   // If this test starts failing, be aware other sort orders could be valid.
   EXPECT_TRUE(parent_id_ == mock_server_->committed_ids()[0]);
   EXPECT_TRUE(parent2_id == mock_server_->committed_ids()[1]);
   EXPECT_TRUE(child_id == mock_server_->committed_ids()[2]);
   {
     ReadTransaction rtrans(FROM_HERE, dir);
     // Check that things committed correctly.
     Entry entry_1(&rtrans, syncable::GET_BY_ID, parent_id_);
     EXPECT_EQ(entry_1.Get(NON_UNIQUE_NAME), parent1_name);
     // Check that parent2 is a subfolder of parent1.
@@ skipping 52 matching lines @@
     MutableEntry child(&wtrans, syncable::CREATE, parent2_local_id, child_name);
     ASSERT_TRUE(child.good());
     child.Put(syncable::IS_UNSYNCED, true);
     child.Put(syncable::IS_DIR, true);
     child.Put(syncable::SPECIFICS, DefaultBookmarkSpecifics());
     child.Put(syncable::ID, child_local_id);
     meta_handle_b = child.Get(syncable::META_HANDLE);
   }
 
   syncer_->SyncShare(session_.get(), SYNCER_BEGIN, SYNCER_END);
-  EXPECT_TRUE(3 == session_->status_controller()->unsynced_handles().size());
-  ASSERT_TRUE(3 == mock_server_->committed_ids().size());
+  EXPECT_EQ(3u, session_->status_controller().unsynced_handles().size());
+  ASSERT_EQ(3u, mock_server_->committed_ids().size());
   // If this test starts failing, be aware other sort orders could be valid.
   EXPECT_TRUE(parent_id_ == mock_server_->committed_ids()[0]);
   EXPECT_TRUE(parent2_local_id == mock_server_->committed_ids()[1]);
   EXPECT_TRUE(child_local_id == mock_server_->committed_ids()[2]);
   {
     ReadTransaction rtrans(FROM_HERE, dir);
 
     Entry parent(&rtrans, syncable::GET_BY_ID,
                  GetOnlyEntryWithName(&rtrans, rtrans.root_id(), parent_name));
     ASSERT_TRUE(parent.good());
@@ skipping 32 matching lines @@
 
 TEST_F(SyncerTest, DontGetStuckWithTwoSameNames) {
   // We should not get stuck here because we get
   // two server updates with exactly the same name.
   ScopedDirLookup dir(syncdb_.manager(), syncdb_.name());
   ASSERT_TRUE(dir.good());
   mock_server_->AddUpdateDirectory(1, 0, "foo:", 1, 10);
   SyncShareAsDelegate();
   mock_server_->AddUpdateDirectory(2, 0, "foo:", 1, 20);
   SyncRepeatedlyToTriggerStuckSignal(session_.get());
-  EXPECT_FALSE(session_->status_controller()->syncer_status().syncer_stuck);
+  EXPECT_FALSE(session_->status_controller().syncer_status().syncer_stuck);
   saw_syncer_event_ = false;
 }
 
 TEST_F(SyncerTest, TestBasicUpdate) {
   ScopedDirLookup dir(syncdb_.manager(), syncdb_.name());
   ASSERT_TRUE(dir.good());
   string id = "some_id";
   string parent_id = "0";
   string name = "in_root";
   int64 version = 10;
@@ skipping 27 matching lines @@
   mock_server_->AddUpdateDirectory(2, 0, "in_root", 10, 10);
 
   // Unknown parent: should never be applied. "-80" is a legal server ID,
   // because any string sent by the server is a legal server ID in the sync
   // protocol, but it's not the ID of any item known to the client.  This
   // update should succeed validation, but be stuck in the unapplied state
   // until an item with the server ID "-80" arrives.
   mock_server_->AddUpdateDirectory(3, -80, "bad_parent", 10, 10);
 
   syncer_->SyncShare(session_.get(), SYNCER_BEGIN, SYNCER_END);
-  StatusController* status = session_->status_controller();
+  StatusController* status = session_->mutable_status_controller();
 
   // Id 3 should be in conflict now.
   EXPECT_EQ(1, status->TotalNumConflictingItems());
   {
     sessions::ScopedModelSafeGroupRestriction r(status, GROUP_PASSIVE);
-    EXPECT_EQ(1, status->conflict_progress().ConflictingItemsSize());
+    ASSERT_TRUE(status->conflict_progress());
+    EXPECT_EQ(1, status->conflict_progress()->ConflictingItemsSize());
   }
 
   // These entries will be used in the second set of updates.
   mock_server_->AddUpdateDirectory(4, 0, "newer_version", 20, 10);
   mock_server_->AddUpdateDirectory(5, 0, "circular1", 10, 10);
   mock_server_->AddUpdateDirectory(6, 5, "circular2", 10, 10);
   mock_server_->AddUpdateDirectory(9, 3, "bad_parent_child", 10, 10);
   mock_server_->AddUpdateDirectory(100, 9, "bad_parent_child2", 10, 10);
   mock_server_->AddUpdateDirectory(10, 0, "dir_to_bookmark", 10, 10);
 
   syncer_->SyncShare(session_.get(), SYNCER_BEGIN, SYNCER_END);
   // The three items with an unresolved parent should be unapplied (3, 9, 100).
   // The name clash should also still be in conflict.
   EXPECT_EQ(3, status->TotalNumConflictingItems());
   {
     sessions::ScopedModelSafeGroupRestriction r(status, GROUP_PASSIVE);
-    EXPECT_EQ(3, status->conflict_progress().ConflictingItemsSize());
+    ASSERT_TRUE(status->conflict_progress());
+    EXPECT_EQ(3, status->conflict_progress()->ConflictingItemsSize());
   }
 
   {
     WriteTransaction trans(FROM_HERE, UNITTEST, dir);
     // Even though it has the same name, it should work.
     Entry name_clash(&trans, GET_BY_ID, ids_.FromNumber(2));
     ASSERT_TRUE(name_clash.good());
     EXPECT_FALSE(name_clash.Get(IS_UNAPPLIED_UPDATE))
         << "Duplicate name SHOULD be OK.";
 
@@ skipping 25 matching lines @@
 
   // Version number older than last known: should fail verify & be dropped.
   mock_server_->AddUpdateDirectory(4, 0, "old_version", 10, 10);
   syncer_->SyncShare(session_.get(), SYNCER_BEGIN, SYNCER_END);
   {
     ReadTransaction trans(FROM_HERE, dir);
 
     Entry still_a_dir(&trans, GET_BY_ID, ids_.FromNumber(10));
     ASSERT_TRUE(still_a_dir.good());
     EXPECT_FALSE(still_a_dir.Get(IS_UNAPPLIED_UPDATE));
-    EXPECT_TRUE(10 == still_a_dir.Get(BASE_VERSION));
-    EXPECT_TRUE(10 == still_a_dir.Get(SERVER_VERSION));
+    EXPECT_EQ(10u, still_a_dir.Get(BASE_VERSION));
+    EXPECT_EQ(10u, still_a_dir.Get(SERVER_VERSION));
     EXPECT_TRUE(still_a_dir.Get(IS_DIR));
 
     Entry rename(&trans, GET_BY_ID, ids_.FromNumber(1));
     ASSERT_TRUE(rename.good());
     EXPECT_EQ(root, rename.Get(PARENT_ID));
     EXPECT_EQ("new_name", rename.Get(NON_UNIQUE_NAME));
     EXPECT_FALSE(rename.Get(IS_UNAPPLIED_UPDATE));
     EXPECT_TRUE(ids_.FromNumber(1) == rename.Get(ID));
-    EXPECT_TRUE(20 == rename.Get(BASE_VERSION));
+    EXPECT_EQ(20u, rename.Get(BASE_VERSION));
 
     Entry name_clash(&trans, GET_BY_ID, ids_.FromNumber(2));
     ASSERT_TRUE(name_clash.good());
     EXPECT_EQ(root, name_clash.Get(PARENT_ID));
     EXPECT_TRUE(ids_.FromNumber(2) == name_clash.Get(ID));
-    EXPECT_TRUE(10 == name_clash.Get(BASE_VERSION));
+    EXPECT_EQ(10u, name_clash.Get(BASE_VERSION));
     EXPECT_EQ("in_root", name_clash.Get(NON_UNIQUE_NAME));
 
     Entry ignored_old_version(&trans, GET_BY_ID, ids_.FromNumber(4));
     ASSERT_TRUE(ignored_old_version.good());
     EXPECT_TRUE(
         ignored_old_version.Get(NON_UNIQUE_NAME) == "newer_version");
     EXPECT_FALSE(ignored_old_version.Get(IS_UNAPPLIED_UPDATE));
-    EXPECT_TRUE(20 == ignored_old_version.Get(BASE_VERSION));
+    EXPECT_EQ(20u, ignored_old_version.Get(BASE_VERSION));
 
     Entry circular_parent_issue(&trans, GET_BY_ID, ids_.FromNumber(5));
     ASSERT_TRUE(circular_parent_issue.good());
     EXPECT_TRUE(circular_parent_issue.Get(IS_UNAPPLIED_UPDATE))
         << "circular move should be in conflict";
     EXPECT_TRUE(circular_parent_issue.Get(PARENT_ID) == root_id_);
     EXPECT_TRUE(circular_parent_issue.Get(SERVER_PARENT_ID) ==
                 ids_.FromNumber(6));
-    EXPECT_TRUE(10 == circular_parent_issue.Get(BASE_VERSION));
+    EXPECT_EQ(10u, circular_parent_issue.Get(BASE_VERSION));
 
     Entry circular_parent_target(&trans, GET_BY_ID, ids_.FromNumber(6));
     ASSERT_TRUE(circular_parent_target.good());
     EXPECT_FALSE(circular_parent_target.Get(IS_UNAPPLIED_UPDATE));
     EXPECT_TRUE(circular_parent_issue.Get(ID) ==
         circular_parent_target.Get(PARENT_ID));
-    EXPECT_TRUE(10 == circular_parent_target.Get(BASE_VERSION));
+    EXPECT_EQ(10u, circular_parent_target.Get(BASE_VERSION));
   }
 
   EXPECT_FALSE(saw_syncer_event_);
   EXPECT_EQ(4, status->TotalNumConflictingItems());
   {
     sessions::ScopedModelSafeGroupRestriction r(status, GROUP_PASSIVE);
-    EXPECT_EQ(4, status->conflict_progress().ConflictingItemsSize());
+    ASSERT_TRUE(status->conflict_progress());
+    EXPECT_EQ(4, status->conflict_progress()->ConflictingItemsSize());
   }
 }
 
 TEST_F(SyncerTest, CommitTimeRename) {
   ScopedDirLookup dir(syncdb_.manager(), syncdb_.name());
   ASSERT_TRUE(dir.good());
   int64 metahandle_folder;
   int64 metahandle_new_entry;
 
   // Create a folder and an entry.
@@ skipping 427 matching lines @@
     ASSERT_TRUE(entry.good());
     entry.Put(syncable::IS_DIR, true);
     entry.Put(syncable::IS_UNSYNCED, true);
     entry.Put(syncable::SPECIFICS, DefaultBookmarkSpecifics());
   }
 
   mock_server_->SetMidCommitCallback(
       NewCallback<EntryCreatedInNewFolderTest>(this,
           &EntryCreatedInNewFolderTest::CreateFolderInBob));
   syncer_->SyncShare(session_.get(), BUILD_COMMIT_REQUEST, SYNCER_END);
-  EXPECT_TRUE(1 == mock_server_->committed_ids().size());
+  EXPECT_EQ(1u, mock_server_->committed_ids().size());
   {
     ReadTransaction trans(FROM_HERE, dir);
     Entry parent_entry(&trans, syncable::GET_BY_ID,
         GetOnlyEntryWithName(&trans, TestIdFactory::root(), "bob"));
     ASSERT_TRUE(parent_entry.good());
 
     Id child_id =
         GetOnlyEntryWithName(&trans, parent_entry.Get(ID), "bob");
     Entry child(&trans, syncable::GET_BY_ID, child_id);
     ASSERT_TRUE(child.good());
@@ skipping 18 matching lines @@
     // Create an item.
     WriteTransaction trans(FROM_HERE, UNITTEST, dir);
     MutableEntry fred_match(&trans, CREATE, trans.root_id(),
                             "fred_match");
     ASSERT_TRUE(fred_match.good());
     metahandle_fred = fred_match.Get(META_HANDLE);
     WriteTestDataToEntry(&trans, &fred_match);
   }
   // Commit it.
   SyncShareAsDelegate();
-  EXPECT_TRUE(1 == mock_server_->committed_ids().size());
+  EXPECT_EQ(1u, mock_server_->committed_ids().size());
   mock_server_->set_conflict_all_commits(true);
   syncable::Id fred_match_id;
   {
     // Now receive a change from outside.
     WriteTransaction trans(FROM_HERE, UNITTEST, dir);
     MutableEntry fred_match(&trans, GET_BY_HANDLE, metahandle_fred);
     ASSERT_TRUE(fred_match.good());
     EXPECT_TRUE(fred_match.Get(ID).ServerKnows());
     fred_match_id = fred_match.Get(ID);
     mock_server_->AddUpdateBookmark(fred_match_id, trans.root_id(),
@@ skipping 39 matching lines @@
     Entry child(&trans, syncable::GET_BY_ID, child_id_);
     ASSERT_TRUE(child.good());
     EXPECT_TRUE(child.Get(syncable::IS_UNSYNCED));
     EXPECT_FALSE(child.Get(syncable::IS_UNAPPLIED_UPDATE));
     EXPECT_TRUE(child.Get(SPECIFICS).HasExtension(sync_pb::bookmark));
     EXPECT_EQ("Pete.htm", child.Get(NON_UNIQUE_NAME));
     VerifyTestBookmarkDataInEntry(&child);
   }
 
   // Only one entry, since we just overwrite one.
-  EXPECT_TRUE(1 == children.size());
+  EXPECT_EQ(1u, children.size());
   saw_syncer_event_ = false;
 }
 
 // We got this repro case when someone was editing bookmarks while sync was
 // occuring. The entry had changed out underneath the user.
 TEST_F(SyncerTest, CommitsUpdateDoesntAlterEntry) {
   ScopedDirLookup dir(syncdb_.manager(), syncdb_.name());
   CHECK(dir.good());
   const base::Time& test_time = ProtoTimeToTime(123456);
   int64 entry_metahandle;
@@ skipping 62 matching lines @@
   mock_server_->AddUpdateDirectory(parent_id, root_id_, "Folder", 10, 10);
   mock_server_->AddUpdateBookmark(child_id, parent_id, "test.htm", 10, 10);
   mock_server_->set_conflict_all_commits(true);
   SyncShareAsDelegate();
   SyncShareAsDelegate();
   SyncShareAsDelegate();
   {
     ReadTransaction trans(FROM_HERE, dir);
     Directory::ChildHandles children;
     dir->GetChildHandlesById(&trans, root_id_, &children);
-    EXPECT_TRUE(1 == children.size());
+    EXPECT_EQ(1u, children.size());
     dir->GetChildHandlesById(&trans, parent_id, &children);
-    EXPECT_TRUE(1 == children.size());
+    EXPECT_EQ(1u, children.size());
     Directory::UnappliedUpdateMetaHandles unapplied;
     dir->GetUnappliedUpdateMetaHandles(&trans, &unapplied);
-    EXPECT_TRUE(0 == unapplied.size());
+    EXPECT_EQ(0u, unapplied.size());
     syncable::Directory::UnsyncedMetaHandles unsynced;
     dir->GetUnsyncedMetaHandles(&trans, &unsynced);
-    EXPECT_TRUE(0 == unsynced.size());
+    EXPECT_EQ(0u, unsynced.size());
     saw_syncer_event_ = false;
   }
 }
 
 TEST_F(SyncerTest, CommittingNewDeleted) {
   ScopedDirLookup dir(syncdb_.manager(), syncdb_.name());
   CHECK(dir.good());
   {
     WriteTransaction trans(FROM_HERE, UNITTEST, dir);
     MutableEntry entry(&trans, CREATE, trans.root_id(), "bob");
     entry.Put(IS_UNSYNCED, true);
     entry.Put(IS_DEL, true);
   }
   SyncShareAsDelegate();
-  EXPECT_TRUE(0 == mock_server_->committed_ids().size());
+  EXPECT_EQ(0u, mock_server_->committed_ids().size());
 }
 
 // Original problem synopsis:
 // Check failed: entry->Get(BASE_VERSION) <= entry->Get(SERVER_VERSION)
 // Client creates entry, client finishes committing entry. Between
 // commit and getting update back, we delete the entry.
 // We get the update for the entry, but the local one was modified
 // so we store the entry but don't apply it. IS_UNAPPLIED_UPDATE is set.
 // We commit deletion and get a new version number.
 // We apply unapplied updates again before we get the update about the deletion.
@@ skipping 10 matching lines @@
     entry.Put(SERVER_VERSION, 1);
     entry.Put(SERVER_PARENT_ID, ids_.FromNumber(9999));  // Bad parent.
     entry.Put(IS_UNSYNCED, true);
     entry.Put(IS_UNAPPLIED_UPDATE, true);
     entry.Put(SPECIFICS, DefaultBookmarkSpecifics());
     entry.Put(SERVER_SPECIFICS, DefaultBookmarkSpecifics());
     entry.Put(IS_DEL, false);
   }
   syncer_->SyncShare(session_.get(), SYNCER_BEGIN, SYNCER_END);
   syncer_->SyncShare(session_.get(), SYNCER_BEGIN, SYNCER_END);
-  EXPECT_TRUE(0 == session_->status_controller()->TotalNumConflictingItems());
+  EXPECT_EQ(0, session_->status_controller().TotalNumConflictingItems());
   saw_syncer_event_ = false;
 }
 
 // Original problem synopsis:
 //   Illegal parent
 // Unexpected error during sync if we:
 //   make a new folder bob
 //   wait for sync
 //   make a new folder fred
 //   move bob into fred
@@ skipping 27 matching lines @@
     MutableEntry existing(&trans, GET_BY_HANDLE, existing_metahandle);
     ASSERT_TRUE(existing.good());
     existing.Put(PARENT_ID, newfolder.Get(ID));
     existing.Put(IS_UNSYNCED, true);
     EXPECT_TRUE(existing.Get(ID).ServerKnows());
 
     newfolder.Put(IS_DEL, true);
     existing.Put(IS_DEL, true);
   }
   syncer_->SyncShare(session_.get(), SYNCER_BEGIN, SYNCER_END);
-  StatusController* status(session_->status_controller());
-  EXPECT_TRUE(0 == status->error().num_conflicting_commits);
+  const StatusController& status(session_->status_controller());
+  EXPECT_EQ(0, status.error().num_conflicting_commits);
 }
 
 TEST_F(SyncerTest, DeletingEntryWithLocalEdits) {
   ScopedDirLookup dir(syncdb_.manager(), syncdb_.name());
   CHECK(dir.good());
   int64 newfolder_metahandle;
 
   mock_server_->AddUpdateDirectory(1, 0, "bob", 1, 10);
   SyncShareAsDelegate();
   {
@@ skipping 973 matching lines @@
     ASSERT_TRUE(dir.good());
 
     const syncable::Id susan_id = TestIdFactory::FromNumber(susan_int_id_);
     ASSERT_GT(countdown_till_delete_, 0);
     if (0 != --countdown_till_delete_)
     return;
   WriteTransaction trans(FROM_HERE, UNITTEST, dir);
     MutableEntry susan(&trans, GET_BY_ID, susan_id);
   Directory::ChildHandles children;
   dir->GetChildHandlesById(&trans, susan.Get(ID), &children);
-  ASSERT_TRUE(0 == children.size());
+  ASSERT_EQ(0u, children.size());
   susan.Put(IS_DEL, true);
   susan.Put(IS_UNSYNCED, true);
 }
 
  protected:
   int countdown_till_delete_;
 };
 
 TEST_F(SusanDeletingTest,
        NewServerItemInAFolderHierarchyWeHaveDeleted3) {
@@ skipping 44 matching lines @@
     ASSERT_TRUE(susan.good());
     EXPECT_FALSE(susan.Get(IS_UNAPPLIED_UPDATE));
     EXPECT_TRUE(fred.Get(IS_UNAPPLIED_UPDATE));
     EXPECT_FALSE(bob.Get(IS_UNAPPLIED_UPDATE));
     EXPECT_FALSE(joe.Get(IS_UNAPPLIED_UPDATE));
     EXPECT_TRUE(susan.Get(IS_UNSYNCED));
     EXPECT_FALSE(fred.Get(IS_UNSYNCED));
     EXPECT_TRUE(bob.Get(IS_UNSYNCED));
     EXPECT_TRUE(joe.Get(IS_UNSYNCED));
   }
-  EXPECT_TRUE(0 == countdown_till_delete_);
+  EXPECT_EQ(0, countdown_till_delete_);
   delete syncer_->pre_conflict_resolution_closure_;
   syncer_->pre_conflict_resolution_closure_ = NULL;
   LoopSyncShare();
   LoopSyncShare();
   {
     ReadTransaction trans(FROM_HERE, dir);
     Entry bob(&trans, GET_BY_ID, bob_id);
     ASSERT_TRUE(bob.good());
     Entry joe(&trans, GET_BY_ID, joe_id);
     ASSERT_TRUE(joe.good());
@@ skipping 179 matching lines @@
     folder.Put(SPECIFICS, DefaultBookmarkSpecifics());
     MutableEntry folder2(&trans, CREATE, trans.root_id(), "fred");
     ASSERT_TRUE(folder2.good());
     folder2.Put(IS_UNSYNCED, false);
     folder2.Put(IS_DIR, true);
     folder2.Put(SPECIFICS, DefaultBookmarkSpecifics());
     folder2.Put(BASE_VERSION, 3);
     folder2.Put(ID, syncable::Id::CreateFromServerId("mock_server:10000"));
   }
   mock_server_->set_next_new_id(10000);
-  EXPECT_TRUE(1 == dir->unsynced_entity_count());
+  EXPECT_EQ(1u, dir->unsynced_entity_count());
   // we get back a bad id in here (should never happen).
   SyncShareAsDelegate();
-  EXPECT_TRUE(1 == dir->unsynced_entity_count());
+  EXPECT_EQ(1u, dir->unsynced_entity_count());
   SyncShareAsDelegate();  // another bad id in here.
-  EXPECT_TRUE(0 == dir->unsynced_entity_count());
+  EXPECT_EQ(0u, dir->unsynced_entity_count());
   saw_syncer_event_ = false;
 }
 
 TEST_F(SyncerTest, DeletedEntryWithBadParentInLoopCalculation) {
   ScopedDirLookup dir(syncdb_.manager(), syncdb_.name());
   ASSERT_TRUE(dir.good());
   mock_server_->AddUpdateDirectory(1, 0, "bob", 1, 10);
   SyncShareAsDelegate();
   {
     WriteTransaction trans(FROM_HERE, UNITTEST, dir);
@@ skipping 121 matching lines @@
   syncable::Id id[7];
   for (int i = 1; i < 7; i++) {
     id[i] = id_factory.NewServerId();
   }
   bool is_dirty = false;
   ConflictProgress c(&is_dirty);
   c.MergeSets(id[1], id[2]);
   c.MergeSets(id[2], id[3]);
   c.MergeSets(id[4], id[5]);
   c.MergeSets(id[5], id[6]);
-  EXPECT_TRUE(6 == c.IdToConflictSetSize());
+  EXPECT_EQ(6u, c.IdToConflictSetSize());
   EXPECT_FALSE(is_dirty);
   for (int i = 1; i < 7; i++) {
     EXPECT_TRUE(NULL != c.IdToConflictSetGet(id[i]));
     EXPECT_TRUE(c.IdToConflictSetGet(id[(i & ~3) + 1]) ==
                 c.IdToConflictSetGet(id[i]));
   }
   c.MergeSets(id[1], id[6]);
   for (int i = 1; i < 7; i++) {
     EXPECT_TRUE(NULL != c.IdToConflictSetGet(id[i]));
     EXPECT_TRUE(c.IdToConflictSetGet(id[1]) == c.IdToConflictSetGet(id[i]));
@@ skipping 32 matching lines @@
 
   syncable::Id parent_id = ids_.MakeServer("Parent");
   mock_server_->AddUpdateDirectory(parent_id, ids_.root(), "foo", 1, 1);
 
   for (int i = 1; i <= one_bajillion; ++i) {
     syncable::Id item_id = ids_.FromNumber(i);
     mock_server_->AddUpdateDirectory(item_id, parent_id, "dude", 1, 1);
   }
 
   syncer_->SyncShare(session_.get(), SYNCER_BEGIN, SYNCER_END);
-  EXPECT_FALSE(session_->status_controller()->syncer_status().syncer_stuck);
+  EXPECT_FALSE(session_->status_controller().syncer_status().syncer_stuck);
 }
 
 // In this test a long changelog contains a child at the start of the changelog
 // and a parent at the end. While these updates are in progress the client would
 // appear stuck.
 TEST_F(SyncerTest, LongChangelistWithApplicationConflict) {
   ScopedDirLookup dir(syncdb_.manager(), syncdb_.name());
   CHECK(dir.good());
   const int depth = 400;
   syncable::Id folder_id = ids_.FromNumber(1);
 
   // First we an item in a folder in the root. However the folder won't come
   // till much later.
   syncable::Id stuck_entry_id = TestIdFactory::FromNumber(99999);
   mock_server_->AddUpdateDirectory(stuck_entry_id,
       folder_id, "stuck", 1, 1);
   mock_server_->SetChangesRemaining(depth - 1);
   syncer_->SyncShare(session_.get(), SYNCER_BEGIN, SYNCER_END);
 
   // Buffer up a very long series of downloads.
   // We should never be stuck (conflict resolution shouldn't
   // kick in so long as we're making forward progress).
   for (int i = 0; i < depth; i++) {
     mock_server_->NextUpdateBatch();
     mock_server_->SetNewTimestamp(i + 1);
     mock_server_->SetChangesRemaining(depth - i);
   }
 
   syncer_->SyncShare(session_.get(), SYNCER_BEGIN, SYNCER_END);
-  EXPECT_FALSE(session_->status_controller()->syncer_status().syncer_stuck);
+  EXPECT_FALSE(session_->status_controller().syncer_status().syncer_stuck);
 
   // Ensure our folder hasn't somehow applied.
   {
     ReadTransaction trans(FROM_HERE, dir);
     Entry child(&trans, GET_BY_ID, stuck_entry_id);
     EXPECT_TRUE(child.good());
     EXPECT_TRUE(child.Get(IS_UNAPPLIED_UPDATE));
     EXPECT_TRUE(child.Get(IS_DEL));
     EXPECT_FALSE(child.Get(IS_UNSYNCED));
   }
@@ skipping 272 matching lines @@
     ASSERT_TRUE(entry.good());
     entry.Put(PARENT_ID, folder_two_id);
     entry.Put(IS_UNSYNCED, true);
     // A new entry should send no "old parent."
     MutableEntry create(&trans, CREATE, trans.root_id(), "new_folder");
     create.Put(IS_UNSYNCED, true);
     create.Put(SPECIFICS, DefaultBookmarkSpecifics());
   }
   SyncShareAsDelegate();
   const sync_pb::CommitMessage& commit = mock_server_->last_sent_commit();
-  ASSERT_TRUE(2 == commit.entries_size());
+  ASSERT_EQ(2, commit.entries_size());
   EXPECT_TRUE(commit.entries(0).parent_id_string() == "2");
   EXPECT_TRUE(commit.entries(0).old_parent_id() == "0");
   EXPECT_FALSE(commit.entries(1).has_old_parent_id());
 }
 
 TEST_F(SyncerTest, Test64BitVersionSupport) {
   ScopedDirLookup dir(syncdb_.manager(), syncdb_.name());
   CHECK(dir.good());
   int64 really_big_int = std::numeric_limits<int64>::max() - 12;
   const string name("ringo's dang orang ran rings around my o-ring");
@@ skipping 718 matching lines @@
     EXPECT_GE(0, Get(metahandle_, BASE_VERSION));
     EXPECT_GE(0, Get(metahandle_, SERVER_VERSION));
   }
 
  protected:
   const std::string client_tag_;
   int64 metahandle_;
 };
 
 TEST_F(SyncerUndeletionTest, UndeleteDuringCommit) {
-  StatusController* status = session_->status_controller();
+  const StatusController& status = session_->status_controller();
 
   Create();
   ExpectUnsyncedCreation();
   SyncShareAsDelegate();
 
   EXPECT_EQ(1, mock_server_->GetAndClearNumGetUpdatesRequests());
-  EXPECT_EQ(0, status->TotalNumConflictingItems());
+  EXPECT_EQ(0, status.TotalNumConflictingItems());
   ExpectSyncedAndCreated();
 
   // Delete, begin committing the delete, then undelete while committing.
   Delete();
   ExpectUnsyncedDeletion();
   mock_server_->SetMidCommitCallback(
       NewCallback<SyncerUndeletionTest>(this,
           &SyncerUndeletionTest::Undelete));
   SyncShareAsDelegate();
 
   // The item ought to exist as an unsynced undeletion (meaning,
   // we think that the next commit ought to be a recreation commit).
-  EXPECT_EQ(0, status->TotalNumConflictingItems());
+  EXPECT_EQ(0, status.TotalNumConflictingItems());
   EXPECT_EQ(1, mock_server_->GetAndClearNumGetUpdatesRequests());
   ExpectUnsyncedUndeletion();
 
   // Now, encounter a GetUpdates corresponding to the deletion from
   // the server.  The undeletion should prevail again and be committed.
   // None of this should trigger any conflict detection -- it is perfectly
   // normal to recieve updates from our own commits.
   mock_server_->SetMidCommitCallback(NULL);
   mock_server_->AddUpdateTombstone(Get(metahandle_, ID));
   SyncShareAsDelegate();
-  EXPECT_EQ(0, status->TotalNumConflictingItems());
+  EXPECT_EQ(0, status.TotalNumConflictingItems());
   EXPECT_EQ(1, mock_server_->GetAndClearNumGetUpdatesRequests());
   ExpectSyncedAndCreated();
 }
 
 TEST_F(SyncerUndeletionTest, UndeleteBeforeCommit) {
-  StatusController* status = session_->status_controller();
+  const StatusController& status = session_->status_controller();
 
   Create();
   ExpectUnsyncedCreation();
   SyncShareAsDelegate();
 
   EXPECT_EQ(1, mock_server_->GetAndClearNumGetUpdatesRequests());
-  EXPECT_EQ(0, status->TotalNumConflictingItems());
+  EXPECT_EQ(0, status.TotalNumConflictingItems());
   ExpectSyncedAndCreated();
 
   // Delete and undelete, then sync to pick up the result.
   Delete();
   ExpectUnsyncedDeletion();
   Undelete();
   ExpectUnsyncedEdit();  // Edit, not undelete: server thinks it exists.
   SyncShareAsDelegate();
 
   // The item ought to have committed successfully.
-  EXPECT_EQ(0, status->TotalNumConflictingItems());
+  EXPECT_EQ(0, status.TotalNumConflictingItems());
   EXPECT_EQ(1, mock_server_->GetAndClearNumGetUpdatesRequests());
   ExpectSyncedAndCreated();
   EXPECT_EQ(2, Get(metahandle_, BASE_VERSION));
 
   // Now, encounter a GetUpdates corresponding to the just-committed
   // update.
   mock_server_->AddUpdateFromLastCommit();
   SyncShareAsDelegate();
-  EXPECT_EQ(0, status->TotalNumConflictingItems());
+  EXPECT_EQ(0, status.TotalNumConflictingItems());
   EXPECT_EQ(1, mock_server_->GetAndClearNumGetUpdatesRequests());
   ExpectSyncedAndCreated();
 }
 
 TEST_F(SyncerUndeletionTest, UndeleteAfterCommitButBeforeGetUpdates) {
-  StatusController* status = session_->status_controller();
+  const StatusController& status = session_->status_controller();
 
   Create();
   ExpectUnsyncedCreation();
   SyncShareAsDelegate();
 
   EXPECT_EQ(1, mock_server_->GetAndClearNumGetUpdatesRequests());
-  EXPECT_EQ(0, status->TotalNumConflictingItems());
+  EXPECT_EQ(0, status.TotalNumConflictingItems());
   ExpectSyncedAndCreated();
 
   // Delete and commit.
   Delete();
   ExpectUnsyncedDeletion();
   SyncShareAsDelegate();
 
   // The item ought to have committed successfully.
-  EXPECT_EQ(0, status->TotalNumConflictingItems());
+  EXPECT_EQ(0, status.TotalNumConflictingItems());
   EXPECT_EQ(1, mock_server_->GetAndClearNumGetUpdatesRequests());
   ExpectSyncedAndDeleted();
 
   // Before the GetUpdates, the item is locally undeleted.
   Undelete();
   ExpectUnsyncedUndeletion();
 
   // Now, encounter a GetUpdates corresponding to the just-committed
   // deletion update.  The undeletion should prevail.
   mock_server_->AddUpdateFromLastCommit();
   SyncShareAsDelegate();
-  EXPECT_EQ(0, status->TotalNumConflictingItems());
+  EXPECT_EQ(0, status.TotalNumConflictingItems());
   EXPECT_EQ(1, mock_server_->GetAndClearNumGetUpdatesRequests());
   ExpectSyncedAndCreated();
 }
 
 TEST_F(SyncerUndeletionTest, UndeleteAfterDeleteAndGetUpdates) {
-  StatusController* status = session_->status_controller();
+  const StatusController& status = session_->status_controller();
 
   Create();
   ExpectUnsyncedCreation();
   SyncShareAsDelegate();
 
   EXPECT_EQ(1, mock_server_->GetAndClearNumGetUpdatesRequests());
-  EXPECT_EQ(0, status->TotalNumConflictingItems());
+  EXPECT_EQ(0, status.TotalNumConflictingItems());
   ExpectSyncedAndCreated();
 
   mock_server_->AddUpdateFromLastCommit();
   SyncShareAsDelegate();
   EXPECT_EQ(1, mock_server_->GetAndClearNumGetUpdatesRequests());
-  EXPECT_EQ(0, status->TotalNumConflictingItems());
+  EXPECT_EQ(0, status.TotalNumConflictingItems());
   ExpectSyncedAndCreated();
 
   // Delete and commit.
   Delete();
   ExpectUnsyncedDeletion();
   SyncShareAsDelegate();
 
   // The item ought to have committed successfully.
-  EXPECT_EQ(0, status->TotalNumConflictingItems());
+  EXPECT_EQ(0, status.TotalNumConflictingItems());
   EXPECT_EQ(1, mock_server_->GetAndClearNumGetUpdatesRequests());
   ExpectSyncedAndDeleted();
 
   // Now, encounter a GetUpdates corresponding to the just-committed
   // deletion update.  Should be consistent.
   mock_server_->AddUpdateFromLastCommit();
   SyncShareAsDelegate();
-  EXPECT_EQ(0, status->TotalNumConflictingItems());
+  EXPECT_EQ(0, status.TotalNumConflictingItems());
   EXPECT_EQ(1, mock_server_->GetAndClearNumGetUpdatesRequests());
   ExpectSyncedAndDeleted();
 
   // After the GetUpdates, the item is locally undeleted.
   Undelete();
   ExpectUnsyncedUndeletion();
 
   // Now, encounter a GetUpdates corresponding to the just-committed
   // deletion update.  The undeletion should prevail.
   SyncShareAsDelegate();
-  EXPECT_EQ(0, status->TotalNumConflictingItems());
+  EXPECT_EQ(0, status.TotalNumConflictingItems());
   EXPECT_EQ(1, mock_server_->GetAndClearNumGetUpdatesRequests());
   ExpectSyncedAndCreated();
 }
 
 // Test processing of undeletion GetUpdateses.
 TEST_F(SyncerUndeletionTest, UndeleteAfterOtherClientDeletes) {
-  StatusController* status = session_->status_controller();
+  const StatusController& status = session_->status_controller();
 
   Create();
   ExpectUnsyncedCreation();
   SyncShareAsDelegate();
 
   EXPECT_EQ(1, mock_server_->GetAndClearNumGetUpdatesRequests());
-  EXPECT_EQ(0, status->TotalNumConflictingItems());
+  EXPECT_EQ(0, status.TotalNumConflictingItems());
   ExpectSyncedAndCreated();
 
   // Add a delete from the server.
   mock_server_->AddUpdateFromLastCommit();
   SyncShareAsDelegate();
   EXPECT_EQ(1, mock_server_->GetAndClearNumGetUpdatesRequests());
-  EXPECT_EQ(0, status->TotalNumConflictingItems());
+  EXPECT_EQ(0, status.TotalNumConflictingItems());
   ExpectSyncedAndCreated();
 
   // Some other client deletes the item.
   mock_server_->AddUpdateTombstone(Get(metahandle_, ID));
   SyncShareAsDelegate();
 
   // The update ought to have applied successfully.
-  EXPECT_EQ(0, status->TotalNumConflictingItems());
+  EXPECT_EQ(0, status.TotalNumConflictingItems());
   EXPECT_EQ(1, mock_server_->GetAndClearNumGetUpdatesRequests());
   ExpectSyncedAndDeleted();
 
   // Undelete it locally.
   Undelete();
   ExpectUnsyncedUndeletion();
   SyncShareAsDelegate();
-  EXPECT_EQ(0, status->TotalNumConflictingItems());
+  EXPECT_EQ(0, status.TotalNumConflictingItems());
   EXPECT_EQ(1, mock_server_->GetAndClearNumGetUpdatesRequests());
   ExpectSyncedAndCreated();
 
   // Now, encounter a GetUpdates corresponding to the just-committed
   // deletion update.  The undeletion should prevail.
   mock_server_->AddUpdateFromLastCommit();
   SyncShareAsDelegate();
-  EXPECT_EQ(0, status->TotalNumConflictingItems());
+  EXPECT_EQ(0, status.TotalNumConflictingItems());
   EXPECT_EQ(1, mock_server_->GetAndClearNumGetUpdatesRequests());
   ExpectSyncedAndCreated();
 }
 
 TEST_F(SyncerUndeletionTest, UndeleteAfterOtherClientDeletesImmediately) {
-  StatusController* status = session_->status_controller();
+  const StatusController& status = session_->status_controller();
 
   Create();
   ExpectUnsyncedCreation();
   SyncShareAsDelegate();
 
   EXPECT_EQ(1, mock_server_->GetAndClearNumGetUpdatesRequests());
-  EXPECT_EQ(0, status->TotalNumConflictingItems());
+  EXPECT_EQ(0, status.TotalNumConflictingItems());
   ExpectSyncedAndCreated();
 
   // Some other client deletes the item before we get a chance
   // to GetUpdates our original request.
   mock_server_->AddUpdateTombstone(Get(metahandle_, ID));
   SyncShareAsDelegate();
 
   // The update ought to have applied successfully.
-  EXPECT_EQ(0, status->TotalNumConflictingItems());
+  EXPECT_EQ(0, status.TotalNumConflictingItems());
   EXPECT_EQ(1, mock_server_->GetAndClearNumGetUpdatesRequests());
   ExpectSyncedAndDeleted();
 
   // Undelete it locally.
   Undelete();
   ExpectUnsyncedUndeletion();
   SyncShareAsDelegate();
-  EXPECT_EQ(0, status->TotalNumConflictingItems());
+  EXPECT_EQ(0, status.TotalNumConflictingItems());
   EXPECT_EQ(1, mock_server_->GetAndClearNumGetUpdatesRequests());
   ExpectSyncedAndCreated();
 
   // Now, encounter a GetUpdates corresponding to the just-committed
   // deletion update.  The undeletion should prevail.
   mock_server_->AddUpdateFromLastCommit();
   SyncShareAsDelegate();
-  EXPECT_EQ(0, status->TotalNumConflictingItems());
+  EXPECT_EQ(0, status.TotalNumConflictingItems());
   EXPECT_EQ(1, mock_server_->GetAndClearNumGetUpdatesRequests());
   ExpectSyncedAndCreated();
 }
 
 TEST_F(SyncerUndeletionTest, OtherClientUndeletes) {
-  StatusController* status = session_->status_controller();
+  const StatusController& status = session_->status_controller();
 
   Create();
   ExpectUnsyncedCreation();
   SyncShareAsDelegate();
 
   EXPECT_EQ(1, mock_server_->GetAndClearNumGetUpdatesRequests());
-  EXPECT_EQ(0, status->TotalNumConflictingItems());
+  EXPECT_EQ(0, status.TotalNumConflictingItems());
   ExpectSyncedAndCreated();
 
   // Get the updates of our just-committed entry.
   mock_server_->AddUpdateFromLastCommit();
   SyncShareAsDelegate();
   EXPECT_EQ(1, mock_server_->GetAndClearNumGetUpdatesRequests());
-  EXPECT_EQ(0, status->TotalNumConflictingItems());
+  EXPECT_EQ(0, status.TotalNumConflictingItems());
   ExpectSyncedAndCreated();
 
   // We delete the item.
   Delete();
   ExpectUnsyncedDeletion();
   SyncShareAsDelegate();
 
   // The update ought to have applied successfully.
-  EXPECT_EQ(0, status->TotalNumConflictingItems());
+  EXPECT_EQ(0, status.TotalNumConflictingItems());
   EXPECT_EQ(1, mock_server_->GetAndClearNumGetUpdatesRequests());
   ExpectSyncedAndDeleted();
 
   // Now, encounter a GetUpdates corresponding to the just-committed
   // deletion update.
   mock_server_->AddUpdateFromLastCommit();
   SyncShareAsDelegate();
-  EXPECT_EQ(0, status->TotalNumConflictingItems());
+  EXPECT_EQ(0, status.TotalNumConflictingItems());
   EXPECT_EQ(1, mock_server_->GetAndClearNumGetUpdatesRequests());
   ExpectSyncedAndDeleted();
 
   // Some other client undeletes the item.
   mock_server_->AddUpdateBookmark(Get(metahandle_, ID),
                                   Get(metahandle_, PARENT_ID),
                                   "Thadeusz", 100, 1000);
   mock_server_->SetLastUpdateClientTag(client_tag_);
   SyncShareAsDelegate();
-  EXPECT_EQ(0, status->TotalNumConflictingItems());
+  EXPECT_EQ(0, status.TotalNumConflictingItems());
   EXPECT_EQ(1, mock_server_->GetAndClearNumGetUpdatesRequests());
   ExpectSyncedAndCreated();
   EXPECT_EQ("Thadeusz", Get(metahandle_, NON_UNIQUE_NAME));
 }
 
 TEST_F(SyncerUndeletionTest, OtherClientUndeletesImmediately) {
-  StatusController* status = session_->status_controller();
+  const StatusController& status = session_->status_controller();
 
   Create();
   ExpectUnsyncedCreation();
   SyncShareAsDelegate();
 
   EXPECT_EQ(1, mock_server_->GetAndClearNumGetUpdatesRequests());
-  EXPECT_EQ(0, status->TotalNumConflictingItems());
+  EXPECT_EQ(0, status.TotalNumConflictingItems());
   ExpectSyncedAndCreated();
 
   // Get the updates of our just-committed entry.
   mock_server_->AddUpdateFromLastCommit();
   SyncShareAsDelegate();
   EXPECT_EQ(1, mock_server_->GetAndClearNumGetUpdatesRequests());
-  EXPECT_EQ(0, status->TotalNumConflictingItems());
+  EXPECT_EQ(0, status.TotalNumConflictingItems());
   ExpectSyncedAndCreated();
 
   // We delete the item.
   Delete();
   ExpectUnsyncedDeletion();
   SyncShareAsDelegate();
 
   // The update ought to have applied successfully.
-  EXPECT_EQ(0, status->TotalNumConflictingItems());
+  EXPECT_EQ(0, status.TotalNumConflictingItems());
   EXPECT_EQ(1, mock_server_->GetAndClearNumGetUpdatesRequests());
   ExpectSyncedAndDeleted();
 
   // Some other client undeletes before we see the update from our
   // commit.
   mock_server_->AddUpdateBookmark(Get(metahandle_, ID),
                                   Get(metahandle_, PARENT_ID),
                                   "Thadeusz", 100, 1000);
   mock_server_->SetLastUpdateClientTag(client_tag_);
   SyncShareAsDelegate();
-  EXPECT_EQ(0, status->TotalNumConflictingItems());
+  EXPECT_EQ(0, status.TotalNumConflictingItems());
   EXPECT_EQ(1, mock_server_->GetAndClearNumGetUpdatesRequests());
   ExpectSyncedAndCreated();
   EXPECT_EQ("Thadeusz", Get(metahandle_, NON_UNIQUE_NAME));
 }
 
 // A group of tests exercising the syncer's handling of sibling ordering, as
 // represented in the sync protocol.
 class SyncerPositionUpdateTest : public SyncerTest {
  public:
   SyncerPositionUpdateTest() : next_update_id_(1), next_revision_(1) {}
@@ skipping 207 matching lines @@
   Add(low_id_);
   Add(high_id_);
   SyncShareAsDelegate();
   ExpectLocalOrderIsByServerId();
 }
 
 const SyncerTest::CommitOrderingTest
 SyncerTest::CommitOrderingTest::LAST_COMMIT_ITEM = {-1, TestIdFactory::root()};
 
 }  // namespace browser_sync