Modernize some extensions code.

extensions/browser/event_listener_map.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 "extensions/browser/event_listener_map.h"
 
 #include <stddef.h>
 
 #include <utility>
 
@@ skipping 45 matching lines @@
   return event_name_ == other->event_name_ &&
          extension_id_ == other->extension_id_ &&
          listener_url_ == other->listener_url_ && process_ == other->process_ &&
          ((!!filter_.get()) == (!!other->filter_.get())) &&
          (!filter_.get() || filter_->Equals(other->filter_.get()));
 }
 
 std::unique_ptr<EventListener> EventListener::Copy() const {
   std::unique_ptr<DictionaryValue> filter_copy;
   if (filter_)
-    filter_copy.reset(filter_->DeepCopy());
-  return std::unique_ptr<EventListener>(
-      new EventListener(event_name_, extension_id_, listener_url_, process_,
-                        std::move(filter_copy)));
+    filter_copy = filter_->CreateDeepCopy();
+  return base::WrapUnique(new EventListener(event_name_, extension_id_,
+                                            listener_url_, process_,
+                                            std::move(filter_copy)));
 }
 
 bool EventListener::IsLazy() const {
   return !process_;
 }
 
 void EventListener::MakeLazy() {
-  process_ = NULL;
+  process_ = nullptr;
 }
 
 content::BrowserContext* EventListener::GetBrowserContext() const {
-  return process_ ? process_->GetBrowserContext() : NULL;
+  return process_ ? process_->GetBrowserContext() : nullptr;
 }
 
 EventListener::EventListener(const std::string& event_name,
                              const std::string& extension_id,
                              const GURL& listener_url,
                              content::RenderProcessHost* process,
                              std::unique_ptr<DictionaryValue> filter)
     : event_name_(event_name),
       extension_id_(extension_id),
       listener_url_(listener_url),
