Remove stl_util's deletion function use from content/.

content/browser/download/download_manager_impl.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 "content/browser/download/download_manager_impl.h"
 
 #include <iterator>
 #include <utility>
 
 #include "base/bind.h"
@@ skipping 154 matching lines @@
       const std::string& mime_type,
       std::unique_ptr<DownloadRequestHandleInterface> request_handle,
       const net::NetLogWithSource& net_log) override {
     return new DownloadItemImpl(delegate, download_id, path, url, mime_type,
                                 std::move(request_handle), net_log);
   }
 };
 
 }  // namespace
 
-DownloadManagerImpl::DownloadManagerImpl(
-    net::NetLog* net_log,
-    BrowserContext* browser_context)
+DownloadManagerImpl::DownloadManagerImpl(net::NetLog* net_log,
+                                         BrowserContext* browser_context)
     : item_factory_(new DownloadItemFactoryImpl()),
       file_factory_(new DownloadFileFactory()),
       shutdown_needed_(true),
       browser_context_(browser_context),
-      delegate_(NULL),
+      delegate_(nullptr),
       net_log_(net_log),
       weak_factory_(this) {
   DCHECK(browser_context);
 }
 
 DownloadManagerImpl::~DownloadManagerImpl() {
   DCHECK(!shutdown_needed_);
 }
 
 DownloadItemImpl* DownloadManagerImpl::CreateActiveItem(
     uint32_t id,
     const DownloadCreateInfo& info) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   DCHECK(!base::ContainsKey(downloads_, id));
   net::NetLogWithSource net_log =
       net::NetLogWithSource::Make(net_log_, net::NetLogSourceType::DOWNLOAD);
   DownloadItemImpl* download =
       item_factory_->CreateActiveItem(this, id, info, net_log);
-  downloads_[id] = download;
+  downloads_[id] = base::WrapUnique(download);
   downloads_by_guid_[download->GetGuid()] = download;
   return download;
 }
 
 void DownloadManagerImpl::GetNextId(const DownloadIdCallback& callback) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   if (delegate_) {
     delegate_->GetNextId(callback);
     return;
   }
@@ skipping 64 matching lines @@
 
   for (auto& observer : observers_)
     observer.ManagerGoingDown(this);
   // TODO(benjhayden): Consider clearing observers_.
 
   // If there are in-progress downloads, cancel them. This also goes for
   // dangerous downloads which will remain in history if they aren't explicitly
   // accepted or discarded. Canceling will remove the intermediate download
   // file.
   for (const auto& it : downloads_) {
-    DownloadItemImpl* download = it.second;
+    DownloadItemImpl* download = it.second.get();
     if (download->GetState() == DownloadItem::IN_PROGRESS)
       download->Cancel(false);
   }
-  base::STLDeleteValues(&downloads_);
+  downloads_.clear();
   downloads_by_guid_.clear();
   url_downloaders_.clear();
 
   // We'll have nothing more to report to the observers after this point.
   observers_.Clear();
 
   if (delegate_)
     delegate_->Shutdown();
-  delegate_ = NULL;
+  delegate_ = nullptr;
 }
 
 void DownloadManagerImpl::StartDownload(
     std::unique_ptr<DownloadCreateInfo> info,
     std::unique_ptr<ByteStreamReader> stream,
     const DownloadUrlParameters::OnStartedCallback& on_started) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   DCHECK(info);
   // |stream| is only non-nil if the download request was successful.
   DCHECK((info->result == DOWNLOAD_INTERRUPT_REASON_NONE && stream.get()) ||
@@ skipping 15 matching lines @@
 }
 
 void DownloadManagerImpl::StartDownloadWithId(
     std::unique_ptr<DownloadCreateInfo> info,
     std::unique_ptr<ByteStreamReader> stream,
     const DownloadUrlParameters::OnStartedCallback& on_started,
     bool new_download,
     uint32_t id) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   DCHECK_NE(content::DownloadItem::kInvalidId, id);
