Remove use of stl_util's STLDeleteContainerPairSecondPointers from content/.

content/browser/appcache/appcache.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 "content/browser/appcache/appcache.h"
 
 #include <stddef.h>
 
 #include <algorithm>
 
 #include "base/logging.h"
 #include "base/stl_util.h"
 #include "content/browser/appcache/appcache_executable_handler.h"
 #include "content/browser/appcache/appcache_group.h"
 #include "content/browser/appcache/appcache_host.h"
 #include "content/browser/appcache/appcache_storage.h"
 #include "content/common/appcache_interfaces.h"
 
 namespace content {
 
 AppCache::AppCache(AppCacheStorage* storage, int64_t cache_id)
     : cache_id_(cache_id),
-      owning_group_(NULL),
+      owning_group_(nullptr),
       online_whitelist_all_(false),
       is_complete_(false),
       cache_size_(0),
       storage_(storage) {
   storage_->working_set()->AddCache(this);
 }
 
 AppCache::~AppCache() {
   DCHECK(associated_hosts_.empty());
   if (owning_group_.get()) {
     DCHECK(is_complete_);
     owning_group_->RemoveCache(this);
   }
   DCHECK(!owning_group_.get());
   storage_->working_set()->RemoveCache(this);
-  base::STLDeleteContainerPairSecondPointers(executable_handlers_.begin(),
-                                             executable_handlers_.end());
 }
 
 void AppCache::UnassociateHost(AppCacheHost* host) {
   associated_hosts_.erase(host);
 }
 
 void AppCache::AddEntry(const GURL& url, const AppCacheEntry& entry) {
   DCHECK(entries_.find(url) == entries_.end());
   entries_.insert(EntryMap::value_type(url, entry));
   cache_size_ += entry.response_size();
@@ skipping 13 matching lines @@
 
 void AppCache::RemoveEntry(const GURL& url) {
   EntryMap::iterator found = entries_.find(url);
   DCHECK(found != entries_.end());
   cache_size_ -= found->second.response_size();
   entries_.erase(found);
 }
 
 AppCacheEntry* AppCache::GetEntry(const GURL& url) {
   EntryMap::iterator it = entries_.find(url);
-  return (it != entries_.end()) ? &(it->second) : NULL;
+  return (it != entries_.end()) ? &(it->second) : nullptr;
 }
 
 const AppCacheEntry* AppCache::GetEntryAndUrlWithResponseId(
     int64_t response_id,
     GURL* optional_url_out) {
   for (EntryMap::const_iterator iter = entries_.begin();
        iter !=  entries_.end(); ++iter) {
     if (iter->second.response_id() == response_id) {
       if (optional_url_out)
         *optional_url_out = iter->first;
       return &iter->second;
     }
   }
-  return NULL;
+  return nullptr;
 }
 
 AppCacheExecutableHandler* AppCache::GetExecutableHandler(int64_t response_id) {
   HandlerMap::const_iterator found = executable_handlers_.find(response_id);
   if (found != executable_handlers_.end())
-    return found->second;
-  return NULL;
+    return found->second.get();
+  return nullptr;
 }
 
 AppCacheExecutableHandler* AppCache::GetOrCreateExecutableHandler(
     int64_t response_id,
     net::IOBuffer* handler_source) {
   AppCacheExecutableHandler* handler = GetExecutableHandler(response_id);
   if (handler)
     return handler;
 
   GURL handler_url;
   const AppCacheEntry* entry = GetEntryAndUrlWithResponseId(
       response_id, &handler_url);
   if (!entry || !entry->IsExecutable())
-    return NULL;
+    return nullptr;
 
   DCHECK(storage_->service()->handler_factory());
   std::unique_ptr<AppCacheExecutableHandler> own_ptr =
       storage_->service()->handler_factory()->CreateHandler(handler_url,
                                                             handler_source);
-  handler = own_ptr.release();
+  handler = own_ptr.get();
   if (!handler)
-    return NULL;
-  executable_handlers_[response_id] = handler;
+    return nullptr;
+  executable_handlers_[response_id] = std::move(own_ptr);
   return handler;
 }
 
 GURL AppCache::GetNamespaceEntryUrl(const AppCacheNamespaceVector& namespaces,
                                     const GURL& namespace_url) const {
   size_t count = namespaces.size();
   for (size_t i = 0; i < count; ++i) {
     if (namespaces[i].namespace_url == namespace_url)
       return namespaces[i].target_url;
   }
@@ skipping 189 matching lines @@
 
 // static
 const AppCacheNamespace* AppCache::FindNamespace(
     const AppCacheNamespaceVector& namespaces,
     const GURL& url) {
   size_t count = namespaces.size();
   for (size_t i = 0; i < count; ++i) {
     if (namespaces[i].IsMatch(url))
       return &namespaces[i];
   }
-  return NULL;
+  return nullptr;
 }
 
 }  // namespace content