[Extensions Bindings] Notify of event unregistration on invalidation

extensions/renderer/api_event_handler.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/api_event_handler.h"
 
 #include <algorithm>
 #include <map>
 #include <memory>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/logging.h"
 #include "base/memory/ptr_util.h"
 #include "base/supports_user_data.h"
 #include "base/values.h"
 #include "content/public/child/v8_value_converter.h"
 #include "extensions/renderer/event_emitter.h"
 #include "gin/handle.h"
 #include "gin/per_context_data.h"
 
 namespace extensions {
 
 namespace {
 
 const char kExtensionAPIEventPerContextKey[] = "extension_api_events";
 
 struct APIEventPerContextData : public base::SupportsUserData::Data {
   APIEventPerContextData(v8::Isolate* isolate) : isolate(isolate) {}
   ~APIEventPerContextData() override {

[Devlin, 2017/03/01 15:14:41]

If we wanted, we could maybe also make this DCHECK(event_data.empty()); and
assume that InvalidateContext() will be called for each context.  It would mean
updating our tests, but should be doable if it makes sense.  Lemme know if you
think it's worthwhile.

[jbroman, 2017/03/01 17:49:47]

Yeah, it's a little messy, but I'd rather not have two paths to clean this up,
especially given we only expect one of them to be reached in production.

[Devlin, 2017/03/01 19:03:50]

Done.

     v8::HandleScope scope(isolate);
     // We explicitly clear the event data map here to remove all references to
     // v8 objects. This helps us avoid cycles in v8 where an event listener
     // could hold a reference to the event, which in turn holds the reference
     // to the listener.
     for (const auto& pair : event_data) {
       EventEmitter* emitter = nullptr;
       gin::Converter<EventEmitter*>::FromV8(
           isolate, pair.second.Get(isolate), &emitter);
       CHECK(emitter);
-      emitter->listeners()->clear();
+      emitter->Invalidate();
     }
   }
 
   // The associated v8::Isolate. Since this object is cleaned up at context
   // destruction, this should always be valid.
   v8::Isolate* isolate;
 
   // A map from event name -> event emitter.
   std::map<std::string, v8::Global<v8::Object>> event_data;
 };
@@ skipping 68 matching lines @@
     v8_args.push_back(converter->ToV8Value(arg.get(), context));
 
   EventEmitter* emitter = nullptr;
   gin::Converter<EventEmitter*>::FromV8(
       context->GetIsolate(), iter->second.Get(context->GetIsolate()), &emitter);
   CHECK(emitter);
 
   emitter->Fire(context, &v8_args);
 }
 
+void APIEventHandler::InvalidateContext(v8::Local<v8::Context> context) {
+  gin::PerContextData* per_context_data = gin::PerContextData::From(context);
+  DCHECK(per_context_data);
+  APIEventPerContextData* data = static_cast<APIEventPerContextData*>(
+      per_context_data->GetUserData(kExtensionAPIEventPerContextKey));
+  if (!data)
+    return;
+
+  v8::Isolate* isolate = context->GetIsolate();
+  v8::HandleScope scope(isolate);
+  for (const auto& pair : data->event_data) {
+    EventEmitter* emitter = nullptr;
+    gin::Converter<EventEmitter*>::FromV8(isolate, pair.second.Get(isolate),
+                                          &emitter);
+    CHECK(emitter);
+    emitter->Invalidate();
+    listeners_changed_.Run(
+        pair.first, binding::EventListenersChanged::NO_LISTENERS, context);
+  }
+
+  data->event_data.clear();
+}
+
 size_t APIEventHandler::GetNumEventListenersForTesting(
     const std::string& event_name,
     v8::Local<v8::Context> context) {
   gin::PerContextData* per_context_data = gin::PerContextData::From(context);
   DCHECK(per_context_data);
   APIEventPerContextData* data = static_cast<APIEventPerContextData*>(
       per_context_data->GetUserData(kExtensionAPIEventPerContextKey));
   DCHECK(data);
 
   auto iter = data->event_data.find(event_name);
   DCHECK(iter != data->event_data.end());
   EventEmitter* emitter = nullptr;
   gin::Converter<EventEmitter*>::FromV8(
       context->GetIsolate(), iter->second.Get(context->GetIsolate()), &emitter);
   CHECK(emitter);
   return emitter->listeners()->size();
 }
 
 }  // namespace extensions