Remove stl_util's deletion function use from content/.

content/browser/download/save_package.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/save_package.h"
 
 #include <algorithm>
 #include <utility>
 
 #include "base/bind.h"
 #include "base/files/file_path.h"
 #include "base/files/file_util.h"
 #include "base/i18n/file_util_icu.h"
 #include "base/logging.h"
 #include "base/macros.h"
+#include "base/memory/ptr_util.h"
 #include "base/message_loop/message_loop.h"
 #include "base/stl_util.h"
 #include "base/strings/string_piece.h"
 #include "base/strings/string_split.h"
 #include "base/strings/sys_string_conversions.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/threading/thread.h"
 #include "build/build_config.h"
 #include "components/url_formatter/url_formatter.h"
 #include "content/browser/bad_message.h"
@@ skipping 159 matching lines @@
     Cancel(true);
   }
 
   // We should no longer be observing the DownloadItem at this point.
   CHECK(!download_);
 
   DCHECK_EQ(all_save_items_count_, waiting_item_queue_.size() +
                                        completed_count() + in_process_count());
 
   // Free all SaveItems.
-  base::STLDeleteElements(&waiting_item_queue_);
-  base::STLDeleteValues(&in_progress_items_);
-  base::STLDeleteValues(&saved_success_items_);
-  base::STLDeleteValues(&saved_failed_items_);
+  waiting_item_queue_.clear();
+  in_progress_items_.clear();
+  saved_success_items_.clear();
+  saved_failed_items_.clear();
   // Clear containers that contain (now dangling/invalid) pointers to the
   // save items freed above.  This is not strictly required (as the containers
   // will be destructed soon by ~SavePackage), but seems like good code hygiene.
   frame_tree_node_id_to_contained_save_items_.clear();
   frame_tree_node_id_to_save_item_.clear();
   url_to_save_item_.clear();
 
   file_manager_ = nullptr;
 }
 
@@ skipping 85 matching lines @@
     GetSavableResourceLinks();
   } else if (save_type_ == SAVE_PAGE_TYPE_AS_MHTML) {
     MHTMLGenerationParams mhtml_generation_params(saved_main_file_path_);
     web_contents()->GenerateMHTML(
         mhtml_generation_params,
         base::Bind(&SavePackage::OnMHTMLGenerated, this));
   } else {
     DCHECK_EQ(SAVE_PAGE_TYPE_AS_ONLY_HTML, save_type_);
     wait_state_ = NET_FILES;
     // Add this item to waiting list.
-    waiting_item_queue_.push_back(new SaveItem(
+    waiting_item_queue_.push_back(base::WrapUnique(new SaveItem(
         page_url_, Referrer(), this, SaveFileCreateInfo::SAVE_FILE_FROM_NET,
         FrameTreeNode::kFrameTreeNodeInvalidId,
-        web_contents()->GetMainFrame()->GetFrameTreeNodeId()));
+        web_contents()->GetMainFrame()->GetFrameTreeNodeId())));
     all_save_items_count_ = 1;
     download_->SetTotalBytes(1);
 
     DoSavingProcess();
   }
 }
 
 void SavePackage::OnMHTMLGenerated(int64_t size) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   if (size <= 0) {
@@ skipping 163 matching lines @@
 
   return true;
 }
 
 // We have received a message from SaveFileManager about a new saving job. We
 // find a SaveItem and store it in our in_progress list.
 void SavePackage::StartSave(const SaveFileCreateInfo* info) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   DCHECK(info);
 
-  SaveItemIdMap::iterator it = in_progress_items_.find(info->save_item_id);
+  auto it = in_progress_items_.find(info->save_item_id);
   if (it == in_progress_items_.end()) {
     // If not found, we must have cancel action.
     DCHECK(canceled());
     return;
   }
-  SaveItem* save_item = it->second;
+  SaveItem* save_item = it->second.get();
 
   DCHECK(!saved_main_file_path_.empty());
 
   save_item->SetTotalBytes(info->total_bytes);
 
   // Determine the proper path for a saving job, by choosing either the default
   // save directory, or prompting the user.
   DCHECK(!save_item->has_final_name());
   if (info->url != page_url_) {
     base::FilePath::StringType generated_name;
@@ skipping 41 matching lines @@
     // Inform backend to serialize the all frames' DOM and send serialized
     // HTML data back.
     GetSerializedHtmlWithLocalLinks();
   }
 }
 
 SaveItem* SavePackage::LookupInProgressSaveItem(SaveItemId save_item_id) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   auto it = in_progress_items_.find(save_item_id);
   if (it != in_progress_items_.end()) {
-    SaveItem* save_item = it->second;
+    SaveItem* save_item = it->second.get();
     DCHECK_EQ(SaveItem::IN_PROGRESS, save_item->state());
     return save_item;
   }
   return nullptr;
 }
 
 void SavePackage::PutInProgressItemToSavedMap(SaveItem* save_item) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
