| // Copyright 2016 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/renderer/event_emitter.h" |
| |
| #include <algorithm> |
| |
| #include "gin/object_template_builder.h" |
| #include "gin/per_context_data.h" |
| |
| namespace extensions { |
| |
| gin::WrapperInfo EventEmitter::kWrapperInfo = {gin::kEmbedderNativeGin}; |
| |
| EventEmitter::EventEmitter(const binding::RunJSFunction& run_js, |
| const ListenersChangedMethod& listeners_changed) |
| : run_js_(run_js), listeners_changed_(listeners_changed) {} |
| |
| EventEmitter::~EventEmitter() {} |
| |
| gin::ObjectTemplateBuilder EventEmitter::GetObjectTemplateBuilder( |
| v8::Isolate* isolate) { |
| return Wrappable<EventEmitter>::GetObjectTemplateBuilder(isolate) |
| .SetMethod("addListener", &EventEmitter::AddListener) |
| .SetMethod("removeListener", &EventEmitter::RemoveListener) |
| .SetMethod("hasListener", &EventEmitter::HasListener) |
| .SetMethod("hasListeners", &EventEmitter::HasListeners) |
| // The following methods aren't part of the public API, but are used |
| // by our custom bindings and exposed on the public event object. :( |
| // TODO(devlin): Once we convert all custom bindings that use these, |
| // they can be removed. |
| .SetMethod("dispatch", &EventEmitter::Dispatch); |
| } |
| |
| void EventEmitter::Fire(v8::Local<v8::Context> context, |
| std::vector<v8::Local<v8::Value>>* args) { |
| // We create a local copy of listeners_ since the array can be modified during |
| // handling. |
| std::vector<v8::Local<v8::Function>> listeners; |
| listeners.reserve(listeners_.size()); |
| for (const auto& listener : listeners_) |
| listeners.push_back(listener.Get(context->GetIsolate())); |
| |
| for (const auto& listener : listeners) { |
| v8::TryCatch try_catch(context->GetIsolate()); |
| // SetVerbose() means the error will still get logged, which is what we |
| // want. We don't let it bubble up any further to prevent it from being |
| // surfaced in e.g. JS code that triggered the event. |
| try_catch.SetVerbose(true); |
| run_js_.Run(listener, context, args->size(), args->data()); |
| } |
| } |
| |
| void EventEmitter::AddListener(gin::Arguments* arguments) { |
| v8::Local<v8::Function> listener; |
| // TODO(devlin): For some reason, we don't throw an error when someone calls |
| // add/removeListener with no argument. We probably should. For now, keep |
| // the status quo, but we should revisit this. |
| if (!arguments->GetNext(&listener)) |
| return; |
| |
| v8::Local<v8::Object> holder; |
| CHECK(arguments->GetHolder(&holder)); |
| CHECK(!holder.IsEmpty()); |
| v8::Local<v8::Context> context = holder->CreationContext(); |
| if (!gin::PerContextData::From(context)) |
| return; |
| |
| if (!HasListener(listener)) { |
| listeners_.push_back( |
| v8::Global<v8::Function>(arguments->isolate(), listener)); |
| if (listeners_.size() == 1) { |
| listeners_changed_.Run(binding::EventListenersChanged::HAS_LISTENERS, |
| context); |
| } |
| } |
| } |
| |
| void EventEmitter::RemoveListener(gin::Arguments* arguments) { |
| v8::Local<v8::Function> listener; |
| // See comment in AddListener(). |
| if (!arguments->GetNext(&listener)) |
| return; |
| |
| auto iter = std::find(listeners_.begin(), listeners_.end(), listener); |
| if (iter != listeners_.end()) { |
| listeners_.erase(iter); |
| if (listeners_.empty()) { |
| v8::Local<v8::Object> holder; |
| CHECK(arguments->GetHolder(&holder)); |
| CHECK(!holder.IsEmpty()); |
| v8::Local<v8::Context> context = holder->CreationContext(); |
| listeners_changed_.Run(binding::EventListenersChanged::NO_LISTENERS, |
| context); |
| } |
| } |
| } |
| |
| bool EventEmitter::HasListener(v8::Local<v8::Function> listener) { |
| return std::find(listeners_.begin(), listeners_.end(), listener) != |
| listeners_.end(); |
| } |
| |
| bool EventEmitter::HasListeners() { |
| return !listeners_.empty(); |
| } |
| |
| void EventEmitter::Dispatch(gin::Arguments* arguments) { |
| if (listeners_.empty()) |
| return; |
| v8::HandleScope handle_scope(arguments->isolate()); |
| v8::Local<v8::Context> context = |
| arguments->isolate()->GetCurrentContext(); |
| std::vector<v8::Local<v8::Value>> v8_args; |
| if (arguments->Length() > 0) { |
| // Converting to v8::Values should never fail. |
| CHECK(arguments->GetRemaining(&v8_args)); |
| } |
| Fire(context, &v8_args); |
| } |
| |
| } // namespace extensions |