Remove stl_util's STLDeleteContainerPairSecondPointers from extensions.

extensions/browser/api/vpn_provider/vpn_service.cc

 // Copyright 2014 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 "extensions/browser/api/vpn_provider/vpn_service.h"
 
 #include <stdint.h>
 #include <utility>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/guid.h"
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
 #include "base/single_thread_task_runner.h"
-#include "base/stl_util.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "base/values.h"
 #include "chromeos/dbus/shill_third_party_vpn_driver_client.h"
 #include "chromeos/dbus/shill_third_party_vpn_observer.h"
 #include "chromeos/network/network_configuration_handler.h"
 #include "chromeos/network/network_profile.h"
 #include "chromeos/network/network_profile_handler.h"
 #include "chromeos/network/network_state.h"
@@ skipping 206 matching lines @@
   network_configuration_handler_->AddObserver(this);
   base::ThreadTaskRunnerHandle::Get()->PostTask(
       FROM_HERE,
       base::Bind(&VpnService::NetworkListChanged, weak_factory_.GetWeakPtr()));
 }
 
 VpnService::~VpnService() {
   network_configuration_handler_->RemoveObserver(this);
   network_state_handler_->RemoveObserver(this, FROM_HERE);
   extension_registry_->RemoveObserver(this);
-  base::STLDeleteContainerPairSecondPointers(key_to_configuration_map_.begin(),
-                                             key_to_configuration_map_.end());
 }
 
 void VpnService::SendShowAddDialogToExtension(const std::string& extension_id) {
   SendSignalToExtension(extension_id,
                         extensions::events::VPN_PROVIDER_ON_UI_EVENT,
                         api_vpn::OnUIEvent::kEventName,
                         api_vpn::OnUIEvent::Create(
                             api_vpn::UI_EVENT_SHOWADDDIALOG, std::string()));
 }
 
@@ skipping 183 matching lines @@
                                       const std::string& configuration_id,
                                       const SuccessCallback& success,
                                       const FailureCallback& failure) {
   // The ID is the configuration name for now. This may change in the future.
   const std::string key = GetKey(extension_id, configuration_id);
   if (!base::ContainsKey(key_to_configuration_map_, key)) {
     failure.Run(std::string(), std::string("Unauthorized access."));
     return;
   }
 
-  VpnConfiguration* configuration = key_to_configuration_map_[key];
+  VpnConfiguration* configuration = key_to_configuration_map_[key].get();
   const std::string service_path = configuration->service_path();
   if (service_path.empty()) {
     failure.Run(std::string(), std::string("Pending create."));
     return;
   }
   if (active_configuration_ == configuration) {
     configuration->OnPlatformMessage(api_vpn::PLATFORM_MESSAGE_DISCONNECTED);
   }
   DestroyConfigurationInternal(configuration);
 
@@ skipping 60 matching lines @@
 bool VpnService::VerifyConfigIsConnectedForTesting(
     const std::string& extension_id) {
   return DoesActiveConfigurationExistAndIsAccessAuthorized(extension_id);
 }
 
 void VpnService::DestroyConfigurationsForExtension(
     const extensions::Extension* extension) {
   std::vector<VpnConfiguration*> to_be_destroyed;
   for (const auto& iter : key_to_configuration_map_) {
     if (iter.second->extension_id() == extension->id()) {
-      to_be_destroyed.push_back(iter.second);
+      to_be_destroyed.push_back(iter.second.get());
     }
   }
 
   for (auto* iter : to_be_destroyed) {
     DestroyConfiguration(extension->id(),             // Extension ID
                          iter->configuration_name(),  // Configuration name
                          base::Bind(base::DoNothing),
                          base::Bind(DoNothingFailureCallback));
   }
 }
@@ skipping 80 matching lines @@
     VpnService::VpnConfiguration* configuration) {
   active_configuration_ = configuration;
 }
 
 VpnService::VpnConfiguration* VpnService::CreateConfigurationInternal(
     const std::string& extension_id,
     const std::string& configuration_name,
     const std::string& key) {
   VpnConfiguration* configuration = new VpnConfiguration(
       extension_id, configuration_name, key, weak_factory_.GetWeakPtr());
-  // The object is owned by key_to_configuration_map_ henceforth.
-  key_to_configuration_map_[key] = configuration;
+  key_to_configuration_map_[key] = base::WrapUnique(configuration);
   return configuration;
 }
 
 void VpnService::DestroyConfigurationInternal(VpnConfiguration* configuration) {
+  std::unique_ptr<VpnConfiguration> configuration_ptr =
+      std::move(key_to_configuration_map_[configuration->key()]);
   key_to_configuration_map_.erase(configuration->key());
   if (active_configuration_ == configuration) {
     active_configuration_ = nullptr;
   }
   if (!configuration->service_path().empty()) {
     shill_client_->RemoveShillThirdPartyVpnObserver(
         configuration->object_path());
     service_path_to_configuration_map_.erase(configuration->service_path());
   }
-  delete configuration;
 }
 
 bool VpnService::DoesActiveConfigurationExistAndIsAccessAuthorized(
     const std::string& extension_id) {
   return active_configuration_ &&
          active_configuration_->extension_id() == extension_id;
 }
 
 void VpnService::Bind(
     const std::string& extension_id,
     const std::string& configuration_id,
     const std::string& configuration_name,
     const SuccessCallback& success,
     const FailureCallback& failure,
     std::unique_ptr<content::PepperVpnProviderResourceHostProxy>
         pepper_vpn_provider_proxy) {
   // The ID is the configuration name for now. This may change in the future.
   const std::string key = GetKey(extension_id, configuration_id);
   if (!base::ContainsKey(key_to_configuration_map_, key)) {
     failure.Run(std::string(),
                 std::string("Unauthorized access. "
                             "The configuration does not exist."));
     return;
   }
 
-  VpnConfiguration* configuration = key_to_configuration_map_[key];
+  VpnConfiguration* configuration = key_to_configuration_map_[key].get();
   if (active_configuration_ != configuration) {
     failure.Run(std::string(), std::string("Unauthorized access. "
                                            "The configuration is not active."));
     return;
   }
 
   if (configuration->extension_id() != extension_id ||
       configuration->configuration_name() != configuration_name) {
     failure.Run(std::string(),
                 std::string("Unauthorized access. "
@@ skipping 11 matching lines @@
   configuration->set_pepper_proxy(std::move(pepper_vpn_provider_proxy));
 
   success.Run();
 }
 
 std::unique_ptr<content::VpnServiceProxy> VpnService::GetVpnServiceProxy() {
   return base::WrapUnique(new VpnServiceProxyImpl(weak_factory_.GetWeakPtr()));
 }
 
 }  // namespace chromeos