-  DownloadItemImpl* download = NULL;
+  DownloadItemImpl* download = nullptr;
   if (new_download) {
     download = CreateActiveItem(id, *info);
   } else {
-    DownloadMap::iterator item_iterator = downloads_.find(id);
+    auto item_iterator = downloads_.find(id);
     // Trying to resume an interrupted download.
     if (item_iterator == downloads_.end() ||
         (item_iterator->second->GetState() == DownloadItem::CANCELLED)) {
       // If the download is no longer known to the DownloadManager, then it was
       // removed after it was resumed. Ignore. If the download is cancelled
       // while resuming, then also ignore the request.
       info->request_handle->CancelRequest();
       if (!on_started.is_null())
-        on_started.Run(NULL, DOWNLOAD_INTERRUPT_REASON_USER_CANCELED);
+        on_started.Run(nullptr, DOWNLOAD_INTERRUPT_REASON_USER_CANCELED);
       // The ByteStreamReader lives and dies on the FILE thread.
       if (info->result == DOWNLOAD_INTERRUPT_REASON_NONE)
         BrowserThread::DeleteSoon(BrowserThread::FILE, FROM_HERE,
                                   stream.release());
       return;
     }
-    download = item_iterator->second;
+    download = item_iterator->second.get();
   }
 
   base::FilePath default_download_directory;
   if (delegate_) {
     base::FilePath website_save_directory;  // Unused
     bool skip_dir_check = false;            // Unused
     delegate_->GetSaveDir(GetBrowserContext(), &website_save_directory,
                           &default_download_directory, &skip_dir_check);
   }
 
