Remove stl_util's deletion function use from content/.

content/browser/appcache/appcache_service_impl.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 "content/browser/appcache/appcache_service_impl.h"
 
 #include <functional>
 #include <utility>
 
 #include "base/bind.h"
 #include "base/bind_helpers.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/threading/thread_task_runner_handle.h"
 #include "content/browser/appcache/appcache.h"
 #include "content/browser/appcache/appcache_backend_impl.h"
 #include "content/browser/appcache/appcache_entry.h"
 #include "content/browser/appcache/appcache_executable_handler.h"
 #include "content/browser/appcache/appcache_histograms.h"
 #include "content/browser/appcache/appcache_policy.h"
 #include "content/browser/appcache/appcache_quota_client.h"
 #include "content/browser/appcache/appcache_response.h"
 #include "content/browser/appcache/appcache_service_impl.h"
@@ skipping 17 matching lines @@
 AppCacheInfoCollection::~AppCacheInfoCollection() {}
 
 // AsyncHelper -------
 
 class AppCacheServiceImpl::AsyncHelper
     : public AppCacheStorage::Delegate {
  public:
   AsyncHelper(AppCacheServiceImpl* service,
               const net::CompletionCallback& callback)
       : service_(service), callback_(callback) {
-    service_->pending_helpers_.insert(this);
+    service_->pending_helpers_[this] = base::WrapUnique(this);
   }
 
   ~AsyncHelper() override {
-    if (service_)
+    if (service_) {
+      service_->pending_helpers_[this].release();
       service_->pending_helpers_.erase(this);
+    }
   }
 
   virtual void Start() = 0;
   virtual void Cancel();
 
  protected:
   void CallCallback(int rv) {
     if (!callback_.is_null()) {
       // Defer to guarantee async completion.
       base::ThreadTaskRunnerHandle::Get()->PostTask(
           FROM_HERE, base::Bind(&DeferredCallback, callback_, rv));
     }
     callback_.Reset();
   }
 
   AppCacheServiceImpl* service_;
   net::CompletionCallback callback_;
 };
 
 void AppCacheServiceImpl::AsyncHelper::Cancel() {
   if (!callback_.is_null()) {
     callback_.Run(net::ERR_ABORTED);
     callback_.Reset();
   }
   service_->storage()->CancelDelegateCallbacks(this);
-  service_ = NULL;
+  service_ = nullptr;
 }
 
 // DeleteHelper -------
 
 class AppCacheServiceImpl::DeleteHelper : public AsyncHelper {
  public:
   DeleteHelper(
       AppCacheServiceImpl* service, const GURL& manifest_url,
       const net::CompletionCallback& callback)
       : AsyncHelper(service, callback), manifest_url_(manifest_url) {
@@ skipping 294 matching lines @@
 
 AppCacheStorageReference::AppCacheStorageReference(
     std::unique_ptr<AppCacheStorage> storage)
     : storage_(std::move(storage)) {}
 AppCacheStorageReference::~AppCacheStorageReference() {}
 
 // AppCacheServiceImpl -------
 
 AppCacheServiceImpl::AppCacheServiceImpl(
     storage::QuotaManagerProxy* quota_manager_proxy)
-    : appcache_policy_(NULL),
-      quota_client_(NULL),
-      handler_factory_(NULL),
+    : appcache_policy_(nullptr),
+      quota_client_(nullptr),
+      handler_factory_(nullptr),
       quota_manager_proxy_(quota_manager_proxy),
-      request_context_(NULL),
+      request_context_(nullptr),
       force_keep_session_state_(false),
       weak_factory_(this) {
   if (quota_manager_proxy_.get()) {
     quota_client_ = new AppCacheQuotaClient(this);
     quota_manager_proxy_->RegisterClient(quota_client_);
   }
 }
 
 AppCacheServiceImpl::~AppCacheServiceImpl() {
   DCHECK(backends_.empty());
   for (auto& observer : observers_)
     observer.OnServiceDestructionImminent(this);
-  for (auto* helper : pending_helpers_)
-    helper->Cancel();
-  base::STLDeleteElements(&pending_helpers_);
+  for (auto& helper : pending_helpers_)
+    helper.first->Cancel();
+  pending_helpers_.clear();
   if (quota_client_)
     quota_client_->NotifyAppCacheDestroyed();
 
   // Destroy storage_ first; ~AppCacheStorageImpl accesses other data members
   // (special_storage_policy_).
   storage_.reset();
 }
 
 void AppCacheServiceImpl::Initialize(
     const base::FilePath& cache_directory,
@@ skipping 89 matching lines @@
   backends_.insert(
       BackendMap::value_type(backend_impl->process_id(), backend_impl));
 }
 
 void AppCacheServiceImpl::UnregisterBackend(
     AppCacheBackendImpl* backend_impl) {
   backends_.erase(backend_impl->process_id());
 }
 
 }  // namespace content