Remove stl_util's deletion function use from chrome/.

chrome/browser/safe_browsing/local_database_manager_unittest.cc

 // Copyright 2013 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 "chrome/browser/safe_browsing/local_database_manager.h"
 
 #include <stddef.h>
 
 #include <memory>
 #include <string>
@@ skipping 24 matching lines @@
 
   bool RunSBHashTest(const ListType list_type,
                      const std::vector<SBThreatType>& expected_threats,
                      const std::vector<std::string>& result_lists);
   bool RunUrlTest(
       const GURL& url, ListType list_type,
       const std::vector<SBThreatType>& expected_threats,
       const std::vector<HostListPair>& host_list_results);
 
  private:
-  bool RunTest(LocalSafeBrowsingDatabaseManager::SafeBrowsingCheck* check,
+  bool RunTest(std::unique_ptr<
+                   LocalSafeBrowsingDatabaseManager::SafeBrowsingCheck> check,
                const std::vector<SBFullHashResult>& hash_results);
 
   TestBrowserThreadBundle thread_bundle_;
 };
 
 bool LocalDatabaseManagerTest::RunSBHashTest(
     const ListType list_type,
     const std::vector<SBThreatType>& expected_threats,
     const std::vector<std::string>& result_lists) {
   const SBFullHash same_full_hash = {};
   std::unique_ptr<LocalSafeBrowsingDatabaseManager::SafeBrowsingCheck> check(
       new LocalSafeBrowsingDatabaseManager::SafeBrowsingCheck(
           std::vector<GURL>(), std::vector<SBFullHash>(1, same_full_hash), NULL,
           list_type, expected_threats));
 
   std::vector<SBFullHashResult> fake_results;
   for (const auto& result_list : result_lists) {
     const SBFullHashResult full_hash_result = {same_full_hash,
                                                GetListId(result_list)};
     fake_results.push_back(full_hash_result);
   }
-  return RunTest(check.get(), fake_results);
+  return RunTest(std::move(check), fake_results);
 }
 
 bool LocalDatabaseManagerTest::RunUrlTest(
     const GURL& url, ListType list_type,
     const std::vector<SBThreatType>& expected_threats,
     const std::vector<HostListPair>& host_list_results) {
   std::unique_ptr<LocalSafeBrowsingDatabaseManager::SafeBrowsingCheck> check(
       new LocalSafeBrowsingDatabaseManager::SafeBrowsingCheck(
           std::vector<GURL>(1, url), std::vector<SBFullHash>(), NULL, list_type,
           expected_threats));
   std::vector<SBFullHashResult> full_hash_results;
   for (const auto& host_list : host_list_results) {
     SBFullHashResult hash_result =
         {SBFullHashForString(host_list.host), GetListId(host_list.list_type)};
     full_hash_results.push_back(hash_result);
   }
-  return RunTest(check.get(), full_hash_results);
+  return RunTest(std::move(check), full_hash_results);
 }
 
 bool LocalDatabaseManagerTest::RunTest(
-    LocalSafeBrowsingDatabaseManager::SafeBrowsingCheck* check,
+    std::unique_ptr<LocalSafeBrowsingDatabaseManager::SafeBrowsingCheck> check,
     const std::vector<SBFullHashResult>& hash_results) {
   scoped_refptr<SafeBrowsingService> sb_service_(
       SafeBrowsingService::CreateSafeBrowsingService());
   scoped_refptr<LocalSafeBrowsingDatabaseManager> db_manager_(
       new LocalSafeBrowsingDatabaseManager(sb_service_));
-  db_manager_->checks_.insert(check);
+  LocalSafeBrowsingDatabaseManager::SafeBrowsingCheck* check_ptr = check.get();
+  db_manager_->checks_[check_ptr] = std::move(check);
 
-  bool result = db_manager_->HandleOneCheck(check, hash_results);
-  db_manager_->checks_.erase(check);
+  bool result = db_manager_->HandleOneCheck(check_ptr, hash_results);
+  db_manager_->checks_.erase(check_ptr);
   return result;
 }
 
 TEST_F(LocalDatabaseManagerTest, CheckCorrespondsListTypeForHash) {
   std::vector<SBThreatType> malware_threat(1,
                                            SB_THREAT_TYPE_BINARY_MALWARE_URL);
   EXPECT_FALSE(RunSBHashTest(BINURL, malware_threat, {kMalwareList}));
   EXPECT_TRUE(RunSBHashTest(BINURL, malware_threat, {kBinUrlList}));
 
   // Check for multiple threats
@@ skipping 221 matching lines @@
   // Stop the service without first flushing above tasks.
   db_manager->StopOnIOThread(false);
 
   // Now run posted tasks, whish should include the extension check which has
   // been posted to the safe browsing task runner. This should not crash.
   content::RunAllBlockingPoolTasksUntilIdle();
   base::RunLoop().RunUntilIdle();
 }
 
 }  // namespace safe_browsing