-  SaveItemIdMap::iterator it = in_progress_items_.find(save_item->id());
+  auto it = in_progress_items_.find(save_item->id());
   DCHECK(it != in_progress_items_.end());
-  DCHECK_EQ(save_item, it->second);
+  DCHECK_EQ(save_item, it->second.get());
+  std::unique_ptr<SaveItem> owned_item = std::move(it->second);
   in_progress_items_.erase(it);
 
   SaveItemIdMap& map = save_item->success() ?
       saved_success_items_ : saved_failed_items_;
   DCHECK(!base::ContainsKey(map, save_item->id()));
-  map[save_item->id()] = save_item;
+  map[save_item->id()] = std::move(owned_item);
 }
 
 // Called for updating saving state.
 bool SavePackage::UpdateSaveProgress(SaveItemId save_item_id,
                                      int64_t size,
                                      bool write_success) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   // Because we might have canceled this saving job before,
   // so we might not find corresponding SaveItem.
   SaveItem* save_item = LookupInProgressSaveItem(save_item_id);
@@ skipping 16 matching lines @@
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   // If we haven't moved out of the initial state, there's nothing to cancel and
   // there won't be valid pointers for |file_manager_| or |download_|.
   if (wait_state_ == INITIALIZE)
     return;
 
   // When stopping, if it still has some items in in_progress, cancel them.
   DCHECK(canceled());
   if (in_process_count()) {
     for (const auto& it : in_progress_items_) {
-      SaveItem* save_item = it.second;
+      SaveItem* save_item = it.second.get();
       DCHECK_EQ(SaveItem::IN_PROGRESS, save_item->state());
       save_item->Cancel();
     }
     // Remove all in progress item to saved map. For failed items, they will
     // be put into saved_failed_items_, for successful item, they will be put
     // into saved_success_items_.
     while (in_process_count())
-      PutInProgressItemToSavedMap(in_progress_items_.begin()->second);
+      PutInProgressItemToSavedMap(in_progress_items_.begin()->second.get());
   }
 
   // This vector contains the save ids of the save files which SaveFileManager
   // needs to remove from its save_file_map_.
   std::vector<SaveItemId> save_item_ids;
   for (const auto& it : saved_success_items_)
     save_item_ids.push_back(it.first);
   for (const auto& it : saved_failed_items_)
     save_item_ids.push_back(it.first);
 
