Modernize some extensions code.

extensions/browser/event_router.h

 // 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.
 
 #ifndef EXTENSIONS_BROWSER_EVENT_ROUTER_H_
 #define EXTENSIONS_BROWSER_EVENT_ROUTER_H_
 
 #include <set>
 #include <string>
 #include <utility>
@@ skipping 54 matching lines @@
   // Observers register interest in events with a particular name and are
   // notified when a listener is added or removed. Observers are matched by
   // the base name of the event (e.g. adding an event listener for event name
   // "foo.onBar/123" will trigger observers registered for "foo.onBar").
   class Observer {
    public:
     // Called when a listener is added.
     virtual void OnListenerAdded(const EventListenerInfo& details) {}
     // Called when a listener is removed.
     virtual void OnListenerRemoved(const EventListenerInfo& details) {}
+
+   protected:
+    virtual ~Observer() {}
   };
 
   // Gets the EventRouter for |browser_context|.
   static EventRouter* Get(content::BrowserContext* browser_context);
 
   // Converts event names like "foo.onBar/123" into "foo.onBar". Event names
   // without a "/" are returned unchanged.
   static std::string GetBaseEventName(const std::string& full_event_name);
 
   // Sends an event via ipc_sender to the given extension. Can be called on any
@@ skipping 34 matching lines @@
                               const GURL& listener_url);
   void RemoveEventListenerForURL(const std::string& event_name,
                                  content::RenderProcessHost* process,
                                  const GURL& listener_url);
 
   EventListenerMap& listeners() { return listeners_; }
 
   // Registers an observer to be notified when an event listener for
   // |event_name| is added or removed. There can currently be only one observer
   // for each distinct |event_name|.
-  void RegisterObserver(Observer* observer,
-                        const std::string& event_name);
+  void RegisterObserver(Observer* observer, const std::string& event_name);
 
   // Unregisters an observer from all events.
   void UnregisterObserver(Observer* observer);
 
   // Add or remove the extension as having a lazy background page that listens
   // to the event. The difference from the above methods is that these will be
   // remembered even after the process goes away. We use this list to decide
   // which extension pages to load when dispatching an event.
   void AddLazyEventListener(const std::string& event_name,
                             const std::string& extension_id);
   void RemoveLazyEventListener(const std::string& event_name,
                                const std::string& extension_id);
 
   // If |add_lazy_listener| is true also add the lazy version of this listener.
   void AddFilteredEventListener(const std::string& event_name,
                                 content::RenderProcessHost* process,
                                 const std::string& extension_id,
                                 const base::DictionaryValue& filter,
                                 bool add_lazy_listener);
 
   // If |remove_lazy_listener| is true also remove the lazy version of this
   // listener.
   void RemoveFilteredEventListener(const std::string& event_name,
                                    content::RenderProcessHost* process,
                                    const std::string& extension_id,
                                    const base::DictionaryValue& filter,
                                    bool remove_lazy_listener);
 
   // Returns true if there is at least one listener for the given event.
-  bool HasEventListener(const std::string& event_name);
+  bool HasEventListener(const std::string& event_name) const;
 
   // Returns true if the extension is listening to the given event.
+  // (virtual for testing only.)
   virtual bool ExtensionHasEventListener(const std::string& extension_id,
-                                         const std::string& event_name);
+                                         const std::string& event_name) const;
 
   // Broadcasts an event to every listener registered for that event.
   virtual void BroadcastEvent(std::unique_ptr<Event> event);
 
   // Dispatches an event to the given extension.
   virtual void DispatchEventToExtension(const std::string& extension_id,
                                         std::unique_ptr<Event> event);
 
   // Dispatches |event| to the given extension as if the extension has a lazy
   // listener for it. NOTE: This should be used rarely, for dispatching events
@@ skipping 139 matching lines @@
   // Implementation of EventListenerMap::Delegate.
   void OnListenerAdded(const EventListener* listener) override;
   void OnListenerRemoved(const EventListener* listener) override;
 
   // RenderProcessHostObserver implementation.
   void RenderProcessExited(content::RenderProcessHost* host,
                            base::TerminationStatus status,
                            int exit_code) override;
   void RenderProcessHostDestroyed(content::RenderProcessHost* host) override;
 
-  content::BrowserContext* browser_context_;
+  content::BrowserContext* const browser_context_;
 
   // The ExtensionPrefs associated with |browser_context_|. May be NULL in
   // tests.
-  ExtensionPrefs* extension_prefs_;
+  ExtensionPrefs* const extension_prefs_;
 
   content::NotificationRegistrar registrar_;
 
   ScopedObserver<ExtensionRegistry, ExtensionRegistryObserver>
       extension_registry_observer_;
 
   EventListenerMap listeners_;
 
   // Map from base event name to observer.
-  typedef base::hash_map<std::string, Observer*> ObserverMap;
+  using ObserverMap = base::hash_map<std::string, Observer*>;

[Devlin, 2017/05/20 00:49:16]

s/base::hash_map/std::unordered_map?

[Lei Zhang, 2017/05/20 01:04:14]

Done.

   ObserverMap observers_;
 
   std::set<content::RenderProcessHost*> observed_process_set_;
 
   DISALLOW_COPY_AND_ASSIGN(EventRouter);
 };
 
 struct Event {
   // This callback should return true if the event should be dispatched to the
   // given context and extension, and false otherwise.
-  typedef base::Callback<bool(content::BrowserContext*,
-                              const Extension*,
-                              Event*,
-                              const base::DictionaryValue*)>
-      WillDispatchCallback;
+  using WillDispatchCallback =
+      base::Callback<bool(content::BrowserContext*,
+                          const Extension*,
+                          Event*,
+                          const base::DictionaryValue*)>;
 
   // The identifier for the event, for histograms. In most cases this
   // correlates 1:1 with |event_name|, in some cases events will generate
   // their own names, but they cannot generate their own identifier.
-  events::HistogramValue histogram_value;
+  const events::HistogramValue histogram_value;
 
   // The event to dispatch.
-  std::string event_name;
+  const std::string event_name;
 
   // Arguments to send to the event listener.
   std::unique_ptr<base::ListValue> event_args;
 
   // If non-NULL, then the event will not be sent to other BrowserContexts
   // unless the extension has permission (e.g. incognito tab update -> normal
   // tab only works if extension is allowed incognito access).
   content::BrowserContext* restrict_to_browser_context;
 
   // If not empty, the event is only sent to extensions with host permissions
@@ skipping 44 matching lines @@
   EventListenerInfo(const std::string& event_name,
                     const std::string& extension_id,
                     const GURL& listener_url,
                     content::BrowserContext* browser_context);
   // The event name including any sub-event, e.g. "runtime.onStartup" or
   // "webRequest.onCompleted/123".
   const std::string event_name;
 
   const std::string extension_id;
   const GURL listener_url;
-  content::BrowserContext* browser_context;
+  content::BrowserContext* const browser_context;
 };
 
 }  // namespace extensions
 
 #endif  // EXTENSIONS_BROWSER_EVENT_ROUTER_H_