Remove stl_util's deletion function use from chrome/.

chrome/browser/plugins/plugin_finder.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/plugins/plugin_finder.h"
 
 #include <stddef.h>
 
 #include "base/bind.h"
 #include "base/json/json_reader.h"
+#include "base/memory/ptr_util.h"
 #include "base/message_loop/message_loop.h"
 #include "base/metrics/histogram_macros.h"
-#include "base/stl_util.h"
 #include "base/strings/sys_string_conversions.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/values.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/plugins/plugin_metadata.h"
 #include "chrome/common/features.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/grit/browser_resources.h"
 #include "components/prefs/pref_registry_simple.h"
 #include "components/prefs/pref_service.h"
@@ skipping 64 matching lines @@
     success = (*mime_type_it)->GetAsString(&mime_type_str);
     DCHECK(success);
     if (matching_mime_types) {
       plugin->AddMatchingMimeType(mime_type_str);
     } else {
       plugin->AddMimeType(mime_type_str);
     }
   }
 }
 
-PluginMetadata* CreatePluginMetadata(
+std::unique_ptr<PluginMetadata> CreatePluginMetadata(
     const std::string& identifier,
     const base::DictionaryValue* plugin_dict) {
   std::string url;
   bool success = plugin_dict->GetString("url", &url);
   std::string help_url;
   plugin_dict->GetString("help_url", &help_url);
   base::string16 name;
   success = plugin_dict->GetString("name", &name);
   DCHECK(success);
   bool display_url = false;
   plugin_dict->GetBoolean("displayurl", &display_url);
   base::string16 group_name_matcher;
   success = plugin_dict->GetString("group_name_matcher", &group_name_matcher);
   DCHECK(success);
   std::string language_str;
   plugin_dict->GetString("lang", &language_str);
 
-  PluginMetadata* plugin = new PluginMetadata(identifier,
-                                              name,
-                                              display_url,
-                                              GURL(url),
-                                              GURL(help_url),
-                                              group_name_matcher,
-                                              language_str);
+  std::unique_ptr<PluginMetadata> plugin = base::MakeUnique<PluginMetadata>(
+      identifier, name, display_url, GURL(url), GURL(help_url),
+      group_name_matcher, language_str);
   const base::ListValue* versions = NULL;
   if (plugin_dict->GetList("versions", &versions)) {
     for (base::ListValue::const_iterator it = versions->begin();
          it != versions->end(); ++it) {
       base::DictionaryValue* version_dict = NULL;
       if (!(*it)->GetAsDictionary(&version_dict)) {
         NOTREACHED();
         continue;
       }
       std::string version;
       success = version_dict->GetString("version", &version);
       DCHECK(success);
       std::string status_str;
       success = version_dict->GetString("status", &status_str);
       DCHECK(success);
       PluginMetadata::SecurityStatus status =
           PluginMetadata::SECURITY_STATUS_UP_TO_DATE;
       success = PluginMetadata::ParseSecurityStatus(status_str, &status);
       DCHECK(success);
       plugin->AddVersion(base::Version(version), status);
     }
   }
 
-  LoadMimeTypes(false, plugin_dict, plugin);
-  LoadMimeTypes(true, plugin_dict, plugin);
+  LoadMimeTypes(false, plugin_dict, plugin.get());
+  LoadMimeTypes(true, plugin_dict, plugin.get());
   return plugin;
 }
 
 void RecordBuiltInPluginListError(PluginListError error_code) {
   UMA_HISTOGRAM_ENUMERATION("PluginFinder.BuiltInPluginList.ErrorCode",
                             static_cast<int>(error_code),
                             static_cast<int>(PluginListError::NUM_VALUES));
 }
 
 }  // namespace