@@ skipping 53 matching lines @@
   if (wrote_to_completed_file_)
     RecordSavePackageEvent(SAVE_PACKAGE_WRITE_TO_COMPLETED);
 
   if (wrote_to_failed_file_)
     RecordSavePackageEvent(SAVE_PACKAGE_WRITE_TO_FAILED);
 
   // This vector contains the save ids of the save files which SaveFileManager
   // needs to remove from its |save_file_map_|.
   std::vector<SaveItemId> list_of_failed_save_item_ids;
   for (const auto& it : saved_failed_items_) {
-    const SaveItem* save_item = it.second;
+    const SaveItem* save_item = it.second.get();
     DCHECK_EQ(it.first, save_item->id());
     list_of_failed_save_item_ids.push_back(save_item->id());
   }
 
   BrowserThread::PostTask(
       BrowserThread::FILE, FROM_HERE,
       base::Bind(&SaveFileManager::RemoveSavedFileFromFileMap, file_manager_,
                  list_of_failed_save_item_ids));
 
   if (download_) {
@@ skipping 65 matching lines @@
       base::Bind(&SaveFileManager::CancelSave, file_manager_, save_item->id()));
 }
 
 void SavePackage::SaveNextFile(bool process_all_remaining_items) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   DCHECK(web_contents());
   DCHECK(!waiting_item_queue_.empty());
 
   do {
     // Pop SaveItem from waiting list.
-    SaveItem* save_item = waiting_item_queue_.front();
+    std::unique_ptr<SaveItem> save_item =
+        std::move(waiting_item_queue_.front());
+    SaveItem* save_item_ptr = save_item.get();
     waiting_item_queue_.pop_front();
 
     // Add the item to |in_progress_items_|.
     DCHECK(!base::ContainsKey(in_progress_items_, save_item->id()));
-    in_progress_items_[save_item->id()] = save_item;
-    save_item->Start();
+    in_progress_items_[save_item_ptr->id()] = std::move(save_item);
+    save_item_ptr->Start();
 
     // Find the frame responsible for making the network request below - it will
     // be used in security checks made later by ResourceDispatcherHostImpl.
     int requester_frame_tree_node_id =
-        save_item->save_source() == SaveFileCreateInfo::SAVE_FILE_FROM_NET
-            ? save_item->container_frame_tree_node_id()
-            : save_item->frame_tree_node_id();
+        save_item_ptr->save_source() == SaveFileCreateInfo::SAVE_FILE_FROM_NET
+            ? save_item_ptr->container_frame_tree_node_id()
+            : save_item_ptr->frame_tree_node_id();
     DCHECK_NE(FrameTreeNode::kFrameTreeNodeInvalidId,
               requester_frame_tree_node_id);
     FrameTreeNode* requester_frame_tree_node =
         FrameTreeNode::GloballyFindByID(requester_frame_tree_node_id);
     if (!requester_frame_tree_node) {
-      save_item->Finish(0, /* is_success = */ false);
+      save_item_ptr->Finish(0, /* is_success = */ false);
       continue;
     }
     RenderFrameHostImpl* requester_frame =
         requester_frame_tree_node->current_frame_host();
 
     file_manager_->SaveURL(
-        save_item->id(), save_item->url(), save_item->referrer(),
+        save_item_ptr->id(), save_item_ptr->url(), save_item_ptr->referrer(),
         requester_frame->GetProcess()->GetID(),
         requester_frame->render_view_host()->GetRoutingID(),
-        requester_frame->routing_id(), save_item->save_source(),
-        save_item->full_path(),
+        requester_frame->routing_id(), save_item_ptr->save_source(),
+        save_item_ptr->full_path(),
         web_contents()->GetBrowserContext()->GetResourceContext(), this);
   } while (process_all_remaining_items && !waiting_item_queue_.empty());
 }
 
 int SavePackage::PercentComplete() {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   if (!all_save_items_count_)
     return 0;
   if (!in_process_count())
     return 100;
@@ skipping 12 matching lines @@
   if (save_type_ == SAVE_PAGE_TYPE_AS_COMPLETE_HTML) {
     // We guarantee that images and JavaScripts must be downloaded first.
     // So when finishing all those sub-resources, we will know which
     // sub-resource's link can be replaced with local file path, which
     // sub-resource's link need to be replaced with absolute URL which
     // point to its internet address because it got error when saving its data.
 
     // Start a new SaveItem job if we still have job in waiting queue.
     if (waiting_item_queue_.size()) {
       DCHECK_EQ(NET_FILES, wait_state_);
-      const SaveItem* save_item = waiting_item_queue_.front();
+      const SaveItem* save_item = waiting_item_queue_.front().get();
       if (save_item->save_source() != SaveFileCreateInfo::SAVE_FILE_FROM_DOM) {
         SaveNextFile(false);
       } else if (!in_process_count()) {
         // If there is no in-process SaveItem, it means all sub-resources
         // have been processed. Now we need to start serializing HTML DOM
         // for the current page to get the generated HTML data.
         wait_state_ = HTML_DATA;
         // All non-HTML resources have been finished, start all remaining
         // HTML files.
         SaveNextFile(true);
@@ skipping 272 matching lines @@
     int container_frame_tree_node_id,
     int save_item_frame_tree_node_id,
     const GURL& url,
     const Referrer& referrer,
     SaveFileCreateInfo::SaveFileSource save_source) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   Referrer sanitized_referrer = Referrer::SanitizeForRequest(url, referrer);
   SaveItem* save_item =
       new SaveItem(url, sanitized_referrer, this, save_source,
                    save_item_frame_tree_node_id, container_frame_tree_node_id);
-  waiting_item_queue_.push_back(save_item);
+  waiting_item_queue_.push_back(base::WrapUnique(save_item));
 
   frame_tree_node_id_to_contained_save_items_[container_frame_tree_node_id]
       .push_back(save_item);
   return save_item;
 }
 
 SaveItem* SavePackage::CreatePendingSaveItemDeduplicatingByUrl(
     int container_frame_tree_node_id,
     int save_item_frame_tree_node_id,
     const GURL& url,
@@ skipping 53 matching lines @@
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   --number_of_frames_pending_response_;
   DCHECK_LE(0, number_of_frames_pending_response_);
   if (number_of_frames_pending_response_ != 0)
     return;  // Need to wait for more responses from RenderFrames.
 
   // Sort |waiting_item_queue_| so that frames go last (frames are identified by
   // SAVE_FILE_FROM_DOM in the comparison function below).
   std::stable_sort(
       waiting_item_queue_.begin(), waiting_item_queue_.end(),
-      [](SaveItem* x, SaveItem* y) {
+      [](const std::unique_ptr<SaveItem>& x,
+         const std::unique_ptr<SaveItem>& y) {
         DCHECK(x);
         DCHECK(y);
         return (x->save_source() != SaveFileCreateInfo::SAVE_FILE_FROM_DOM) &&
                (y->save_source() == SaveFileCreateInfo::SAVE_FILE_FROM_DOM);
       });
 
   all_save_items_count_ = static_cast<int>(waiting_item_queue_.size());
 
   // We use total bytes as the total number of files we want to save.
   // Hack to avoid touching download_ after user cancel.
@@ skipping 256 matching lines @@
 }
 
 void SavePackage::FinalizeDownloadEntry() {
   DCHECK(download_);
 
   download_manager_->OnSavePackageSuccessfullyFinished(download_);
   RemoveObservers();
 }
 
 }  // namespace content