Remove stl_util's deletion function use from chrome/.

chrome/browser/safe_browsing/local_database_manager.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.
 
 #include "chrome/browser/safe_browsing/local_database_manager.h"
 
 #include <algorithm>
 #include <limits>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/callback.h"
 #include "base/command_line.h"
 #include "base/debug/leak_tracker.h"
 #include "base/location.h"
+#include "base/memory/ptr_util.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/single_thread_task_runner.h"
-#include "base/stl_util.h"
 #include "base/strings/string_util.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/chrome_notification_types.h"
 #include "chrome/browser/prerender/prerender_field_trial.h"
 #include "chrome/browser/profiles/profile_manager.h"
 #include "chrome/browser/safe_browsing/client_side_detection_service.h"
 #include "chrome/browser/safe_browsing/download_protection_service.h"
 #include "chrome/browser/safe_browsing/protocol_manager.h"
 #include "chrome/browser/safe_browsing/safe_browsing_database.h"
@@ skipping 313 matching lines @@
 
 bool LocalSafeBrowsingDatabaseManager::CheckDownloadUrl(
     const std::vector<GURL>& url_chain,
     Client* client) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   if (!enabled_ || !enable_download_protection_)
     return true;
 
   // We need to check the database for url prefix, and later may fetch the url
   // from the safebrowsing backends. These need to be asynchronous.
-  SafeBrowsingCheck* check = new SafeBrowsingCheck(
-      url_chain, std::vector<SBFullHash>(), client, BINURL,
-      std::vector<SBThreatType>(1, SB_THREAT_TYPE_BINARY_MALWARE_URL));
+  std::unique_ptr<SafeBrowsingCheck> check =
+      base::MakeUnique<SafeBrowsingCheck>(
+          url_chain, std::vector<SBFullHash>(), client, BINURL,
+          std::vector<SBThreatType>(1, SB_THREAT_TYPE_BINARY_MALWARE_URL));
   std::vector<SBPrefix> prefixes;
   SafeBrowsingDatabase::GetDownloadUrlPrefixes(url_chain, &prefixes);
   StartSafeBrowsingCheck(
-      check,
+      std::move(check),
       base::Bind(&LocalSafeBrowsingDatabaseManager::CheckDownloadUrlOnSBThread,
                  this, prefixes));
   return false;
 }
 
 bool LocalSafeBrowsingDatabaseManager::CheckExtensionIDs(
     const std::set<std::string>& extension_ids,
     Client* client) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
   if (!enabled_ || !enable_extension_blacklist_)
     return true;
 
   std::vector<SBFullHash> extension_id_hashes;
   std::transform(extension_ids.begin(), extension_ids.end(),
                  std::back_inserter(extension_id_hashes), StringToSBFullHash);
   std::vector<SBPrefix> prefixes;
   for (const SBFullHash& hash : extension_id_hashes)
     prefixes.push_back(hash.prefix);
 
-  SafeBrowsingCheck* check = new SafeBrowsingCheck(
-      std::vector<GURL>(), extension_id_hashes, client, EXTENSIONBLACKLIST,
-      std::vector<SBThreatType>(1, SB_THREAT_TYPE_EXTENSION));
+  std::unique_ptr<SafeBrowsingCheck> check =
+      base::MakeUnique<SafeBrowsingCheck>(
+          std::vector<GURL>(), extension_id_hashes, client, EXTENSIONBLACKLIST,
+          std::vector<SBThreatType>(1, SB_THREAT_TYPE_EXTENSION));
   StartSafeBrowsingCheck(
-      check,
+      std::move(check),
       base::Bind(&LocalSafeBrowsingDatabaseManager::CheckExtensionIDsOnSBThread,
                  this, prefixes));
   return false;
 }
 
 bool LocalSafeBrowsingDatabaseManager::CheckResourceUrl(const GURL& url,
                                                         Client* client) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
   if (!enabled_ || !CanCheckUrl(url))
     return true;
 
   std::vector<SBThreatType> expected_threats = {
       SB_THREAT_TYPE_BLACKLISTED_RESOURCE};
 
   if (!MakeDatabaseAvailable()) {
     QueuedCheck queued_check(RESOURCEBLACKLIST, client, url, expected_threats,
                              base::TimeTicks::Now());
     queued_checks_.push_back(queued_check);
     return false;
   }
 
