[Extensions Bindings] Notify of event unregistration on invalidation

extensions/renderer/native_extension_bindings_system_unittest.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/native_extension_bindings_system.h"
 
 #include "base/memory/ptr_util.h"
 #include "base/run_loop.h"
 #include "base/strings/stringprintf.h"
 #include "components/crx_file/id_util.h"
@@ skipping 81 matching lines @@
     script_context_set_ = base::MakeUnique<ScriptContextSet>(&extension_ids_);
     bindings_system_ = base::MakeUnique<NativeExtensionBindingsSystem>(
         base::Bind(&NativeExtensionBindingsSystemUnittest::MockSendRequestIPC,
                    base::Unretained(this)),
         base::Bind(&NativeExtensionBindingsSystemUnittest::MockSendListenerIPC,
                    base::Unretained(this)));
     APIBindingTest::SetUp();
   }
 
   void TearDown() override {
-    for (auto* context : raw_script_contexts_)
+    event_change_handler_.reset();
+
+    for (auto* context : raw_script_contexts_) {
+      bindings_system_->WillReleaseScriptContext(context);
       script_context_set_->Remove(context);
+    }
     base::RunLoop().RunUntilIdle();
     script_context_set_.reset();
     bindings_system_.reset();
     APIBindingTest::TearDown();
   }
 
   void MockSendRequestIPC(ScriptContext* context,
                           const ExtensionHostMsg_Request_Params& params) {
     last_params_.name = params.name;
     last_params_.arguments.Swap(params.arguments.CreateDeepCopy().get());
@@ skipping 19 matching lines @@
     auto script_context = base::MakeUnique<ScriptContext>(
         v8_context, nullptr, extension, context_type, extension, context_type);
     script_context->set_module_system(
         base::MakeUnique<ModuleSystem>(script_context.get(), source_map()));
     ScriptContext* raw_script_context = script_context.get();
     raw_script_contexts_.push_back(raw_script_context);
     script_context_set_->AddForTesting(std::move(script_context));
     return raw_script_context;
   }
 
+  void DisposeMainScriptContext() {
+    v8::Local<v8::Context> context = ContextLocal();
+    auto iter =
+        std::find_if(raw_script_contexts_.begin(), raw_script_contexts_.end(),
+                     [context](ScriptContext* script_context) {
+                       return script_context->v8_context() == context;
+                     });
+    ASSERT_TRUE(iter != raw_script_contexts_.end());
+    bindings_system_->WillReleaseScriptContext(*iter);
+    DisposeContext();
+    script_context_set_->Remove(*iter);
+    raw_script_contexts_.erase(iter);
+  }
+
   void RegisterExtension(const ExtensionId& id) { extension_ids_.insert(id); }
 
   void InitEventChangeHandler() {
     event_change_handler_ = base::MakeUnique<MockEventChangeHandler>();
   }
 
   NativeExtensionBindingsSystem* bindings_system() {
     return bindings_system_.get();
   }
   const ExtensionHostMsg_Request_Params& last_params() { return last_params_; }
@@ skipping 200 matching lines @@
       context, extension.get(), Feature::BLESSED_EXTENSION_CONTEXT);
   script_context->set_url(extension->url());
 
   bindings_system()->UpdateBindingsForContext(script_context);
 
   v8::Local<v8::Value> first_idle_object =
       V8ValueFromScriptSource(context, "chrome.idle");
   ASSERT_FALSE(first_idle_object.IsEmpty());
   EXPECT_TRUE(first_idle_object->IsObject());
 
-  DisposeContext();
+  DisposeMainScriptContext();
 
   // Check an API that was instantiated....
   v8::Local<v8::Value> second_idle_object =
       V8ValueFromScriptSource(context, "chrome.idle");
   ASSERT_FALSE(second_idle_object.IsEmpty());
   EXPECT_TRUE(second_idle_object->IsUndefined());
   // ... and also one that wasn't.
   v8::Local<v8::Value> power_object =
       V8ValueFromScriptSource(context, "chrome.power");
   ASSERT_FALSE(power_object.IsEmpty());
@@ skipping 350 matching lines @@
   const std::vector<std::string> kKeys = {"get", "set", "remove", "clear",
                                           "getBytesInUse"};
   for (const auto& key : kKeys) {
     v8::Local<v8::String> v8_key = gin::StringToV8(isolate(), key);
     EXPECT_TRUE(local_object->HasOwnProperty(context, v8_key).FromJust())
         << key;
   }
 }
 
 }  // namespace extensions