Remove stl_util's STLValueDeleter.

components/sync/syncable/directory_backing_store_unittest.cc

 // Copyright 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 "components/sync/syncable/directory_backing_store.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <map>
 #include <memory>
 #include <string>
 
 #include "base/files/file_path.h"
 #include "base/files/scoped_temp_dir.h"
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
-#include "base/stl_util.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/stringprintf.h"
 #include "build/build_config.h"
 #include "components/sync/base/node_ordinal.h"
 #include "components/sync/base/time.h"
 #include "components/sync/protocol/bookmark_specifics.pb.h"
 #include "components/sync/protocol/sync.pb.h"
 #include "components/sync/syncable/directory.h"
 #include "components/sync/syncable/on_disk_directory_backing_store.h"
 #include "components/sync/syncable/syncable-inl.h"
@@ skipping 37 matching lines @@
   std::string GetUsername() {
     return "nick@chromium.org";
   }
 
   base::FilePath GetDatabasePath() {
     return temp_dir_.path().Append(Directory::kSyncDatabaseFilename);
   }
 
   static bool LoadAndIgnoreReturnedData(DirectoryBackingStore *dbs) {
     Directory::MetahandlesMap tmp_handles_map;
-    JournalIndex  delete_journals;
+    JournalIndex delete_journals;
     MetahandleSet metahandles_to_purge;
-    base::STLValueDeleter<Directory::MetahandlesMap> deleter(&tmp_handles_map);
     Directory::KernelLoadInfo kernel_load_info;
     return dbs->Load(&tmp_handles_map, &delete_journals, &metahandles_to_purge,
                      &kernel_load_info) == OPENED;
   }
 
   void SetUpVersion67Database(sql::Connection* connection);
   void SetUpVersion68Database(sql::Connection* connection);
   void SetUpVersion69Database(sql::Connection* connection);
   void SetUpVersion70Database(sql::Connection* connection);
   void SetUpVersion71Database(sql::Connection* connection);
@@ skipping 3233 matching lines @@
       new TestDirectoryBackingStore(GetUsername(), &connection));
   ASSERT_FALSE(dbs->needs_column_refresh());
   ASSERT_TRUE(dbs->MigrateVersion79To80());
   ASSERT_EQ(80, dbs->GetVersion());
   ASSERT_FALSE(dbs->needs_column_refresh());
 
   // Ensure the bag_of_chips has been set.
   Directory::MetahandlesMap handles_map;
   JournalIndex delete_journals;
   MetahandleSet metahandles_to_purge;
-  base::STLValueDeleter<Directory::MetahandlesMap> deleter(&handles_map);
   Directory::KernelLoadInfo load_info;
 
   ASSERT_TRUE(dbs->Load(&handles_map, &delete_journals, &metahandles_to_purge,
                         &load_info));
   // Check that the initial value is the serialization of an empty ChipBag.
   sync_pb::ChipBag chip_bag;
   std::string serialized_chip_bag;
   ASSERT_TRUE(chip_bag.SerializeToString(&serialized_chip_bag));
   EXPECT_EQ(serialized_chip_bag, load_info.kernel_info.bag_of_chips);
 }
@@ skipping 218 matching lines @@
       "INSERT INTO metas "
       "( id, metahandle, is_dir, ctime, mtime,"
       "  unique_position, server_unique_position) "
       "VALUES('c-invalid', 9999, 1, 0, 0, 'BAD_POS', 'BAD_POS')"));
   ASSERT_TRUE(s.Run());
 
   // Trying to unpack this entry should signal that the DB is corrupted.
   Directory::MetahandlesMap handles_map;
   JournalIndex delete_journals;
   MetahandleSet metahandles_to_purge;
-  base::STLValueDeleter<Directory::MetahandlesMap> deleter(&handles_map);
   Directory::KernelLoadInfo kernel_load_info;
   ASSERT_EQ(FAILED_DATABASE_CORRUPT,
             dbs->Load(&handles_map, &delete_journals, &metahandles_to_purge,
                       &kernel_load_info));
 }
 
 TEST_P(MigrationTest, ToCurrentVersion) {
   sql::Connection connection;
   ASSERT_TRUE(connection.Open(GetDatabasePath()));
   // Assume all old versions have an old page size.
@@ skipping 78 matching lines @@
       // SetUpVersionYDatabase function with a dump of the test database
       // at the new schema.  See the MigrateToLatestAndDump test case.
       FAIL() << "Need to supply database dump for version " << GetParam();
   }
   connection.Close();
 
   syncable::Directory::KernelLoadInfo dir_info;
   Directory::MetahandlesMap handles_map;
   JournalIndex delete_journals;
   MetahandleSet metahandles_to_purge;