@@ skipping 22 matching lines @@
   EventListener* listener_ptr = listener.get();
   listeners_[listener->event_name()].push_back(std::move(listener));
 
   delegate_->OnListenerAdded(listener_ptr);
 
   return true;
 }
 
 std::unique_ptr<EventMatcher> EventListenerMap::ParseEventMatcher(
     DictionaryValue* filter_dict) {
-  return std::unique_ptr<EventMatcher>(new EventMatcher(
-      base::WrapUnique(filter_dict->DeepCopy()), MSG_ROUTING_NONE));
+  return base::MakeUnique<EventMatcher>(filter_dict->CreateDeepCopy(),
+                                        MSG_ROUTING_NONE);
 }
 
 bool EventListenerMap::RemoveListener(const EventListener* listener) {
   ListenerList& listeners = listeners_[listener->event_name()];
-  for (ListenerList::iterator it = listeners.begin(); it != listeners.end();
-       it++) {
-    if ((*it)->Equals(listener)) {
-      CleanupListener(it->get());
+  for (auto& it : listeners) {
+    if (it->Equals(listener)) {
+      CleanupListener(it.get());
       // Popping from the back should be cheaper than erase(it).
-      std::swap(*it, listeners.back());
+      std::swap(it, listeners.back());
       listeners.pop_back();
       delegate_->OnListenerRemoved(listener);
       return true;
     }
   }
   return false;
 }
 
-bool EventListenerMap::HasListenerForEvent(const std::string& event_name) {
-  ListenerMap::iterator it = listeners_.find(event_name);
+bool EventListenerMap::HasListenerForEvent(
+    const std::string& event_name) const {
+  ListenerMap::const_iterator it = listeners_.find(event_name);
   return it != listeners_.end() && !it->second.empty();
 }
 
 bool EventListenerMap::HasListenerForExtension(
     const std::string& extension_id,
-    const std::string& event_name) {
-  ListenerMap::iterator it = listeners_.find(event_name);
+    const std::string& event_name) const {
+  auto it = listeners_.find(event_name);
   if (it == listeners_.end())
     return false;
 
-  for (ListenerList::iterator it2 = it->second.begin();
-       it2 != it->second.end(); it2++) {
-    if ((*it2)->extension_id() == extension_id)
+  for (const auto& listener_to_search : it->second) {
+    if (listener_to_search->extension_id() == extension_id)
       return true;
   }
   return false;
 }
 
-bool EventListenerMap::HasListener(const EventListener* listener) {
-  ListenerMap::iterator it = listeners_.find(listener->event_name());
+bool EventListenerMap::HasListener(const EventListener* listener) const {
+  auto it = listeners_.find(listener->event_name());
   if (it == listeners_.end())
     return false;
-  for (ListenerList::iterator it2 = it->second.begin();
-       it2 != it->second.end(); it2++) {
-    if ((*it2)->Equals(listener)) {
+
+  for (const auto& listener_to_search : it->second) {
+    if (listener_to_search->Equals(listener))
       return true;
-    }
   }
   return false;
 }
 
-bool EventListenerMap::HasProcessListener(content::RenderProcessHost* process,
-                                          const std::string& extension_id) {
-  for (ListenerMap::iterator it = listeners_.begin(); it != listeners_.end();
-       it++) {
-    for (ListenerList::iterator it2 = it->second.begin();
-         it2 != it->second.end(); it2++) {
-      if ((*it2)->process() == process &&
-          (*it2)->extension_id() == extension_id)
+bool EventListenerMap::HasProcessListener(
+    content::RenderProcessHost* process,
+    const std::string& extension_id) const {
+  for (const auto& it : listeners_) {
+    for (const auto& listener : it.second) {
+      if (listener->process() == process &&
+          listener->extension_id() == extension_id)
         return true;
     }
   }
   return false;
 }
 
 void EventListenerMap::RemoveListenersForExtension(
     const std::string& extension_id) {
-  for (ListenerMap::iterator it = listeners_.begin(); it != listeners_.end();
-       it++) {
-    for (ListenerList::iterator it2 = it->second.begin();
-         it2 != it->second.end();) {
+  for (auto& it : listeners_) {
+    auto& listener_map = it.second;
+    for (ListenerList::iterator it2 = listener_map.begin();
+         it2 != listener_map.end();) {
       if ((*it2)->extension_id() == extension_id) {
         std::unique_ptr<EventListener> listener_removed = std::move(*it2);
         CleanupListener(listener_removed.get());
-        it2 = it->second.erase(it2);
+        it2 = listener_map.erase(it2);
         delegate_->OnListenerRemoved(listener_removed.get());
       } else {
-        it2++;
+        ++it2;
       }
     }
   }
 }
 
 void EventListenerMap::LoadUnfilteredLazyListeners(
     const std::string& extension_id,
     const std::set<std::string>& event_names) {
-  for (std::set<std::string>::const_iterator it = event_names.begin();
-       it != event_names.end(); ++it) {
+  for (const auto& name : event_names) {
     AddListener(EventListener::ForExtension(
-        *it, extension_id, NULL, std::unique_ptr<DictionaryValue>()));
+        name, extension_id, nullptr, std::unique_ptr<DictionaryValue>()));
   }
 }
 
 void EventListenerMap::LoadFilteredLazyListeners(
     const std::string& extension_id,
     const DictionaryValue& filtered) {
   for (DictionaryValue::Iterator it(filtered); !it.IsAtEnd(); it.Advance()) {
     // We skip entries if they are malformed.
-    const base::ListValue* filter_list = NULL;
+    const base::ListValue* filter_list = nullptr;
     if (!it.value().GetAsList(&filter_list))
       continue;
     for (size_t i = 0; i < filter_list->GetSize(); i++) {
-      const DictionaryValue* filter = NULL;
+      const DictionaryValue* filter = nullptr;
       if (!filter_list->GetDictionary(i, &filter))
         continue;
-      AddListener(EventListener::ForExtension(
-          it.key(), extension_id, NULL, base::WrapUnique(filter->DeepCopy())));
+      AddListener(
+          EventListener::ForExtension(it.key(), extension_id, nullptr,
+                                      base::WrapUnique(filter->DeepCopy())));
     }
   }
 }
 
 std::set<const EventListener*> EventListenerMap::GetEventListeners(
     const Event& event) {
   std::set<const EventListener*> interested_listeners;
   if (IsFilteredEvent(event)) {
     // Look up the interested listeners via the EventFilter.
     std::set<MatcherID> ids =
         event_filter_.MatchEvent(event.event_name, event.filter_info,
             MSG_ROUTING_NONE);
-    for (std::set<MatcherID>::iterator id = ids.begin(); id != ids.end();
-         id++) {
-      EventListener* listener = listeners_by_matcher_id_[*id];
+    for (const MatcherID& id : ids) {
+      EventListener* listener = listeners_by_matcher_id_[id];
       CHECK(listener);
       interested_listeners.insert(listener);
     }
   } else {
-    ListenerList& listeners = listeners_[event.event_name];
-    for (ListenerList::const_iterator it = listeners.begin();
-         it != listeners.end(); it++) {
-      interested_listeners.insert(it->get());
-    }
+    for (const auto& listener : listeners_[event.event_name])
+      interested_listeners.insert(listener.get());
   }
 
   return interested_listeners;
 }
 
 void EventListenerMap::RemoveListenersForProcess(
     const content::RenderProcessHost* process) {
   CHECK(process);
-  for (ListenerMap::iterator it = listeners_.begin(); it != listeners_.end();
-       it++) {
-    for (ListenerList::iterator it2 = it->second.begin();
-         it2 != it->second.end();) {
+  for (auto& it : listeners_) {
+    auto& listener_map = it.second;
+    for (ListenerList::iterator it2 = listener_map.begin();
+         it2 != listener_map.end();) {
       if ((*it2)->process() == process) {
         std::unique_ptr<EventListener> listener_removed = std::move(*it2);
         CleanupListener(listener_removed.get());
-        it2 = it->second.erase(it2);
+        it2 = listener_map.erase(it2);
         delegate_->OnListenerRemoved(listener_removed.get());
       } else {
-        it2++;
+        ++it2;
       }
     }
   }
 }
 
 void EventListenerMap::CleanupListener(EventListener* listener) {
   // If the listener doesn't have a filter then we have nothing to clean up.
   if (listener->matcher_id() == -1)
     return;
   event_filter_.RemoveEventMatcher(listener->matcher_id());
   CHECK_EQ(1u, listeners_by_matcher_id_.erase(listener->matcher_id()));
 }
 
 bool EventListenerMap::IsFilteredEvent(const Event& event) const {
-  return filtered_events_.count(event.event_name) > 0u;
+  return base::ContainsKey(filtered_events_, event.event_name);
 }
 
 }  // namespace extensions