[Extensions Bindings] Notify of event unregistration on invalidation

extensions/renderer/event_emitter.cc

 // 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"
@@ skipping 34 matching lines @@
   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::Invalidate() {
+  valid_ = false;
+  listeners_.clear();
+}
+
 void EventEmitter::AddListener(gin::Arguments* arguments) {
+  // If script from another context maintains a reference to this object, it's
+  // possible that functions can be called after this object's owning context
+  // is torn down and released by blink. We don't support this behavior, but
+  // we need to make sure nothing crashes, so early out of methods.
+  if (!valid_)
+    return;
+
   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) {
+  // See comment in AddListener().
+  if (!valid_)
+    return;
+
   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 (!valid_)
+    return;
+
   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