-  SafeBrowsingCheck* check =
+  std::unique_ptr<SafeBrowsingCheck> check = base::WrapUnique(
       new SafeBrowsingCheck({url}, std::vector<SBFullHash>(), client,
-                            RESOURCEBLACKLIST, expected_threats);
+                            RESOURCEBLACKLIST, expected_threats));
 
   std::vector<SBPrefix> prefixes;
   SafeBrowsingDatabase::GetDownloadUrlPrefixes(check->urls, &prefixes);
   StartSafeBrowsingCheck(
-      check,
+      std::move(check),
       base::Bind(&LocalSafeBrowsingDatabaseManager::CheckResourceUrlOnSBThread,
                  this, prefixes));
   return false;
 }
 
 bool LocalSafeBrowsingDatabaseManager::MatchMalwareIP(
     const std::string& ip_address) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   if (!enabled_ || !enable_ip_blacklist_ || !MakeDatabaseAvailable()) {
     return false;  // Fail open.
@@ skipping 116 matching lines @@
   // This check will ping the Safe Browsing servers and get all lists which it
   // matches. These lists will then be filtered against the |expected_threats|
   // and the result callback for MALWARE (which is the same as for PHISH and
   // UNWANTEDURL) will eventually be invoked with the final decision.
   SafeBrowsingCheck* check = new SafeBrowsingCheck(
       std::vector<GURL>(1, url), std::vector<SBFullHash>(), client, MALWARE,
       expected_threats);
   check->need_get_hash = cache_hits.empty();
   check->prefix_hits.swap(prefix_hits);
   check->cache_hits.swap(cache_hits);
-  checks_.insert(check);
+  checks_[check] = base::WrapUnique(check);
 
   BrowserThread::PostTask(
       BrowserThread::IO, FROM_HERE,
       base::Bind(&LocalSafeBrowsingDatabaseManager::OnCheckDone, this, check));
 
   return false;
 }
 
 void LocalSafeBrowsingDatabaseManager::CancelCheck(Client* client) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
-  for (CurrentChecks::iterator i = checks_.begin(); i != checks_.end(); ++i) {
+  for (const auto& check : checks_) {
     // We can't delete matching checks here because the db thread has a copy of
     // the pointer.  Instead, we simply NULL out the client, and when the db
     // thread calls us back, we'll clean up the check.
-    if ((*i)->client == client)
-      (*i)->client = NULL;
+    if (check.first->client == client)
+      check.first->client = NULL;
   }
 
   // Scan the queued clients store. Clients may be here if they requested a URL
   // check before the database has finished loading.
-  for (std::deque<QueuedCheck>::iterator it(queued_checks_.begin());
-       it != queued_checks_.end();) {
+  for (auto it = queued_checks_.begin(); it != queued_checks_.end();) {
     // In this case it's safe to delete matches entirely since nothing has a
     // pointer to them.
     if (it->client == client)
       it = queued_checks_.erase(it);
     else
       ++it;
   }
 }
 
 void LocalSafeBrowsingDatabaseManager::HandleGetHashResults(
@@ skipping 178 matching lines @@
     closing_database_ = true;
     safe_browsing_task_runner_->PostTask(
         FROM_HERE,
         base::Bind(&LocalSafeBrowsingDatabaseManager::OnCloseDatabase, this));
   }
 
   // Delete pending checks, calling back any clients with 'SB_THREAT_TYPE_SAFE'.
   // We have to do this after the db thread returns because methods on it can
   // have copies of these pointers, so deleting them might lead to accessing
   // garbage.
-  for (CurrentChecks::iterator it = checks_.begin(); it != checks_.end();
-       ++it) {
-    SafeBrowsingCheck* check = *it;
-    if (check->client)
-      check->OnSafeBrowsingResult();
+  for (const auto& check : checks_) {
+    if (check.first->client)
+      check.first->OnSafeBrowsingResult();
   }
-  base::STLDeleteElements(&checks_);
 
+  checks_.clear();
   gethash_requests_.clear();
 }
 
 bool LocalSafeBrowsingDatabaseManager::DatabaseAvailable() const {
   base::AutoLock lock(database_lock_);
   return !closing_database_ && (database_ != NULL);
 }
 
 bool LocalSafeBrowsingDatabaseManager::MakeDatabaseAvailable() {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
@@ skipping 424 matching lines @@
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   DCHECK(check);
 
   if (!enabled_)
     return;
 
   DCHECK(checks_.find(check) != checks_.end());
   if (check->client)
     check->OnSafeBrowsingResult();
   checks_.erase(check);
-  delete check;
 }
 
 void LocalSafeBrowsingDatabaseManager::StartSafeBrowsingCheck(
-    SafeBrowsingCheck* check,
+    std::unique_ptr<SafeBrowsingCheck> check,
     const base::Callback<std::vector<SBPrefix>(void)>& task) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   check->weak_ptr_factory_.reset(
       new base::WeakPtrFactory<LocalSafeBrowsingDatabaseManager>(this));
-  checks_.insert(check);
+  SafeBrowsingCheck* check_ptr = check.get();
+  checks_[check_ptr] = std::move(check);
 
   base::PostTaskAndReplyWithResult(
       safe_browsing_task_runner_.get(), FROM_HERE, task,
       base::Bind(&LocalSafeBrowsingDatabaseManager::OnAsyncCheckDone,
-                 check->weak_ptr_factory_->GetWeakPtr(), check));
+                 check_ptr->weak_ptr_factory_->GetWeakPtr(), check_ptr));
   base::ThreadTaskRunnerHandle::Get()->PostDelayedTask(
-      FROM_HERE, base::Bind(&LocalSafeBrowsingDatabaseManager::TimeoutCallback,
-                            check->weak_ptr_factory_->GetWeakPtr(), check),
+      FROM_HERE,
+      base::Bind(&LocalSafeBrowsingDatabaseManager::TimeoutCallback,
+                 check_ptr->weak_ptr_factory_->GetWeakPtr(), check_ptr),
       check_timeout_);
 }
 
 bool LocalSafeBrowsingDatabaseManager::IsDownloadProtectionEnabled() const {
   return enable_download_protection_;
 }
 
 }  // namespace safe_browsing