Restrict EventRouter::Get/Set-RegisteredEvents.

extensions/browser/event_router.cc

 // 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.
 
 #include "extensions/browser/event_router.h"
 
 #include <stddef.h>
 
 #include <utility>
 
@@ skipping 306 matching lines @@
 bool EventRouter::HasEventListener(const std::string& event_name) {
   return listeners_.HasListenerForEvent(event_name);
 }
 
 bool EventRouter::ExtensionHasEventListener(const std::string& extension_id,
                                             const std::string& event_name) {
   return listeners_.HasListenerForExtension(extension_id, event_name);
 }
 
 std::set<std::string> EventRouter::GetRegisteredEvents(
-    const std::string& extension_id) {
+    const std::string& extension_id) const {
   std::set<std::string> events;
   const ListValue* events_value = NULL;
 
   if (!extension_prefs_ ||
       !extension_prefs_->ReadPrefAsList(
            extension_id, kRegisteredEvents, &events_value)) {
     return events;
   }
 
   for (size_t i = 0; i < events_value->GetSize(); ++i) {
     std::string event;
     if (events_value->GetString(i, &event))
       events.insert(event);
   }
   return events;
 }
 
-void EventRouter::SetRegisteredEvents(const std::string& extension_id,
-                                      const std::set<std::string>& events) {
-  auto events_value = base::MakeUnique<base::ListValue>();
-  for (std::set<std::string>::const_iterator iter = events.begin();
-       iter != events.end(); ++iter) {
-    events_value->AppendString(*iter);
-  }
-  extension_prefs_->UpdateExtensionPref(extension_id, kRegisteredEvents,
-                                        std::move(events_value));
-}
-
-void EventRouter::AddFilterToEvent(const std::string& event_name,
-                                   const std::string& extension_id,
-                                   const DictionaryValue* filter) {
-  ExtensionPrefs::ScopedDictionaryUpdate update(
-      extension_prefs_, extension_id, kFilteredEvents);
-  DictionaryValue* filtered_events = update.Get();
-  if (!filtered_events)
-    filtered_events = update.Create();
-
-  ListValue* filter_list = nullptr;
-  if (!filtered_events->GetListWithoutPathExpansion(event_name, &filter_list)) {
-    filter_list = new ListValue;
-    filtered_events->SetWithoutPathExpansion(event_name,
-                                             base::WrapUnique(filter_list));
-  }
-
-  filter_list->Append(filter->CreateDeepCopy());
-}
-
 void EventRouter::RemoveFilterFromEvent(const std::string& event_name,
                                         const std::string& extension_id,
                                         const DictionaryValue* filter) {
   ExtensionPrefs::ScopedDictionaryUpdate update(
       extension_prefs_, extension_id, kFilteredEvents);
   DictionaryValue* filtered_events = update.Get();
   ListValue* filter_list = NULL;
   if (!filtered_events ||
       !filtered_events->GetListWithoutPathExpansion(event_name, &filter_list)) {
     return;
@@ skipping 297 matching lines @@
   // The event ACK is routed to the background host, so this should never be
   // NULL.
   CHECK(host);
   // TODO(mpcomplete): We should never get this message unless
   // HasLazyBackgroundPage is true. Find out why we're getting it anyway.
   if (host->extension() &&
       BackgroundInfo::HasLazyBackgroundPage(host->extension()))
     pm->DecrementLazyKeepaliveCount(host->extension());
 }
 
+bool EventRouter::HasRegisteredEvents(const ExtensionId& extension_id) const {
+  return !GetRegisteredEvents(extension_id).empty();
+}
+
+void EventRouter::ClearRegisteredEventsForTest(
+    const ExtensionId& extension_id) {
+  SetRegisteredEvents(extension_id, std::set<std::string>());
+}
+
 void EventRouter::ReportEvent(events::HistogramValue histogram_value,
                               const Extension* extension,
                               bool did_enqueue) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
 
   // Record every event fired.
   UMA_HISTOGRAM_ENUMERATION("Extensions.Events.Dispatch", histogram_value,
                             events::ENUM_BOUNDARY);
 
   bool is_component = Manifest::IsComponentLocation(extension->location());
@@ skipping 45 matching lines @@
     return;
 
   if (listeners_.HasProcessListener(host->render_process_host(),
                                     host->extension()->id())) {
     DispatchEventToProcess(host->extension()->id(), host->GetURL(),
                            host->render_process_host(), event, nullptr,
                            true /* did_enqueue */);
   }
 }
 
+void EventRouter::SetRegisteredEvents(const std::string& extension_id,

[lazyboy, 2017/05/11 20:58:49]

note: This block is moved from line 345.

+                                      const std::set<std::string>& events) {
+  auto events_value = base::MakeUnique<base::ListValue>();
+  for (std::set<std::string>::const_iterator iter = events.begin();
+       iter != events.end(); ++iter) {
+    events_value->AppendString(*iter);
+  }
+  extension_prefs_->UpdateExtensionPref(extension_id, kRegisteredEvents,
+                                        std::move(events_value));
+}
+
+void EventRouter::AddFilterToEvent(const std::string& event_name,
+                                   const std::string& extension_id,
+                                   const DictionaryValue* filter) {
+  ExtensionPrefs::ScopedDictionaryUpdate update(extension_prefs_, extension_id,
+                                                kFilteredEvents);
+  DictionaryValue* filtered_events = update.Get();
+  if (!filtered_events)
+    filtered_events = update.Create();
+
+  ListValue* filter_list = nullptr;
+  if (!filtered_events->GetListWithoutPathExpansion(event_name, &filter_list)) {
+    filter_list = new ListValue;
+    filtered_events->SetWithoutPathExpansion(event_name,
+                                             base::WrapUnique(filter_list));
+  }
+
+  filter_list->Append(filter->CreateDeepCopy());
+}
+
 void EventRouter::Observe(int type,
                           const content::NotificationSource& source,
                           const content::NotificationDetails& details) {
   switch (type) {
     case extensions::NOTIFICATION_EXTENSION_ENABLED: {
       // If the extension has a lazy background page, make sure it gets loaded
       // to register the events the extension is interested in.
       const Extension* extension =
           content::Details<const Extension>(details).ptr();
       if (BackgroundInfo::HasLazyBackgroundPage(extension)) {
@@ skipping 82 matching lines @@
                                      const std::string& extension_id,
                                      const GURL& listener_url,
                                      content::BrowserContext* browser_context)
     : event_name(event_name),
       extension_id(extension_id),
       listener_url(listener_url),
       browser_context(browser_context) {
 }
 
 }  // namespace extensions