Remove stl_util from sync.

components/sync/syncable/directory_unittest.cc

 // Copyright 2014 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 "components/sync/syncable/directory_unittest.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <cstdlib>
 
 #include "base/macros.h"
+#include "base/memory/ptr_util.h"
 #include "base/rand_util.h"
 #include "base/run_loop.h"
 #include "base/strings/stringprintf.h"
 #include "base/test/values_test_util.h"
 #include "components/sync/base/attachment_id_proto.h"
 #include "components/sync/base/mock_unrecoverable_error_handler.h"
 #include "components/sync/syncable/syncable_proto_util.h"
 #include "components/sync/syncable/syncable_util.h"
 #include "components/sync/syncable/syncable_write_transaction.h"
 #include "components/sync/test/engine/test_syncable_utils.h"
@@ skipping 264 matching lines @@
     }
   }
   // Fake SaveChanges() and make sure we got what we expected.
   {
     Directory::SaveChangesSnapshot snapshot;
     base::AutoLock scoped_lock(dir()->kernel()->save_changes_mutex);
     dir()->TakeSnapshotForSaveChanges(&snapshot);
     // Make sure there's an entry for each new metahandle.  Make sure all
     // entries are marked dirty.
     ASSERT_EQ(expected_dirty_metahandles.size(), snapshot.dirty_metas.size());
-    for (EntryKernelSet::const_iterator i = snapshot.dirty_metas.begin();
-         i != snapshot.dirty_metas.end(); ++i) {
+    for (auto i = snapshot.dirty_metas.begin(); i != snapshot.dirty_metas.end();
+         ++i) {
       ASSERT_TRUE((*i)->is_dirty());
     }
     dir()->VacuumAfterSaveChanges(snapshot);
   }
   // Put a new value with existing transactions as well as adding new ones.
   {
     WriteTransaction trans(FROM_HERE, UNITTEST, dir().get());
     std::vector<int64_t> new_dirty_metahandles;
     for (std::vector<int64_t>::const_iterator i =
              expected_dirty_metahandles.begin();
@@ skipping 12 matching lines @@
                                       new_dirty_metahandles.end());
   }
   // Fake SaveChanges() and make sure we got what we expected.
   {
     Directory::SaveChangesSnapshot snapshot;
     base::AutoLock scoped_lock(dir()->kernel()->save_changes_mutex);
     dir()->TakeSnapshotForSaveChanges(&snapshot);
     // Make sure there's an entry for each new metahandle.  Make sure all
     // entries are marked dirty.
     EXPECT_EQ(expected_dirty_metahandles.size(), snapshot.dirty_metas.size());
-    for (EntryKernelSet::const_iterator i = snapshot.dirty_metas.begin();
-         i != snapshot.dirty_metas.end(); ++i) {
+    for (auto i = snapshot.dirty_metas.begin(); i != snapshot.dirty_metas.end();
+         ++i) {
       EXPECT_TRUE((*i)->is_dirty());
     }
     dir()->VacuumAfterSaveChanges(snapshot);
   }
 }
 
 TEST_F(SyncableDirectoryTest, TakeSnapshotGetsOnlyDirtyHandlesTest) {
   const int metahandles_to_create = 100;
 
   // half of 2 * metahandles_to_create
@@ skipping 68 matching lines @@
     }
   }
   // Fake SaveChanges() and make sure we got what we expected.
   {
     Directory::SaveChangesSnapshot snapshot;
     base::AutoLock scoped_lock(dir()->kernel()->save_changes_mutex);
     dir()->TakeSnapshotForSaveChanges(&snapshot);
     // Make sure there's an entry for each changed metahandle.  Make sure all
     // entries are marked dirty.
     EXPECT_EQ(number_changed, snapshot.dirty_metas.size());
-    for (EntryKernelSet::const_iterator i = snapshot.dirty_metas.begin();
-         i != snapshot.dirty_metas.end(); ++i) {
+    for (auto i = snapshot.dirty_metas.begin(); i != snapshot.dirty_metas.end();
+         ++i) {
       EXPECT_TRUE((*i)->is_dirty());
     }
     dir()->VacuumAfterSaveChanges(snapshot);
   }
 }
 
 // Test delete journals management.
 TEST_F(SyncableDirectoryTest, ManageDeleteJournals) {
   sync_pb::EntitySpecifics bookmark_specifics;
   AddDefaultFieldValue(BOOKMARKS, &bookmark_specifics);
@@ skipping 1568 matching lines @@
     EXPECT_EQ(Id(), item1.GetPredecessorId());
     EXPECT_EQ(item2_id, item1.GetSuccessorId());
 
     Entry item2(&trans, GET_BY_ID, item2_id);
     EXPECT_EQ(item1_id, item2.GetPredecessorId());
     EXPECT_EQ(Id(), item2.GetSuccessorId());
   }
 }
 
 TEST_F(SyncableDirectoryTest, SaveChangesSnapshot_HasUnsavedMetahandleChanges) {
-  EntryKernel kernel;
   Directory::SaveChangesSnapshot snapshot;
   EXPECT_FALSE(snapshot.HasUnsavedMetahandleChanges());
-  snapshot.dirty_metas.insert(&kernel);
+  snapshot.dirty_metas.insert(base::MakeUnique<EntryKernel>());
   EXPECT_TRUE(snapshot.HasUnsavedMetahandleChanges());
   snapshot.dirty_metas.clear();
 
   EXPECT_FALSE(snapshot.HasUnsavedMetahandleChanges());
   snapshot.metahandles_to_purge.insert(1);
   EXPECT_TRUE(snapshot.HasUnsavedMetahandleChanges());
   snapshot.metahandles_to_purge.clear();
 
   EXPECT_FALSE(snapshot.HasUnsavedMetahandleChanges());
-  snapshot.delete_journals.insert(&kernel);
+  snapshot.delete_journals.insert(base::MakeUnique<EntryKernel>());
   EXPECT_TRUE(snapshot.HasUnsavedMetahandleChanges());
   snapshot.delete_journals.clear();
 
   EXPECT_FALSE(snapshot.HasUnsavedMetahandleChanges());
   snapshot.delete_journals_to_purge.insert(1);
   EXPECT_TRUE(snapshot.HasUnsavedMetahandleChanges());
   snapshot.delete_journals_to_purge.clear();
 }
 
 // Verify that Directory triggers an unrecoverable error when a catastrophic
@@ skipping 104 matching lines @@
 
   const base::DictionaryValue* first_result;
   ASSERT_TRUE(nodes->GetDictionary(0, &first_result));
   EXPECT_TRUE(first_result->HasKey("ID"));
   EXPECT_TRUE(first_result->HasKey("NON_UNIQUE_NAME"));
 }
 
 }  // namespace syncable
 
 }  // namespace syncer