Remove stl_util's deletion function use from media galleries.

chrome/browser/media_galleries/media_file_system_registry.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/media_galleries/media_file_system_registry.h"
 
 #include <stddef.h>
 
 #include <set>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/files/file_path.h"
 #include "base/macros.h"
+#include "base/memory/ptr_util.h"
 #include "base/stl_util.h"
 #include "chrome/browser/media_galleries/fileapi/media_file_system_backend.h"
 #include "chrome/browser/media_galleries/gallery_watch_manager.h"
 #include "chrome/browser/media_galleries/imported_media_gallery_registry.h"
 #include "chrome/browser/media_galleries/media_file_system_context.h"
 #include "chrome/browser/media_galleries/media_galleries_dialog_controller.h"
 #include "chrome/browser/media_galleries/media_galleries_histograms.h"
 #include "chrome/browser/media_galleries/media_galleries_preferences_factory.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/common/chrome_paths.h"
@@ skipping 61 matching lines @@
 // back informs the caller.
 class RPHReferenceManager {
  public:
   // |no_references_callback| is called when the last WebContents reference
   // goes away. WebContents references are added through
   // ReferenceFromWebContents().
   explicit RPHReferenceManager(const base::Closure& no_references_callback);
   virtual ~RPHReferenceManager();
 
   // Remove all references, but don't call |no_references_callback|.
-  void Reset() { base::STLDeleteValues(&observer_map_); }
+  void Reset() { observer_map_.clear(); }
 
-  // Returns true if there are no references;
+  // Returns true if there are no references.
   bool empty() const { return observer_map_.empty(); }
 
   // Adds a reference to the passed |contents|. Calling this multiple times with
   // the same |contents| is a no-op.
   void ReferenceFromWebContents(content::WebContents* contents);
 
  private:
   class RPHWebContentsObserver : public content::WebContentsObserver {
    public:
     RPHWebContentsObserver(RPHReferenceManager* manager,
@@ skipping 17 matching lines @@
     void RemoveWebContentsObserver(WebContents* web_contents);
     bool HasWebContentsObservers() {
       return observed_web_contentses_.size() > 0;
     }
 
    private:
     void RenderProcessHostDestroyed(RenderProcessHost* host) override;
 
     RPHReferenceManager* manager_;
     RenderProcessHost* host_;
-    typedef std::map<WebContents*, RPHWebContentsObserver*> WCObserverMap;
-    WCObserverMap observed_web_contentses_;
+    std::map<WebContents*, std::unique_ptr<RPHWebContentsObserver>>
+        observed_web_contentses_;
   };
-  typedef std::map<const RenderProcessHost*, RPHObserver*> RPHObserverMap;
 
   // Handlers for observed events.
   void OnRenderProcessHostDestroyed(RenderProcessHost* rph);
   void OnWebContentsDestroyedOrNavigated(WebContents* contents);
 
   // A callback to call when the last RVH reference goes away.
   base::Closure no_references_callback_;
 
   // The set of render processes and web contents that may have references to
   // the file system ids this instance manages.
-  RPHObserverMap observer_map_;
+  std::map<const RenderProcessHost*, std::unique_ptr<RPHObserver>>
+      observer_map_;
 };
 
 RPHReferenceManager::RPHReferenceManager(
     const base::Closure& no_references_callback)
     : no_references_callback_(no_references_callback) {
 }
 
 RPHReferenceManager::~RPHReferenceManager() {
   Reset();
 }
 
 void RPHReferenceManager::ReferenceFromWebContents(
     content::WebContents* contents) {
   RenderProcessHost* rph = contents->GetRenderProcessHost();
-  RPHObserver* state = NULL;
   if (!base::ContainsKey(observer_map_, rph)) {
-    state = new RPHObserver(this, rph);
-    observer_map_[rph] = state;
-  } else {
-    state = observer_map_[rph];
+    observer_map_[rph] = base::MakeUnique<RPHObserver>(this, rph);
   }
-
-  state->AddWebContentsObserver(contents);
+  observer_map_[rph]->AddWebContentsObserver(contents);
 }
 
 RPHReferenceManager::RPHWebContentsObserver::RPHWebContentsObserver(
     RPHReferenceManager* manager,
     WebContents* web_contents)
     : content::WebContentsObserver(web_contents),
       manager_(manager) {
 }
 
 void RPHReferenceManager::RPHWebContentsObserver::WebContentsDestroyed() {
   manager_->OnWebContentsDestroyedOrNavigated(web_contents());
 }
 
 void RPHReferenceManager::RPHWebContentsObserver::NavigationEntryCommitted(
     const content::LoadCommittedDetails& load_details) {
   if (load_details.is_in_page)
     return;
 
   manager_->OnWebContentsDestroyedOrNavigated(web_contents());
 }
 
 RPHReferenceManager::RPHObserver::RPHObserver(
     RPHReferenceManager* manager, RenderProcessHost* host)
     : manager_(manager),
       host_(host) {
   host->AddObserver(this);
 }
 
 RPHReferenceManager::RPHObserver::~RPHObserver() {
-  base::STLDeleteValues(&observed_web_contentses_);
+  observed_web_contentses_.clear();
   if (host_)
     host_->RemoveObserver(this);
 }
 
 void RPHReferenceManager::RPHObserver::AddWebContentsObserver(
     WebContents* web_contents) {
   if (base::ContainsKey(observed_web_contentses_, web_contents))
     return;
 
-  RPHWebContentsObserver* observer =
-    new RPHWebContentsObserver(manager_, web_contents);
-  observed_web_contentses_[web_contents] = observer;
+  observed_web_contentses_[web_contents] =
+      base::MakeUnique<RPHWebContentsObserver>(manager_, web_contents);
 }
 
 void RPHReferenceManager::RPHObserver::RemoveWebContentsObserver(
     WebContents* web_contents) {
-  WCObserverMap::iterator wco_iter =
-      observed_web_contentses_.find(web_contents);
-  DCHECK(wco_iter != observed_web_contentses_.end());
-  delete wco_iter->second;
-  observed_web_contentses_.erase(wco_iter);
+  DCHECK(observed_web_contentses_.find(web_contents) !=
+         observed_web_contentses_.end());
+  observed_web_contentses_.erase(web_contents);
 }
 
 void RPHReferenceManager::RPHObserver::RenderProcessHostDestroyed(
     RenderProcessHost* host) {
   host_ = NULL;
   manager_->OnRenderProcessHostDestroyed(host);
 }
 
 void RPHReferenceManager::OnRenderProcessHostDestroyed(
     RenderProcessHost* rph) {
-  RPHObserverMap::iterator rph_info = observer_map_.find(rph);
+  auto rph_info = observer_map_.find(rph);
   // This could be a potential problem if the RPH is navigated to a page on the
   // same renderer (triggering OnWebContentsDestroyedOrNavigated()) and then the
   // renderer crashes.
   if (rph_info == observer_map_.end()) {
     NOTREACHED();
     return;
   }
-  delete rph_info->second;
   observer_map_.erase(rph_info);
   if (observer_map_.empty())
     no_references_callback_.Run();
 }
 
 void RPHReferenceManager::OnWebContentsDestroyedOrNavigated(
     WebContents* contents) {
   RenderProcessHost* rph = contents->GetRenderProcessHost();
-  RPHObserverMap::iterator rph_info = observer_map_.find(rph);
+  auto rph_info = observer_map_.find(rph);
   DCHECK(rph_info != observer_map_.end());
 
   rph_info->second->RemoveWebContentsObserver(contents);
   if (!rph_info->second->HasWebContentsObservers())
     OnRenderProcessHostDestroyed(rph);
 }
 
 }  // namespace
 
 MediaFileSystemInfo::MediaFileSystemInfo(const base::string16& fs_name,
@@ skipping 614 matching lines @@
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   auto extension_hosts_it = extension_hosts_map_.find(profile);
   DCHECK(extension_hosts_it != extension_hosts_map_.end());
   extension_hosts_map_.erase(extension_hosts_it);
 
   auto profile_subscription_it = profile_subscription_map_.find(profile);
   DCHECK(profile_subscription_it != profile_subscription_map_.end());
   profile_subscription_map_.erase(profile_subscription_it);
 }