Fix memory errors in sync unit tests

sync/engine/syncer_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.
 //
 // 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 411 matching lines @@
         SCOPED_TRACE(::testing::Message("Projection mismatch with i = ") << i);
         syncable::Id projected =
             command.ordered_commit_set_->GetCommitIdAt(proj[i]);
         ASSERT_EQ(expected_id_order[proj[i]], projected);
         // Since this projection is the identity, the following holds.
         ASSERT_EQ(expected_id_order[i], projected);
       }
     }
   }
 
+  const StatusController& status() {
+    return session_->status_controller();
+  }
+
   Directory* directory() {
     return dir_maker_.directory();
   }
 
   int64 CreateUnsyncedDirectory(const string& entry_name,
       const string& idstring) {
     return CreateUnsyncedDirectory(entry_name,
         syncable::Id::CreateFromServerId(idstring));
   }
 
@@ skipping 744 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);
   }
 
-  const StatusController& status = session_->status_controller();
   SyncShareNudge();
-  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, directory());
     Entry entry(&rt, syncable::GET_BY_ID, child_id_);
     ASSERT_TRUE(entry.good());
     VerifyTestDataInEntry(&rt, &entry);
   }
@@ skipping 22 matching lines @@
     parent2.Put(syncable::IS_UNSYNCED, true);
     parent2.Put(syncable::IS_DIR, true);
     parent2.Put(syncable::SPECIFICS, DefaultPreferencesSpecifics());
     parent2.Put(syncable::BASE_VERSION, 1);
     parent2.Put(syncable::ID, pref_node_id);
   }
 
   directory()->PurgeEntriesWithTypeIn(
       syncable::ModelTypeSet(syncable::PREFERENCES));
 
-  const StatusController& status = session_->status_controller();
   SyncShareNudge();
-  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, directory());
     Entry entry(&rt, syncable::GET_BY_ID, child_id_);
     ASSERT_TRUE(entry.good());
     VerifyTestDataInEntry(&rt, &entry);
   }
@@ skipping 525 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);
 
   SyncShareNudge();
-  StatusController* status = session_->mutable_status_controller();
 
   // Id 3 should be in conflict now.
-  EXPECT_EQ(1, status->TotalNumConflictingItems());
+  EXPECT_EQ(1, status().TotalNumConflictingItems());
   {
-    sessions::ScopedModelSafeGroupRestriction r(status, GROUP_PASSIVE);
-    ASSERT_TRUE(status->conflict_progress());
-    EXPECT_EQ(1, status->conflict_progress()->HierarchyConflictingItemsSize());
+    sessions::ScopedModelSafeGroupRestriction r(
+        session_->mutable_status_controller(), GROUP_PASSIVE);
+    ASSERT_TRUE(status().conflict_progress());
+    EXPECT_EQ(1, status().conflict_progress()->HierarchyConflictingItemsSize());
   }
 
   // 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);
 
   SyncShareNudge();
   // 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());
+  EXPECT_EQ(3, status().TotalNumConflictingItems());
   {
-    sessions::ScopedModelSafeGroupRestriction r(status, GROUP_PASSIVE);
-    ASSERT_TRUE(status->conflict_progress());
-    EXPECT_EQ(3, status->conflict_progress()->HierarchyConflictingItemsSize());
+    sessions::ScopedModelSafeGroupRestriction r(
+        session_->mutable_status_controller(), GROUP_PASSIVE);
+    ASSERT_TRUE(status().conflict_progress());
+    EXPECT_EQ(3, status().conflict_progress()->HierarchyConflictingItemsSize());
   }
 
   {
     WriteTransaction trans(FROM_HERE, UNITTEST, directory());
     // 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 69 matching lines @@
 
     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_EQ(10u, circular_parent_target.Get(BASE_VERSION));
   }
 
   EXPECT_FALSE(saw_syncer_event_);
-  EXPECT_EQ(4, status->TotalNumConflictingItems());
+  EXPECT_EQ(4, status().TotalNumConflictingItems());
   {
-    sessions::ScopedModelSafeGroupRestriction r(status, GROUP_PASSIVE);
-    ASSERT_TRUE(status->conflict_progress());
-    EXPECT_EQ(4, status->conflict_progress()->HierarchyConflictingItemsSize());
+    sessions::ScopedModelSafeGroupRestriction r(
+        session_->mutable_status_controller(), GROUP_PASSIVE);
+    ASSERT_TRUE(status().conflict_progress());
+    EXPECT_EQ(4, status().conflict_progress()->HierarchyConflictingItemsSize());
   }
 }
 
 TEST_F(SyncerTest, CommitTimeRename) {
   int64 metahandle_folder;
   int64 metahandle_new_entry;
 
   // Create a folder and an entry.
   {
     WriteTransaction trans(FROM_HERE, UNITTEST, directory());
@@ skipping 671 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);
-  const StatusController& status(session_->status_controller());
-  EXPECT_EQ(0, status.TotalNumServerConflictingItems());
+  EXPECT_EQ(0, status().TotalNumServerConflictingItems());
 }
 
 TEST_F(SyncerTest, DeletingEntryWithLocalEdits) {
   int64 newfolder_metahandle;
 
   mock_server_->AddUpdateDirectory(1, 0, "bob", 1, 10);
   SyncShareNudge();
   {
     WriteTransaction trans(FROM_HERE, UNITTEST, directory());
     MutableEntry newfolder(&trans, CREATE, ids_.FromNumber(1), "local");
@@ skipping 2144 matching lines @@
 
 TEST_F(SyncerPositionTiebreakingTest, MidLowHigh) {
   Add(mid_id_);
   Add(low_id_);
   Add(high_id_);
   SyncShareNudge();
   ExpectLocalOrderIsByServerId();
 }
 
 }  // namespace browser_sync