Restrict EventRouter::Get/Set-RegisteredEvents.

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 145 matching lines @@
                                    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);
 
   // Returns true if the extension is listening to the given event.
   virtual bool ExtensionHasEventListener(const std::string& extension_id,
                                          const std::string& event_name);
 
-  // Return or set the list of events for which the given extension has
-  // registered.
-  std::set<std::string> GetRegisteredEvents(const std::string& extension_id);
-  void SetRegisteredEvents(const std::string& extension_id,
-                           const std::set<std::string>& events);
-
   // 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
   // to extensions that haven't had a chance to add their own listeners yet, eg:
   // newly installed extensions.
   void DispatchEventWithLazyListener(const std::string& extension_id,
                                      std::unique_ptr<Event> event);
 
   // Record the Event Ack from the renderer. (One less event in-flight.)
   void OnEventAck(content::BrowserContext* context,
                   const std::string& extension_id);
 
+  // Returns whether or not the given extension has any registered events.
+  bool HasRegisteredEvents(const ExtensionId& extension_id) const {
+    return !GetRegisteredEvents(extension_id).empty();
+  }
+
+  // Clears registered events for testing purposes.
+  void ClearRegisteredEventsForTest(const ExtensionId& extension_id) {
+    SetRegisteredEvents(extension_id, std::set<std::string>());
+  }
+
   // Reports UMA for an event dispatched to |extension| with histogram value
   // |histogram_value|. Must be called on the UI thread.
   //
   // |did_enqueue| should be true if the event was queued waiting for a process
   // to start, like an event page.
   void ReportEvent(events::HistogramValue histogram_value,
                    const Extension* extension,
                    bool did_enqueue);
 
  private:
   friend class EventRouterFilterTest;
   friend class EventRouterTest;
 
   // An identifier for an event dispatch that is used to prevent double dispatch
   // due to race conditions between the direct and lazy dispatch paths.
   typedef std::pair<const content::BrowserContext*, std::string>
       EventDispatchIdentifier;
 
   // TODO(gdk): Document this.
   static void DispatchExtensionMessage(
       IPC::Sender* ipc_sender,
       void* browser_context_id,
       const std::string& extension_id,
       int event_id,
       const std::string& event_name,
       base::ListValue* event_args,
       UserGestureState user_gesture,
       const extensions::EventFilteringInfo& info);
 
+  // Returns or sets the list of events for which the given extension has
+  // registered.
+  std::set<std::string> GetRegisteredEvents(
+      const std::string& extension_id) const;
+  void SetRegisteredEvents(const std::string& extension_id,
+                           const std::set<std::string>& events);
+
   void Observe(int type,
                const content::NotificationSource& source,
                const content::NotificationDetails& details) override;
   // ExtensionRegistryObserver implementation.
   void OnExtensionLoaded(content::BrowserContext* browser_context,
                          const Extension* extension) override;
   void OnExtensionUnloaded(content::BrowserContext* browser_context,
                            const Extension* extension,
                            UnloadedExtensionReason reason) override;
 
@@ skipping 182 matching lines @@
   const std::string event_name;
 
   const std::string extension_id;
   const GURL listener_url;
   content::BrowserContext* browser_context;
 };
 
 }  // namespace extensions
 
 #endif  // EXTENSIONS_BROWSER_EVENT_ROUTER_H_