Remove use of stl_util's STLDeleteContainerPairSecondPointers from content/.

content/browser/appcache/appcache_storage.cc

 // Copyright (c) 2009 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_storage.h"
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
-#include "base/stl_util.h"
+#include "base/memory/ptr_util.h"
 #include "content/browser/appcache/appcache_response.h"
 #include "content/browser/appcache/appcache_service_impl.h"
 #include "storage/browser/quota/quota_client.h"
 #include "storage/browser/quota/quota_manager_proxy.h"
 
 namespace content {
 
 // static
 const int64_t AppCacheStorage::kUnitializedId = -1;
 
 AppCacheStorage::AppCacheStorage(AppCacheServiceImpl* service)
     : last_cache_id_(kUnitializedId), last_group_id_(kUnitializedId),
       last_response_id_(kUnitializedId), service_(service)  {
 }
 
 AppCacheStorage::~AppCacheStorage() {
-  base::STLDeleteValues(&pending_info_loads_);
   DCHECK(delegate_references_.empty());
 }
 
 AppCacheStorage::DelegateReference::DelegateReference(
     Delegate* delegate, AppCacheStorage* storage)
     : delegate(delegate), storage(storage) {
   storage->delegate_references_.insert(
       DelegateReferenceMap::value_type(delegate, this));
 }
 
 AppCacheStorage::DelegateReference::~DelegateReference() {
   if (delegate)
     storage->delegate_references_.erase(delegate);
 }
 
 AppCacheStorage::ResponseInfoLoadTask::ResponseInfoLoadTask(
     const GURL& manifest_url,
     int64_t response_id,
     AppCacheStorage* storage)
     : storage_(storage),
       manifest_url_(manifest_url),
       response_id_(response_id),
       info_buffer_(new HttpResponseInfoIOBuffer) {
-  storage_->pending_info_loads_.insert(
-      PendingResponseInfoLoads::value_type(response_id, this));
+  storage_->pending_info_loads_.insert(PendingResponseInfoLoads::value_type(

[ncarter (slow), 2016/08/15 21:51:33]

Does map::emplace(key, value) work here (letting you omit the value_type)?

[Avi (use Gerrit), 2016/08/15 23:46:49]

Nice, and it lets me drop the typedef.

[Avi (use Gerrit), 2016/08/16 14:59:02]

No, unfortunately map::emplace doesn't exist on the version of libstdc++ that
we're using on Linux. That's apparently called out at
https://chromium-cpp.appspot.com/, though we must have missed that.

[ncarter (slow), 2016/08/16 18:41:19]

Sorry for the wild goose chase, then. At least we learned something.

+      response_id, base::WrapUnique(this)));
 }
 
 AppCacheStorage::ResponseInfoLoadTask::~ResponseInfoLoadTask() {
 }
 
 void AppCacheStorage::ResponseInfoLoadTask::StartIfNeeded() {
   if (reader_)
     return;
   reader_.reset(storage_->CreateResponseReader(manifest_url_, response_id_));
   reader_->ReadInfo(info_buffer_.get(),
                     base::Bind(&ResponseInfoLoadTask::OnReadComplete,
                                base::Unretained(this)));
 }
 
 void AppCacheStorage::ResponseInfoLoadTask::OnReadComplete(int result) {
+  std::unique_ptr<ResponseInfoLoadTask> this_wrapper(
+      std::move(storage_->pending_info_loads_[response_id_]));
   storage_->pending_info_loads_.erase(response_id_);
+
   scoped_refptr<AppCacheResponseInfo> info;
   if (result >= 0) {
     info = new AppCacheResponseInfo(storage_, manifest_url_,
                                     response_id_,
                                     info_buffer_->http_info.release(),
                                     info_buffer_->response_data_size);
   }
   FOR_EACH_DELEGATE(delegates_, OnResponseInfoLoaded(info.get(), response_id_));
-  delete this;
+
+  // returning deletes this
 }
 
 void AppCacheStorage::LoadResponseInfo(const GURL& manifest_url,
                                        int64_t id,
                                        Delegate* delegate) {
   AppCacheResponseInfo* info = working_set_.GetResponseInfo(id);
   if (info) {
     delegate->OnResponseInfoLoaded(info, id);
     return;
   }
@@ skipping 40 matching lines @@
   if (service()->quota_manager_proxy() &&
       usage_map_.find(origin) != usage_map_.end())
     service()->quota_manager_proxy()->NotifyStorageAccessed(
         storage::QuotaClient::kAppcache,
         origin,
         storage::kStorageTypeTemporary);
 }
 
 }  // namespace content