@@ skipping 23 matching lines @@
       observer.OnDownloadCreated(this, download);
   }
 
   if (!on_started.is_null())
     on_started.Run(download, DOWNLOAD_INTERRUPT_REASON_NONE);
 }
 
 void DownloadManagerImpl::CheckForHistoryFilesRemoval() {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   for (const auto& it : downloads_) {
-    DownloadItemImpl* item = it.second;
+    DownloadItemImpl* item = it.second.get();
     CheckForFileRemoval(item);
   }
 }
 
 void DownloadManagerImpl::CheckForFileRemoval(DownloadItemImpl* download_item) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   if ((download_item->GetState() == DownloadItem::COMPLETE) &&
       !download_item->GetFileExternallyRemoved() &&
       delegate_) {
     delegate_->CheckForFileExistence(
@@ skipping 43 matching lines @@
     const DownloadItemImplCreated& item_created,
     uint32_t id) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   DCHECK_NE(content::DownloadItem::kInvalidId, id);
   DCHECK(!base::ContainsKey(downloads_, id));
   net::NetLogWithSource net_log =
       net::NetLogWithSource::Make(net_log_, net::NetLogSourceType::DOWNLOAD);
   DownloadItemImpl* download_item = item_factory_->CreateSavePageItem(
       this, id, main_file_path, page_url, mime_type, std::move(request_handle),
       net_log);
-  downloads_[download_item->GetId()] = download_item;
+  downloads_[download_item->GetId()] = base::WrapUnique(download_item);
   DCHECK(!base::ContainsKey(downloads_by_guid_, download_item->GetGuid()));
   downloads_by_guid_[download_item->GetGuid()] = download_item;
   for (auto& observer : observers_)
     observer.OnDownloadCreated(this, download_item);
   if (!item_created.is_null())
     item_created.Run(download_item);
 }
 
 void DownloadManagerImpl::OnSavePackageSuccessfullyFinished(
     DownloadItem* download_item) {
@@ skipping 28 matching lines @@
 
 DownloadFileFactory* DownloadManagerImpl::GetDownloadFileFactoryForTesting() {
   return file_factory_.get();
 }
 
 void DownloadManagerImpl::DownloadRemoved(DownloadItemImpl* download) {
   if (!download)
     return;
 
   downloads_by_guid_.erase(download->GetGuid());
-
-  uint32_t download_id = download->GetId();
-  if (downloads_.erase(download_id) == 0)
-    return;
-  delete download;
+  downloads_.erase(download->GetId());
 }
 
 void DownloadManagerImpl::AddUrlDownloader(
     std::unique_ptr<UrlDownloader, BrowserThread::DeleteOnIOThread>
         downloader) {
   if (downloader)
     url_downloaders_.push_back(std::move(downloader));
 }
 
 void DownloadManagerImpl::RemoveUrlDownloader(UrlDownloader* downloader) {
@@ skipping 79 matching lines @@
           const DownloadItemImpl* download_item) {
   return url_filter.Run(download_item->GetURL()) &&
          download_item->GetStartTime() >= remove_begin &&
          (remove_end.is_null() || download_item->GetStartTime() < remove_end);
 }
 
 }  // namespace
 
 int DownloadManagerImpl::RemoveDownloads(const DownloadRemover& remover) {
   int count = 0;
-  DownloadMap::const_iterator it = downloads_.begin();
+  auto it = downloads_.begin();
   while (it != downloads_.end()) {
-    DownloadItemImpl* download = it->second;
+    DownloadItemImpl* download = it->second.get();
 
     // Increment done here to protect against invalidation below.
     ++it;
 
     if (download->GetState() != DownloadItem::IN_PROGRESS &&
         remover.Run(download)) {
       download->Remove();
       count++;
     }
   }
@@ skipping 61 matching lines @@
     const std::string& last_modified,
     int64_t received_bytes,
     int64_t total_bytes,
     const std::string& hash,
     DownloadItem::DownloadState state,
     DownloadDangerType danger_type,
     DownloadInterruptReason interrupt_reason,
     bool opened) {
   if (base::ContainsKey(downloads_, id)) {
     NOTREACHED();
-    return NULL;
+    return nullptr;
   }
   DCHECK(!base::ContainsKey(downloads_by_guid_, guid));
   DownloadItemImpl* item = item_factory_->CreatePersistedItem(
       this, guid, id, current_path, target_path, url_chain, referrer_url,
       site_url, tab_url, tab_refererr_url, mime_type, original_mime_type,
       start_time, end_time, etag, last_modified, received_bytes, total_bytes,
       hash, state, danger_type, interrupt_reason, opened,
       net::NetLogWithSource::Make(net_log_, net::NetLogSourceType::DOWNLOAD));
-  downloads_[id] = item;
+  downloads_[id] = base::WrapUnique(item);
   downloads_by_guid_[guid] = item;
   for (auto& observer : observers_)
     observer.OnDownloadCreated(this, item);
   DVLOG(20) << __func__ << "() download = " << item->DebugString(true);
   return item;
 }
 
 int DownloadManagerImpl::InProgressCount() const {
   int count = 0;
   for (const auto& it : downloads_) {
@@ skipping 12 matching lines @@
         it.second->GetDangerType() != DOWNLOAD_DANGER_TYPE_DANGEROUS_HOST &&
         it.second->GetDangerType() !=
             DOWNLOAD_DANGER_TYPE_POTENTIALLY_UNWANTED) {
       ++count;
     }
   }
   return count;
 }
 
 DownloadItem* DownloadManagerImpl::GetDownload(uint32_t download_id) {
-  return base::ContainsKey(downloads_, download_id) ? downloads_[download_id]
-                                                    : nullptr;
+  return base::ContainsKey(downloads_, download_id)
+             ? downloads_[download_id].get()
+             : nullptr;
 }
 
 DownloadItem* DownloadManagerImpl::GetDownloadByGuid(const std::string& guid) {
   DCHECK(guid == base::ToUpperASCII(guid));
   return base::ContainsKey(downloads_by_guid_, guid) ? downloads_by_guid_[guid]
                                                      : nullptr;
 }
 
 void DownloadManagerImpl::GetAllDownloads(DownloadVector* downloads) {
   for (const auto& it : downloads_) {
-    downloads->push_back(it.second);
+    downloads->push_back(it.second.get());
   }
 }
 
 void DownloadManagerImpl::OpenDownload(DownloadItemImpl* download) {
   int num_unopened = 0;
   for (const auto& it : downloads_) {
-    DownloadItemImpl* item = it.second;
+    DownloadItemImpl* item = it.second.get();
     if ((item->GetState() == DownloadItem::COMPLETE) &&
         !item->GetOpened())
       ++num_unopened;
   }
   RecordOpensOutstanding(num_unopened);
 
   if (delegate_)
     delegate_->OpenDownload(download);
 }
 
 void DownloadManagerImpl::ShowDownloadInShell(DownloadItemImpl* download) {
   if (delegate_)
     delegate_->ShowDownloadInShell(download);
 }
 
 }  // namespace content