api_event_handler.cc 15 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397
  1. // Copyright 2016 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/renderer/bindings/api_event_handler.h"
  5. #include <algorithm>
  6. #include <map>
  7. #include <memory>
  8. #include <utility>
  9. #include <vector>
  10. #include "base/bind.h"
  11. #include "base/callback_helpers.h"
  12. #include "base/check.h"
  13. #include "base/notreached.h"
  14. #include "base/supports_user_data.h"
  15. #include "base/values.h"
  16. #include "content/public/renderer/v8_value_converter.h"
  17. #include "extensions/common/mojom/event_dispatcher.mojom.h"
  18. #include "extensions/renderer/bindings/api_response_validator.h"
  19. #include "extensions/renderer/bindings/event_emitter.h"
  20. #include "extensions/renderer/bindings/get_per_context_data.h"
  21. #include "extensions/renderer/bindings/js_runner.h"
  22. #include "gin/handle.h"
  23. #include "gin/per_context_data.h"
  24. namespace extensions {
  25. namespace {
  26. struct APIEventPerContextData : public base::SupportsUserData::Data {
  27. static constexpr char kPerContextDataKey[] = "extension_api_events";
  28. APIEventPerContextData(v8::Isolate* isolate) : isolate(isolate) {}
  29. ~APIEventPerContextData() override {
  30. DCHECK(emitters.empty())
  31. << "|emitters| should have been cleared by InvalidateContext()";
  32. DCHECK(massagers.empty())
  33. << "|massagers| should have been cleared by InvalidateContext()";
  34. DCHECK(anonymous_emitters.empty())
  35. << "|anonymous_emitters| should have been cleared by "
  36. << "InvalidateContext()";
  37. }
  38. // The associated v8::Isolate. Since this object is cleaned up at context
  39. // destruction, this should always be valid.
  40. v8::Isolate* isolate;
  41. // A map from event name -> event emitter.
  42. std::map<std::string, v8::Global<v8::Object>> emitters;
  43. // A map from event name -> argument massager.
  44. std::map<std::string, v8::Global<v8::Function>> massagers;
  45. // The collection of anonymous events.
  46. std::vector<v8::Global<v8::Object>> anonymous_emitters;
  47. static APIEventPerContextData* GetFrom(v8::Local<v8::Context> context,
  48. CreatePerContextData should_create) {
  49. return GetPerContextData<APIEventPerContextData>(context, should_create,
  50. context->GetIsolate());
  51. }
  52. };
  53. constexpr char APIEventPerContextData::kPerContextDataKey[];
  54. void DispatchEvent(const v8::FunctionCallbackInfo<v8::Value>& info) {
  55. v8::Isolate* isolate = info.GetIsolate();
  56. v8::HandleScope handle_scope(isolate);
  57. if (info.Length() != 1 || !info[0]->IsArray()) {
  58. NOTREACHED();
  59. return;
  60. }
  61. v8::Local<v8::Context> context = isolate->GetCurrentContext();
  62. APIEventPerContextData* data =
  63. APIEventPerContextData::GetFrom(context, kDontCreateIfMissing);
  64. DCHECK(data);
  65. std::string event_name = gin::V8ToString(isolate, info.Data());
  66. auto iter = data->emitters.find(event_name);
  67. if (iter == data->emitters.end())
  68. return;
  69. v8::Global<v8::Object>& v8_emitter = iter->second;
  70. std::vector<v8::Local<v8::Value>> args;
  71. CHECK(gin::Converter<std::vector<v8::Local<v8::Value>>>::FromV8(
  72. isolate, info[0], &args));
  73. EventEmitter* emitter = nullptr;
  74. gin::Converter<EventEmitter*>::FromV8(isolate, v8_emitter.Get(isolate),
  75. &emitter);
  76. CHECK(emitter);
  77. // Note: It's safe to use EventEmitter::FireSync() here because this should
  78. // only be triggered from a JS call, so we know JS is running.
  79. // TODO(devlin): It looks like the return result that requires this to be sync
  80. // is only used by the InputIME custom bindings; it would be kind of nice to
  81. // remove the dependency.
  82. info.GetReturnValue().Set(emitter->FireSync(context, &args, nullptr));
  83. }
  84. } // namespace
  85. APIEventHandler::APIEventHandler(
  86. const APIEventListeners::ListenersUpdated& listeners_changed,
  87. const APIEventListeners::ContextOwnerIdGetter& context_owner_id_getter,
  88. ExceptionHandler* exception_handler)
  89. : listeners_changed_(listeners_changed),
  90. context_owner_id_getter_(context_owner_id_getter),
  91. exception_handler_(exception_handler) {}
  92. APIEventHandler::~APIEventHandler() {}
  93. void APIEventHandler::SetResponseValidator(
  94. std::unique_ptr<APIResponseValidator> validator) {
  95. api_response_validator_ = std::move(validator);
  96. }
  97. v8::Local<v8::Object> APIEventHandler::CreateEventInstance(
  98. const std::string& event_name,
  99. bool supports_filters,
  100. bool supports_lazy_listeners,
  101. int max_listeners,
  102. bool notify_on_change,
  103. v8::Local<v8::Context> context) {
  104. // We need a context scope since gin::CreateHandle only takes the isolate
  105. // and infers the context from that.
  106. // TODO(devlin): This could be avoided if gin::CreateHandle could take a
  107. // context directly.
  108. v8::Context::Scope context_scope(context);
  109. APIEventPerContextData* data =
  110. APIEventPerContextData::GetFrom(context, kCreateIfMissing);
  111. DCHECK(data->emitters.find(event_name) == data->emitters.end());
  112. APIEventListeners::ListenersUpdated updated =
  113. notify_on_change ? listeners_changed_ : base::DoNothing();
  114. std::unique_ptr<APIEventListeners> listeners;
  115. if (supports_filters) {
  116. listeners = std::make_unique<FilteredEventListeners>(
  117. updated, event_name, context_owner_id_getter_, max_listeners,
  118. supports_lazy_listeners, &listener_tracker_);
  119. } else {
  120. listeners = std::make_unique<UnfilteredEventListeners>(
  121. updated, event_name, context_owner_id_getter_, max_listeners,
  122. supports_lazy_listeners, &listener_tracker_);
  123. }
  124. gin::Handle<EventEmitter> emitter_handle =
  125. gin::CreateHandle(context->GetIsolate(),
  126. new EventEmitter(supports_filters, std::move(listeners),
  127. exception_handler_));
  128. CHECK(!emitter_handle.IsEmpty());
  129. v8::Local<v8::Value> emitter_value = emitter_handle.ToV8();
  130. CHECK(emitter_value->IsObject());
  131. v8::Local<v8::Object> emitter_object =
  132. v8::Local<v8::Object>::Cast(emitter_value);
  133. data->emitters[event_name] =
  134. v8::Global<v8::Object>(context->GetIsolate(), emitter_object);
  135. return emitter_object;
  136. }
  137. v8::Local<v8::Object> APIEventHandler::CreateAnonymousEventInstance(
  138. v8::Local<v8::Context> context) {
  139. v8::Context::Scope context_scope(context);
  140. APIEventPerContextData* data =
  141. APIEventPerContextData::GetFrom(context, kCreateIfMissing);
  142. bool supports_filters = false;
  143. // Anonymous events are not tracked, and thus don't need a name or a context
  144. // owner.
  145. std::string empty_event_name;
  146. ListenerTracker* anonymous_listener_tracker = nullptr;
  147. std::unique_ptr<APIEventListeners> listeners =
  148. std::make_unique<UnfilteredEventListeners>(
  149. base::DoNothing(), empty_event_name,
  150. APIEventListeners::ContextOwnerIdGetter(), binding::kNoListenerMax,
  151. false, anonymous_listener_tracker);
  152. gin::Handle<EventEmitter> emitter_handle =
  153. gin::CreateHandle(context->GetIsolate(),
  154. new EventEmitter(supports_filters, std::move(listeners),
  155. exception_handler_));
  156. CHECK(!emitter_handle.IsEmpty());
  157. v8::Local<v8::Object> emitter_object = emitter_handle.ToV8().As<v8::Object>();
  158. data->anonymous_emitters.push_back(
  159. v8::Global<v8::Object>(context->GetIsolate(), emitter_object));
  160. return emitter_object;
  161. }
  162. void APIEventHandler::InvalidateCustomEvent(v8::Local<v8::Context> context,
  163. v8::Local<v8::Object> event) {
  164. EventEmitter* emitter = nullptr;
  165. APIEventPerContextData* data =
  166. APIEventPerContextData::GetFrom(context, kDontCreateIfMissing);
  167. // This could happen if a port (or JS) invalidates an event following
  168. // context destruction.
  169. // TODO(devlin): Is it better to fail gracefully here, or track all these
  170. // down for determinism?
  171. if (!data)
  172. return;
  173. if (!gin::Converter<EventEmitter*>::FromV8(context->GetIsolate(), event,
  174. &emitter)) {
  175. NOTREACHED();
  176. return;
  177. }
  178. emitter->Invalidate(context);
  179. auto emitter_entry = std::find(data->anonymous_emitters.begin(),
  180. data->anonymous_emitters.end(), event);
  181. if (emitter_entry == data->anonymous_emitters.end()) {
  182. NOTREACHED();
  183. return;
  184. }
  185. data->anonymous_emitters.erase(emitter_entry);
  186. }
  187. void APIEventHandler::FireEventInContext(const std::string& event_name,
  188. v8::Local<v8::Context> context,
  189. const base::Value::List& args,
  190. mojom::EventFilteringInfoPtr filter) {
  191. // Don't bother converting arguments if there are no listeners.
  192. // NOTE(devlin): This causes a double data and EventEmitter lookup, since
  193. // the v8 version below also checks for listeners. This should be very cheap,
  194. // but if we were really worried we could refactor.
  195. if (!HasListenerForEvent(event_name, context))
  196. return;
  197. // Note: since we only convert the arguments once, if a listener modifies an
  198. // object (including an array), other listeners will see that modification.
  199. // TODO(devlin): This is how it's always been, but should it be?
  200. std::unique_ptr<content::V8ValueConverter> converter =
  201. content::V8ValueConverter::Create();
  202. std::vector<v8::Local<v8::Value>> v8_args;
  203. v8_args.reserve(args.size());
  204. for (const auto& arg : args)
  205. v8_args.push_back(converter->ToV8Value(arg, context));
  206. FireEventInContext(event_name, context, &v8_args, std::move(filter),
  207. JSRunner::ResultCallback());
  208. }
  209. void APIEventHandler::FireEventInContext(
  210. const std::string& event_name,
  211. v8::Local<v8::Context> context,
  212. std::vector<v8::Local<v8::Value>>* arguments,
  213. mojom::EventFilteringInfoPtr filter,
  214. JSRunner::ResultCallback callback) {
  215. APIEventPerContextData* data =
  216. APIEventPerContextData::GetFrom(context, kDontCreateIfMissing);
  217. if (!data)
  218. return;
  219. auto iter = data->emitters.find(event_name);
  220. if (iter == data->emitters.end())
  221. return;
  222. EventEmitter* emitter = nullptr;
  223. gin::Converter<EventEmitter*>::FromV8(
  224. context->GetIsolate(), iter->second.Get(context->GetIsolate()), &emitter);
  225. CHECK(emitter);
  226. auto massager_iter = data->massagers.find(event_name);
  227. if (massager_iter == data->massagers.end()) {
  228. // Validate the event arguments if there are no massagers (and validation is
  229. // enabled). Unfortunately, massagers both transform the event args from
  230. // unexpected -> expected and (badly!) from expected -> unexpected. As such,
  231. // we simply don't validate if there's a massager attached to the event.
  232. // TODO(crbug.com/1329587): Ideally, we'd be able to validate the response
  233. // after the massagers run. This requires fixing our schema for at least
  234. // chrome.permissions events.
  235. if (api_response_validator_) {
  236. api_response_validator_->ValidateEvent(context, event_name, *arguments);
  237. }
  238. emitter->Fire(context, arguments, std::move(filter), std::move(callback));
  239. } else {
  240. DCHECK(!callback) << "Can't use an event callback with argument massagers.";
  241. v8::Isolate* isolate = context->GetIsolate();
  242. v8::HandleScope handle_scope(isolate);
  243. v8::Local<v8::Function> massager = massager_iter->second.Get(isolate);
  244. v8::Local<v8::Array> args_array =
  245. v8::Array::New(isolate, arguments->size());
  246. {
  247. // Massagers expect an array of v8 values. Since this is a newly-
  248. // constructed array and we're assigning data properties, this shouldn't
  249. // be able to fail or be visible by other script.
  250. for (size_t i = 0; i < arguments->size(); ++i) {
  251. v8::Maybe<bool> success = args_array->CreateDataProperty(
  252. context, static_cast<uint32_t>(i), arguments->at(i));
  253. CHECK(success.ToChecked());
  254. }
  255. }
  256. // Curry in the native dispatch function. Some argument massagers take
  257. // extra liberties and call this asynchronously, so we can't just have the
  258. // massager return a modified array of arguments.
  259. // We don't store this in a template because the Data (event name) is
  260. // different for each instance. Luckily, this is called during dispatching
  261. // an event, rather than e.g. at initialization time.
  262. v8::Local<v8::Function> dispatch_event =
  263. v8::Function::New(context, &DispatchEvent,
  264. gin::StringToSymbol(isolate, event_name))
  265. .ToLocalChecked();
  266. v8::Local<v8::Value> massager_args[] = {args_array, dispatch_event};
  267. JSRunner::Get(context)->RunJSFunction(
  268. massager, context, std::size(massager_args), massager_args);
  269. }
  270. }
  271. void APIEventHandler::RegisterArgumentMassager(
  272. v8::Local<v8::Context> context,
  273. const std::string& event_name,
  274. v8::Local<v8::Function> massager) {
  275. APIEventPerContextData* data =
  276. APIEventPerContextData::GetFrom(context, kCreateIfMissing);
  277. DCHECK(data->massagers.find(event_name) == data->massagers.end());
  278. data->massagers[event_name].Reset(context->GetIsolate(), massager);
  279. }
  280. bool APIEventHandler::HasListenerForEvent(const std::string& event_name,
  281. v8::Local<v8::Context> context) {
  282. APIEventPerContextData* data =
  283. APIEventPerContextData::GetFrom(context, kDontCreateIfMissing);
  284. if (!data)
  285. return false;
  286. auto iter = data->emitters.find(event_name);
  287. if (iter == data->emitters.end())
  288. return false;
  289. EventEmitter* emitter = nullptr;
  290. gin::Converter<EventEmitter*>::FromV8(
  291. context->GetIsolate(), iter->second.Get(context->GetIsolate()), &emitter);
  292. CHECK(emitter);
  293. return emitter->GetNumListeners() > 0;
  294. }
  295. void APIEventHandler::InvalidateContext(v8::Local<v8::Context> context) {
  296. DCHECK(gin::PerContextData::From(context))
  297. << "Trying to invalidate an already-invalid context.";
  298. APIEventPerContextData* data =
  299. APIEventPerContextData::GetFrom(context, kDontCreateIfMissing);
  300. if (!data)
  301. return;
  302. v8::Isolate* isolate = context->GetIsolate();
  303. v8::HandleScope scope(isolate);
  304. // This loop *shouldn't* allow any self-modification (i.e., no listeners
  305. // should be added or removed as a result of the iteration). If that changes,
  306. // we'll need to cache the listeners elsewhere before iterating.
  307. for (const auto& pair : data->emitters) {
  308. EventEmitter* emitter = nullptr;
  309. gin::Converter<EventEmitter*>::FromV8(isolate, pair.second.Get(isolate),
  310. &emitter);
  311. CHECK(emitter);
  312. emitter->Invalidate(context);
  313. }
  314. for (const auto& global : data->anonymous_emitters) {
  315. EventEmitter* emitter = nullptr;
  316. gin::Converter<EventEmitter*>::FromV8(isolate, global.Get(isolate),
  317. &emitter);
  318. CHECK(emitter);
  319. emitter->Invalidate(context);
  320. }
  321. data->emitters.clear();
  322. data->massagers.clear();
  323. data->anonymous_emitters.clear();
  324. // InvalidateContext() is called shortly (and, theoretically, synchronously)
  325. // before the PerContextData is deleted. We have a check that guarantees that
  326. // no new EventEmitters are created after the PerContextData is deleted, so
  327. // no new emitters should be created after this point.
  328. }
  329. size_t APIEventHandler::GetNumEventListenersForTesting(
  330. const std::string& event_name,
  331. v8::Local<v8::Context> context) {
  332. APIEventPerContextData* data =
  333. APIEventPerContextData::GetFrom(context, kDontCreateIfMissing);
  334. DCHECK(data);
  335. auto iter = data->emitters.find(event_name);
  336. DCHECK(iter != data->emitters.end());
  337. EventEmitter* emitter = nullptr;
  338. gin::Converter<EventEmitter*>::FromV8(
  339. context->GetIsolate(), iter->second.Get(context->GetIsolate()), &emitter);
  340. CHECK(emitter);
  341. return emitter->GetNumListeners();
  342. }
  343. } // namespace extensions