Modernize some extensions code.

extensions/browser/event_listener_map.h

 // 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.
 
 #ifndef EXTENSIONS_BROWSER_EVENT_LISTENER_MAP_H_
 #define EXTENSIONS_BROWSER_EVENT_LISTENER_MAP_H_
 
 #include <map>
 #include <memory>
 #include <set>
@@ skipping 120 matching lines @@
   std::set<const EventListener*> GetEventListeners(const Event& event);
 
   const ListenerList& GetEventListenersByName(const std::string& event_name) {
     return listeners_[event_name];
   }
 
   // Removes all listeners with process equal to |process|.
   void RemoveListenersForProcess(const content::RenderProcessHost* process);
 
   // Returns true if there are any listeners on the event named |event_name|.
-  bool HasListenerForEvent(const std::string& event_name);
+  bool HasListenerForEvent(const std::string& event_name) const;
 
   // Returns true if there are any listeners on |event_name| from
   // |extension_id|.
   bool HasListenerForExtension(const std::string& extension_id,
-                               const std::string& event_name);
+                               const std::string& event_name) const;
 
   // Returns true if this map contains an EventListener that .Equals()
   // |listener|.
-  bool HasListener(const EventListener* listener);
+  bool HasListener(const EventListener* listener) const;
 
   // Returns true if there is a listener for |extension_id| in |process|.
   bool HasProcessListener(content::RenderProcessHost* process,
-                          const std::string& extension_id);
+                          const std::string& extension_id) const;
 
   // Removes any listeners that |extension_id| has added, both lazy and regular.
   void RemoveListenersForExtension(const std::string& extension_id);
 
   // Adds unfiltered lazy listeners as described their serialised descriptions.
   // |event_names| the names of the lazy events.
   // Note that we can only load lazy listeners in this fashion, because there
   // is no way to serialise a RenderProcessHost*.
   void LoadUnfilteredLazyListeners(const std::string& extension_id,
                                    const std::set<std::string>& event_names);
 
   // Adds filtered lazy listeners as described their serialised descriptions.
   // |filtered| contains a map from event names to filters, each pairing
   // defining a lazy filtered listener.
   void LoadFilteredLazyListeners(
       const std::string& extension_id,
       const base::DictionaryValue& filtered);
 
  private:
   // The key here is an event name.
-  typedef std::map<std::string, ListenerList> ListenerMap;
+  using ListenerMap = std::map<std::string, ListenerList>;
 
   void CleanupListener(EventListener* listener);
   bool IsFilteredEvent(const Event& event) const;
   std::unique_ptr<EventMatcher> ParseEventMatcher(
       base::DictionaryValue* filter_dict);
 
   // Listens for removals from this map.
-  Delegate* delegate_;
+  Delegate* const delegate_;
 
   std::set<std::string> filtered_events_;
   ListenerMap listeners_;
 
   std::map<EventFilter::MatcherID, EventListener*> listeners_by_matcher_id_;
 
   EventFilter event_filter_;
 
   DISALLOW_COPY_AND_ASSIGN(EventListenerMap);
 };
 
 }  // namespace extensions
 
 #endif  // EXTENSIONS_BROWSER_EVENT_LISTENER_MAP_H_