Remove stl_util's deletion functions from net/dns/.

net/dns/mdns_client_impl.cc

 // Copyright 2013 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 "net/dns/mdns_client_impl.h"
 
 #include <algorithm>
 #include <queue>
 #include <utility>
 
 #include "base/bind.h"
 #include "base/location.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 "base/time/clock.h"
 #include "base/time/default_clock.h"
 #include "base/time/time.h"
 #include "base/timer/timer.h"
 #include "net/base/net_errors.h"
 #include "net/base/rand_callback.h"
 #include "net/dns/dns_protocol.h"
 #include "net/dns/dns_util.h"
 #include "net/dns/record_rdata.h"
@@ skipping 175 matching lines @@
   delegate_->HandlePacket(response, bytes_read);
 }
 
 MDnsClientImpl::Core::Core(base::Clock* clock, base::Timer* timer)
     : clock_(clock),
       cleanup_timer_(timer),
       connection_(new MDnsConnection(this)) {
 }
 
 MDnsClientImpl::Core::~Core() {
-  base::STLDeleteValues(&listeners_);
 }
 
 bool MDnsClientImpl::Core::Init(MDnsSocketFactory* socket_factory) {
   return connection_->Init(socket_factory);
 }
 
 bool MDnsClientImpl::Core::SendQuery(uint16_t rrtype, const std::string& name) {
   std::string name_dns;
   if (!DNSDomainFromDot(name, &name_dns))
     return false;
@@ skipping 119 matching lines @@
   ListenerMap::iterator listener_map_iterator = listeners_.find(key);
   if (listener_map_iterator == listeners_.end()) return;
 
   for (auto& observer : *listener_map_iterator->second)
     observer.HandleRecordUpdate(update_type, record);
 }
 
 void MDnsClientImpl::Core::AddListener(
     MDnsListenerImpl* listener) {
   ListenerKey key(listener->GetName(), listener->GetType());
-  std::pair<ListenerMap::iterator, bool> observer_insert_result =
-      listeners_.insert(make_pair(
-          key, static_cast<base::ObserverList<MDnsListenerImpl>*>(NULL)));
 
-  // If an equivalent key does not exist, actually create the observer list.
-  if (observer_insert_result.second)
-    observer_insert_result.first->second =
-        new base::ObserverList<MDnsListenerImpl>();
+  std::unique_ptr<base::ObserverList<MDnsListenerImpl>>& observer_list =
+      listeners_[key];
 
-  base::ObserverList<MDnsListenerImpl>* observer_list =
-      observer_insert_result.first->second;
+  if (!observer_list)
+    observer_list = base::MakeUnique<base::ObserverList<MDnsListenerImpl>>();
 
   observer_list->AddObserver(listener);
 }
 
 void MDnsClientImpl::Core::RemoveListener(MDnsListenerImpl* listener) {
   ListenerKey key(listener->GetName(), listener->GetType());
   ListenerMap::iterator observer_list_iterator = listeners_.find(key);
 
   DCHECK(observer_list_iterator != listeners_.end());
   DCHECK(observer_list_iterator->second->HasObserver(listener));
 
   observer_list_iterator->second->RemoveObserver(listener);
 
   // Remove the observer list from the map if it is empty
   if (!observer_list_iterator->second->might_have_observers()) {
     // Schedule the actual removal for later in case the listener removal
     // happens while iterating over the observer list.
     base::ThreadTaskRunnerHandle::Get()->PostTask(
         FROM_HERE, base::Bind(&MDnsClientImpl::Core::CleanupObserverList,
                               AsWeakPtr(), key));
   }
 }
 
 void MDnsClientImpl::Core::CleanupObserverList(const ListenerKey& key) {
   ListenerMap::iterator found = listeners_.find(key);
   if (found != listeners_.end() && !found->second->might_have_observers()) {
-    delete found->second;
     listeners_.erase(found);
   }
 }
 
 void MDnsClientImpl::Core::ScheduleCleanup(base::Time cleanup) {
   // Cleanup is already scheduled, no need to do anything.
   if (cleanup == scheduled_cleanup_) {
     return;
   }
   scheduled_cleanup_ = cleanup;
@@ skipping 350 matching lines @@
 
 void MDnsTransactionImpl::OnNsecRecord(const std::string& name, unsigned type) {
   TriggerCallback(RESULT_NSEC, NULL);
 }
 
 void MDnsTransactionImpl::OnCachePurged() {
   // TODO(noamsml): Cache purge situations not yet implemented
 }
 
 }  // namespace net