-  base::STLValueDeleter<Directory::MetahandlesMap> index_deleter(&handles_map);
 
   {
     std::unique_ptr<OnDiskDirectoryBackingStore> dbs(
         new OnDiskDirectoryBackingStore(GetUsername(), GetDatabasePath()));
     ASSERT_EQ(OPENED, dbs->Load(&handles_map, &delete_journals,
                                 &metahandles_to_purge, &dir_info));
     if (!metahandles_to_purge.empty())
       dbs->DeleteEntries(DirectoryBackingStore::METAS_TABLE,
                          metahandles_to_purge);
     ASSERT_FALSE(dbs->needs_column_refresh());
@@ skipping 394 matching lines @@
 }
 
 TEST_F(DirectoryBackingStoreTest, DeleteEntries) {
   sql::Connection connection;
   ASSERT_TRUE(connection.OpenInMemory());
 
   SetUpCurrentDatabaseAndCheckVersion(&connection);
   std::unique_ptr<TestDirectoryBackingStore> dbs(
       new TestDirectoryBackingStore(GetUsername(), &connection));
   Directory::MetahandlesMap handles_map;
-  JournalIndex  delete_journals;
+  JournalIndex delete_journals;
   MetahandleSet metahandles_to_purge;
   Directory::KernelLoadInfo kernel_load_info;
-  base::STLValueDeleter<Directory::MetahandlesMap> index_deleter(&handles_map);
 
   dbs->Load(&handles_map, &delete_journals, &metahandles_to_purge,
             &kernel_load_info);
   size_t initial_size = handles_map.size();
   ASSERT_LT(0U, initial_size) << "Test requires handles_map to delete.";
   int64_t first_to_die = handles_map.begin()->second->ref(META_HANDLE);
   MetahandleSet to_delete;
   to_delete.insert(first_to_die);
   EXPECT_TRUE(dbs->DeleteEntries(to_delete));
 
-  base::STLDeleteValues(&handles_map);
+  handles_map.clear();
   metahandles_to_purge.clear();
   dbs->LoadEntries(&handles_map, &metahandles_to_purge);
 
   EXPECT_EQ(initial_size - 1, handles_map.size());
   bool delete_failed = false;
   for (Directory::MetahandlesMap::iterator it = handles_map.begin();
        it != handles_map.end(); ++it) {
     if (it->first == first_to_die) {
       delete_failed = true;
       break;
     }
   }
   EXPECT_FALSE(delete_failed);
 
   to_delete.clear();
   for (Directory::MetahandlesMap::iterator it = handles_map.begin();
        it != handles_map.end(); ++it) {
     to_delete.insert(it->first);
   }
 
   EXPECT_TRUE(dbs->DeleteEntries(to_delete));
 
-  base::STLDeleteValues(&handles_map);
+  handles_map.clear();
   metahandles_to_purge.clear();
   dbs->LoadEntries(&handles_map, &metahandles_to_purge);
   EXPECT_EQ(0U, handles_map.size());
 }
 
 TEST_F(DirectoryBackingStoreTest, GenerateCacheGUID) {
   const std::string& guid1 = TestDirectoryBackingStore::GenerateCacheGUID();
   const std::string& guid2 = TestDirectoryBackingStore::GenerateCacheGUID();
   EXPECT_EQ(24U, guid1.size());
   EXPECT_EQ(24U, guid2.size());
   // In theory this test can fail, but it won't before the universe
   // dies of heat death.
   EXPECT_NE(guid1, guid2);
 }
 
 TEST_F(DirectoryBackingStoreTest, IncreaseDatabasePageSizeFrom4KTo32K) {
   sql::Connection connection;
   ASSERT_TRUE(connection.Open(GetDatabasePath()));
 
   SetUpCurrentDatabaseAndCheckVersion(&connection);
   std::unique_ptr<TestDirectoryBackingStore> dbs(
       new TestDirectoryBackingStore(GetUsername(), &connection));
   Directory::MetahandlesMap handles_map;
   JournalIndex delete_journals;
   MetahandleSet metahandles_to_purge;
   Directory::KernelLoadInfo kernel_load_info;
-  base::STLValueDeleter<Directory::MetahandlesMap> index_deleter(&handles_map);
 
   DirOpenResult open_result = dbs->Load(
       &handles_map, &delete_journals, &metahandles_to_purge, &kernel_load_info);
   EXPECT_EQ(open_result, OPENED);
 
   // Set up database's page size to 4096
   EXPECT_TRUE(dbs->db_->Execute("PRAGMA page_size=4096;"));
   EXPECT_TRUE(dbs->Vacuum());
 
   // Check if update is successful.
@@ skipping 103 matching lines @@
   ASSERT_FALSE(dbs->SaveChanges(snapshot));
   // At this point the handler has been posted but not executed.
   ASSERT_FALSE(was_called);
   // Pump the message loop and see that it is executed.
   base::RunLoop().RunUntilIdle();
   ASSERT_TRUE(was_called);
 }
 
 }  // namespace syncable
 }  // namespace syncer