event_listener_map.cc 13 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376
  1. // Copyright 2013 The Chromium Authors. All rights reserved.
  2. // Use of this source code is governed by a BSD-style license that can be
  3. // found in the LICENSE file.
  4. #include "extensions/browser/event_listener_map.h"
  5. #include <stddef.h>
  6. #include <utility>
  7. #include "base/containers/contains.h"
  8. #include "base/memory/ptr_util.h"
  9. #include "base/values.h"
  10. #include "content/public/browser/render_process_host.h"
  11. #include "extensions/browser/event_router.h"
  12. #include "extensions/common/constants.h"
  13. #include "ipc/ipc_message.h"
  14. #include "url/gurl.h"
  15. #include "url/origin.h"
  16. using base::DictionaryValue;
  17. namespace extensions {
  18. typedef EventFilter::MatcherID MatcherID;
  19. // static
  20. std::unique_ptr<EventListener> EventListener::ForExtension(
  21. const std::string& event_name,
  22. const std::string& extension_id,
  23. content::RenderProcessHost* process,
  24. std::unique_ptr<base::DictionaryValue> filter) {
  25. return base::WrapUnique(
  26. new EventListener(event_name, extension_id, GURL(), process, false,
  27. blink::mojom::kInvalidServiceWorkerVersionId,
  28. kMainThreadId, std::move(filter)));
  29. }
  30. // static
  31. std::unique_ptr<EventListener> EventListener::ForURL(
  32. const std::string& event_name,
  33. const GURL& listener_url,
  34. content::RenderProcessHost* process,
  35. std::unique_ptr<base::DictionaryValue> filter) {
  36. // Use only the origin to identify the event listener, e.g. chrome://settings
  37. // for chrome://settings/accounts, to avoid multiple events being triggered
  38. // for the same process. See crbug.com/536858 for details. // TODO(devlin): If
  39. // we dispatched events to processes more intelligently this could be avoided.
  40. return base::WrapUnique(new EventListener(
  41. event_name, ExtensionId(), url::Origin::Create(listener_url).GetURL(),
  42. process, false, blink::mojom::kInvalidServiceWorkerVersionId,
  43. kMainThreadId, std::move(filter)));
  44. }
  45. std::unique_ptr<EventListener> EventListener::ForExtensionServiceWorker(
  46. const std::string& event_name,
  47. const std::string& extension_id,
  48. content::RenderProcessHost* process,
  49. const GURL& service_worker_scope,
  50. int64_t service_worker_version_id,
  51. int worker_thread_id,
  52. std::unique_ptr<base::DictionaryValue> filter) {
  53. return base::WrapUnique(new EventListener(
  54. event_name, extension_id, service_worker_scope, process, true,
  55. service_worker_version_id, worker_thread_id, std::move(filter)));
  56. }
  57. EventListener::~EventListener() {}
  58. bool EventListener::Equals(const EventListener* other) const {
  59. // We don't check matcher_id equality because we want a listener with a
  60. // filter that hasn't been added to EventFilter to match one that is
  61. // equivalent but has.
  62. return event_name_ == other->event_name_ &&
  63. extension_id_ == other->extension_id_ &&
  64. listener_url_ == other->listener_url_ && process_ == other->process_ &&
  65. is_for_service_worker_ == other->is_for_service_worker_ &&
  66. service_worker_version_id_ == other->service_worker_version_id_ &&
  67. worker_thread_id_ == other->worker_thread_id_ &&
  68. ((!!filter_.get()) == (!!other->filter_.get())) &&
  69. (!filter_.get() || *filter_ == *other->filter_);
  70. }
  71. std::unique_ptr<EventListener> EventListener::Copy() const {
  72. std::unique_ptr<DictionaryValue> filter_copy;
  73. if (filter_)
  74. filter_copy = filter_->CreateDeepCopy();
  75. return base::WrapUnique(
  76. new EventListener(event_name_, extension_id_, listener_url_, process_,
  77. is_for_service_worker_, service_worker_version_id_,
  78. worker_thread_id_, std::move(filter_copy)));
  79. }
  80. bool EventListener::IsLazy() const {
  81. return !process_;
  82. }
  83. void EventListener::MakeLazy() {
  84. // A lazy listener neither has a process attached to it nor it has a worker
  85. // thread (if the listener was for a service worker), so reset these values
  86. // below to reflect that.
  87. if (is_for_service_worker_) {
  88. worker_thread_id_ = kMainThreadId;
  89. service_worker_version_id_ = blink::mojom::kInvalidServiceWorkerVersionId;
  90. }
  91. process_ = nullptr;
  92. }
  93. content::BrowserContext* EventListener::GetBrowserContext() const {
  94. return process_ ? process_->GetBrowserContext() : nullptr;
  95. }
  96. EventListener::EventListener(const std::string& event_name,
  97. const std::string& extension_id,
  98. const GURL& listener_url,
  99. content::RenderProcessHost* process,
  100. bool is_for_service_worker,
  101. int64_t service_worker_version_id,
  102. int worker_thread_id,
  103. std::unique_ptr<DictionaryValue> filter)
  104. : event_name_(event_name),
  105. extension_id_(extension_id),
  106. listener_url_(listener_url),
  107. process_(process),
  108. is_for_service_worker_(is_for_service_worker),
  109. service_worker_version_id_(service_worker_version_id),
  110. worker_thread_id_(worker_thread_id),
  111. filter_(std::move(filter)),
  112. matcher_id_(-1) {
  113. if (!IsLazy()) {
  114. DCHECK_EQ(is_for_service_worker, worker_thread_id != kMainThreadId);
  115. DCHECK_EQ(is_for_service_worker,
  116. service_worker_version_id !=
  117. blink::mojom::kInvalidServiceWorkerVersionId);
  118. }
  119. }
  120. EventListenerMap::EventListenerMap(Delegate* delegate)
  121. : delegate_(delegate) {
  122. }
  123. EventListenerMap::~EventListenerMap() {}
  124. bool EventListenerMap::AddListener(std::unique_ptr<EventListener> listener) {
  125. if (HasListener(listener.get()))
  126. return false;
  127. if (listener->filter()) {
  128. std::unique_ptr<EventMatcher> matcher(
  129. ParseEventMatcher(listener->filter()));
  130. MatcherID id = event_filter_.AddEventMatcher(listener->event_name(),
  131. std::move(matcher));
  132. listener->set_matcher_id(id);
  133. listeners_by_matcher_id_[id] = listener.get();
  134. filtered_events_.insert(listener->event_name());
  135. }
  136. EventListener* listener_ptr = listener.get();
  137. listeners_[listener->event_name()].push_back(std::move(listener));
  138. delegate_->OnListenerAdded(listener_ptr);
  139. return true;
  140. }
  141. std::unique_ptr<EventMatcher> EventListenerMap::ParseEventMatcher(
  142. DictionaryValue* filter_dict) {
  143. return std::make_unique<EventMatcher>(filter_dict->CreateDeepCopy(),
  144. MSG_ROUTING_NONE);
  145. }
  146. bool EventListenerMap::RemoveListener(const EventListener* listener) {
  147. auto listener_itr = listeners_.find(listener->event_name());
  148. if (listener_itr == listeners_.end())
  149. return false;
  150. ListenerList& listeners = listener_itr->second;
  151. for (auto& it : listeners) {
  152. if (it->Equals(listener)) {
  153. CleanupListener(it.get());
  154. // Popping from the back should be cheaper than erase(it).
  155. std::swap(it, listeners.back());
  156. listeners.pop_back();
  157. if (listeners.empty())
  158. listeners_.erase(listener_itr);
  159. delegate_->OnListenerRemoved(listener);
  160. return true;
  161. }
  162. }
  163. return false;
  164. }
  165. bool EventListenerMap::HasListenerForEvent(
  166. const std::string& event_name) const {
  167. auto it = listeners_.find(event_name);
  168. return it != listeners_.end() && !it->second.empty();
  169. }
  170. bool EventListenerMap::HasListenerForExtension(
  171. const std::string& extension_id,
  172. const std::string& event_name) const {
  173. auto it = listeners_.find(event_name);
  174. if (it == listeners_.end())
  175. return false;
  176. for (const auto& listener_to_search : it->second) {
  177. if (listener_to_search->extension_id() == extension_id)
  178. return true;
  179. }
  180. return false;
  181. }
  182. bool EventListenerMap::HasListener(const EventListener* listener) const {
  183. auto it = listeners_.find(listener->event_name());
  184. if (it == listeners_.end())
  185. return false;
  186. for (const auto& listener_to_search : it->second) {
  187. if (listener_to_search->Equals(listener))
  188. return true;
  189. }
  190. return false;
  191. }
  192. bool EventListenerMap::HasProcessListener(
  193. content::RenderProcessHost* process,
  194. int worker_thread_id,
  195. const std::string& extension_id) const {
  196. for (const auto& it : listeners_) {
  197. for (const auto& listener : it.second) {
  198. if (listener->process() == process &&
  199. listener->extension_id() == extension_id &&
  200. listener->worker_thread_id() == worker_thread_id) {
  201. return true;
  202. }
  203. }
  204. }
  205. return false;
  206. }
  207. void EventListenerMap::RemoveListenersForExtension(
  208. const std::string& extension_id) {
  209. for (auto it = listeners_.begin(); it != listeners_.end();) {
  210. auto& listener_list = it->second;
  211. for (auto it2 = listener_list.begin(); it2 != listener_list.end();) {
  212. if ((*it2)->extension_id() == extension_id) {
  213. std::unique_ptr<EventListener> listener_removed = std::move(*it2);
  214. CleanupListener(listener_removed.get());
  215. it2 = listener_list.erase(it2);
  216. delegate_->OnListenerRemoved(listener_removed.get());
  217. } else {
  218. ++it2;
  219. }
  220. }
  221. // Check if we removed all the listeners from the list. If so,
  222. // remove the list entry entirely.
  223. if (listener_list.empty())
  224. it = listeners_.erase(it);
  225. else
  226. ++it;
  227. }
  228. }
  229. void EventListenerMap::LoadUnfilteredLazyListeners(
  230. const std::string& extension_id,
  231. const std::set<std::string>& event_names) {
  232. for (const auto& name : event_names) {
  233. AddListener(EventListener::ForExtension(
  234. name, extension_id, nullptr, std::unique_ptr<DictionaryValue>()));
  235. }
  236. }
  237. void EventListenerMap::LoadUnfilteredWorkerListeners(
  238. const ExtensionId& extension_id,
  239. const std::set<std::string>& event_names) {
  240. for (const auto& name : event_names) {
  241. AddListener(EventListener::ForExtensionServiceWorker(
  242. name, extension_id, nullptr,
  243. // TODO(lazyboy): We need to store correct scopes of each worker into
  244. // ExtensionPrefs for events. This currently assumes all workers are
  245. // registered in the '/' scope. https://crbug.com/773103.
  246. Extension::GetBaseURLFromExtensionId(extension_id),
  247. blink::mojom::kInvalidServiceWorkerVersionId, kMainThreadId, nullptr));
  248. }
  249. }
  250. void EventListenerMap::LoadFilteredLazyListeners(
  251. const std::string& extension_id,
  252. bool is_for_service_worker,
  253. const DictionaryValue& filtered) {
  254. for (DictionaryValue::Iterator it(filtered); !it.IsAtEnd(); it.Advance()) {
  255. // We skip entries if they are malformed.
  256. if (!it.value().is_list())
  257. continue;
  258. for (const base::Value& filter_value : it.value().GetListDeprecated()) {
  259. if (!filter_value.is_dict())
  260. continue;
  261. const base::DictionaryValue* filter =
  262. static_cast<const base::DictionaryValue*>(&filter_value);
  263. if (is_for_service_worker) {
  264. AddListener(EventListener::ForExtensionServiceWorker(
  265. it.key(), extension_id, nullptr,
  266. // TODO(lazyboy): We need to store correct scopes of each worker
  267. // into ExtensionPrefs for events. This currently assumes all
  268. // workers are registered in the '/' scope.
  269. // https://crbug.com/773103.
  270. Extension::GetBaseURLFromExtensionId(extension_id),
  271. blink::mojom::kInvalidServiceWorkerVersionId, kMainThreadId,
  272. filter->CreateDeepCopy()));
  273. } else {
  274. AddListener(EventListener::ForExtension(it.key(), extension_id, nullptr,
  275. filter->CreateDeepCopy()));
  276. }
  277. }
  278. }
  279. }
  280. std::set<const EventListener*> EventListenerMap::GetEventListeners(
  281. const Event& event) {
  282. std::set<const EventListener*> interested_listeners;
  283. if (IsFilteredEvent(event)) {
  284. // Look up the interested listeners via the EventFilter.
  285. std::set<MatcherID> ids = event_filter_.MatchEvent(
  286. event.event_name, *event.filter_info, MSG_ROUTING_NONE);
  287. for (const MatcherID& id : ids) {
  288. EventListener* listener = listeners_by_matcher_id_[id];
  289. CHECK(listener);
  290. interested_listeners.insert(listener);
  291. }
  292. } else {
  293. for (const auto& listener : listeners_[event.event_name])
  294. interested_listeners.insert(listener.get());
  295. }
  296. return interested_listeners;
  297. }
  298. void EventListenerMap::RemoveListenersForProcess(
  299. const content::RenderProcessHost* process) {
  300. CHECK(process);
  301. for (auto it = listeners_.begin(); it != listeners_.end();) {
  302. auto& listener_list = it->second;
  303. for (auto it2 = listener_list.begin(); it2 != listener_list.end();) {
  304. if ((*it2)->process() == process) {
  305. std::unique_ptr<EventListener> listener_removed = std::move(*it2);
  306. CleanupListener(listener_removed.get());
  307. it2 = listener_list.erase(it2);
  308. delegate_->OnListenerRemoved(listener_removed.get());
  309. } else {
  310. ++it2;
  311. }
  312. }
  313. // Check if we removed all the listeners from the list. If so,
  314. // remove the list entry entirely.
  315. if (listener_list.empty())
  316. it = listeners_.erase(it);
  317. else
  318. ++it;
  319. }
  320. }
  321. void EventListenerMap::CleanupListener(EventListener* listener) {
  322. // If the listener doesn't have a filter then we have nothing to clean up.
  323. if (listener->matcher_id() == -1)
  324. return;
  325. // If we're removing the final listener for an event, we can remove the
  326. // entry from |filtered_events_|, as well.
  327. auto iter = listeners_.find(listener->event_name());
  328. if (iter->second.size() == 1)
  329. filtered_events_.erase(iter->first);
  330. event_filter_.RemoveEventMatcher(listener->matcher_id());
  331. CHECK_EQ(1u, listeners_by_matcher_id_.erase(listener->matcher_id()));
  332. }
  333. bool EventListenerMap::IsFilteredEvent(const Event& event) const {
  334. return base::Contains(filtered_events_, event.event_name);
  335. }
  336. } // namespace extensions