@@ skipping 82 matching lines @@
     RecordBuiltInPluginListError(PluginListError::SCHEMA_ERROR);
     return nullptr;
   }
 
   DCHECK_EQ(base::JSONReader::JSON_NO_ERROR, error_code);
   RecordBuiltInPluginListError(PluginListError::PLUGIN_LIST_NO_ERROR);
   return static_cast<base::DictionaryValue*>(value.release());
 }
 
 PluginFinder::~PluginFinder() {
-#if BUILDFLAG(ENABLE_PLUGIN_INSTALLATION)
-  base::STLDeleteValues(&installers_);
-#endif
-  base::STLDeleteValues(&identifier_plugin_);
 }
 
 #if BUILDFLAG(ENABLE_PLUGIN_INSTALLATION)
 bool PluginFinder::FindPlugin(
     const std::string& mime_type,
     const std::string& language,
     PluginInstaller** installer,
     std::unique_ptr<PluginMetadata>* plugin_metadata) {
   if (g_browser_process->local_state()->GetBoolean(prefs::kDisablePluginFinder))
     return false;
 
   base::AutoLock lock(mutex_);
-  PluginMap::const_iterator metadata_it = identifier_plugin_.begin();
+  auto metadata_it = identifier_plugin_.begin();
   for (; metadata_it != identifier_plugin_.end(); ++metadata_it) {
     if (language == metadata_it->second->language() &&
         metadata_it->second->HasMimeType(mime_type)) {
       *plugin_metadata = metadata_it->second->Clone();
 
-      std::map<std::string, PluginInstaller*>::const_iterator installer_it =
-          installers_.find(metadata_it->second->identifier());
+      auto installer_it = installers_.find(metadata_it->second->identifier());
       DCHECK(installer_it != installers_.end());
-      *installer = installer_it->second;
+      *installer = installer_it->second.get();
       return true;
     }
   }
   return false;
 }
 
 bool PluginFinder::FindPluginWithIdentifier(
     const std::string& identifier,
     PluginInstaller** installer,
     std::unique_ptr<PluginMetadata>* plugin_metadata) {
   base::AutoLock lock(mutex_);
-  PluginMap::const_iterator metadata_it = identifier_plugin_.find(identifier);
+  auto metadata_it = identifier_plugin_.find(identifier);
   if (metadata_it == identifier_plugin_.end())
     return false;
   *plugin_metadata = metadata_it->second->Clone();
 
   if (installer) {
-    std::map<std::string, PluginInstaller*>::const_iterator installer_it =
-        installers_.find(identifier);
+    auto installer_it = installers_.find(identifier);
     if (installer_it == installers_.end())
       return false;
-    *installer = installer_it->second;
+    *installer = installer_it->second.get();
   }
   return true;
 }
 #endif
 
 void PluginFinder::ReinitializePlugins(
     const base::DictionaryValue* plugin_list) {
   base::AutoLock lock(mutex_);
   int version = 0;  // If no version is defined, we default to 0.
   const char kVersionKey[] = "x-version";
   plugin_list->GetInteger(kVersionKey, &version);
   if (version <= version_)
     return;
 
   version_ = version;
 
-  base::STLDeleteValues(&identifier_plugin_);
+  identifier_plugin_.clear();
 
   for (base::DictionaryValue::Iterator plugin_it(*plugin_list);
       !plugin_it.IsAtEnd(); plugin_it.Advance()) {
     const base::DictionaryValue* plugin = NULL;
     const std::string& identifier = plugin_it.key();
     if (plugin_list->GetDictionaryWithoutPathExpansion(identifier, &plugin)) {
       DCHECK(!identifier_plugin_[identifier]);
       identifier_plugin_[identifier] = CreatePluginMetadata(identifier, plugin);
 
 #if BUILDFLAG(ENABLE_PLUGIN_INSTALLATION)
       if (installers_.find(identifier) == installers_.end())
-        installers_[identifier] = new PluginInstaller();
+        installers_[identifier] = base::MakeUnique<PluginInstaller>();
 #endif
     }
   }
 }
 
 std::unique_ptr<PluginMetadata> PluginFinder::GetPluginMetadata(
     const content::WebPluginInfo& plugin) {
   base::AutoLock lock(mutex_);
-  for (PluginMap::const_iterator it = identifier_plugin_.begin();
-       it != identifier_plugin_.end(); ++it) {
-    if (!it->second->MatchesPlugin(plugin))
+  for (const auto& plugin_pair : identifier_plugin_) {
+    if (!plugin_pair.second->MatchesPlugin(plugin))
       continue;
 
-    return it->second->Clone();
+    return plugin_pair.second->Clone();
   }
 
   // The plugin metadata was not found, create a dummy one holding
   // the name, identifier and group name only.
   std::string identifier = GetIdentifier(plugin);
-  PluginMetadata* metadata = new PluginMetadata(identifier,
-                                                GetGroupName(plugin),
-                                                false,
-                                                GURL(),
-                                                GURL(),
-                                                plugin.name,
-                                                std::string());
+  std::unique_ptr<PluginMetadata> metadata = base::MakeUnique<PluginMetadata>(
+      identifier, GetGroupName(plugin), false, GURL(), GURL(), plugin.name,
+      std::string());
   for (size_t i = 0; i < plugin.mime_types.size(); ++i)
     metadata->AddMatchingMimeType(plugin.mime_types[i].mime_type);
 
   DCHECK(metadata->MatchesPlugin(plugin));
   if (identifier_plugin_.find(identifier) != identifier_plugin_.end())
     identifier = GetLongIdentifier(plugin);
 
   DCHECK(identifier_plugin_.find(identifier) == identifier_plugin_.end());
-  identifier_plugin_[identifier] = metadata;
-  return metadata->Clone();
+  identifier_plugin_[identifier] = std::move(metadata);
+  return identifier_plugin_[identifier]->Clone();
 }