Revert of Move the event attach/detach logic on unload from event.js to

extensions/renderer/module_system.cc

 // Copyright 2014 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/module_system.h"
 
 #include "base/bind.h"
 #include "base/command_line.h"
-#include "base/logging.h"
 #include "base/stl_util.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/trace_event/trace_event.h"
 #include "content/public/renderer/render_frame.h"
 #include "content/public/renderer/render_view.h"
 #include "extensions/common/extension.h"
 #include "extensions/common/extensions_client.h"
 #include "extensions/renderer/console.h"
 #include "extensions/renderer/safe_builtins.h"
@@ skipping 125 matching lines @@
   global->SetHiddenValue(v8::String::NewFromUtf8(isolate, kModuleSystem),
                          v8::External::New(isolate, this));
 
   gin::ModuleRegistry::From(context->v8_context())->AddObserver(this);
   if (context_->GetRenderFrame()) {
     context_->GetRenderFrame()->EnsureMojoBuiltinsAreAvailable(
         context->isolate(), context->v8_context());
   }
 }
 
-ModuleSystem::~ModuleSystem() {
-}
+ModuleSystem::~ModuleSystem() { Invalidate(); }
 
 void ModuleSystem::Invalidate() {
+  if (!is_valid())
+    return;
+
   // Clear the module system properties from the global context. It's polite,
   // and we use this as a signal in lazy handlers that we no longer exist.
   {
     v8::HandleScope scope(GetIsolate());
     v8::Handle<v8::Object> global = context()->v8_context()->Global();
     global->DeleteHiddenValue(
         v8::String::NewFromUtf8(GetIsolate(), kModulesField));
     global->DeleteHiddenValue(
         v8::String::NewFromUtf8(GetIsolate(), kModuleSystem));
   }
 
-  // Invalidate all active and clobbered NativeHandlers we own.
-  for (const auto& handler : native_handler_map_)
-    handler.second->Invalidate();
-  for (const auto& clobbered_handler : clobbered_native_handlers_)
-    clobbered_handler->Invalidate();
+  // Invalidate all of the successfully required handlers we own.
+  for (NativeHandlerMap::iterator it = native_handler_map_.begin();
+       it != native_handler_map_.end();
+       ++it) {
+    it->second->Invalidate();
+  }
 
   ObjectBackedNativeHandler::Invalidate();
 }
 
 ModuleSystem::NativesEnabledScope::NativesEnabledScope(
     ModuleSystem* module_system)
     : module_system_(module_system) {
   module_system_->natives_enabled_++;
 }
 
@@ skipping 107 matching lines @@
     result = context_->CallFunction(func, argc, argv);
     if (try_catch.HasCaught())
       HandleException(try_catch);
   }
   return handle_scope.Escape(result);
 }
 
 void ModuleSystem::RegisterNativeHandler(
     const std::string& name,
     scoped_ptr<NativeHandler> native_handler) {
-  ClobberExistingNativeHandler(name);
   native_handler_map_[name] =
       linked_ptr<NativeHandler>(native_handler.release());
 }
 
 void ModuleSystem::OverrideNativeHandlerForTest(const std::string& name) {
-  ClobberExistingNativeHandler(name);
   overridden_native_handlers_.insert(name);
 }
 
 void ModuleSystem::RunString(const std::string& code, const std::string& name) {
   v8::HandleScope handle_scope(GetIsolate());
   RunString(v8::String::NewFromUtf8(GetIsolate(), code.c_str()),
             v8::String::NewFromUtf8(GetIsolate(), name.c_str()));
 }
 
 // static
@@ skipping 359 matching lines @@
     scoped_ptr<v8::Global<v8::Promise::Resolver>> resolver,
     v8::Handle<v8::Value> value) {
   if (!is_valid())
     return;
   v8::HandleScope handle_scope(GetIsolate());
   v8::Handle<v8::Promise::Resolver> resolver_local(
       v8::Local<v8::Promise::Resolver>::New(GetIsolate(), *resolver));
   resolver_local->Resolve(value);
 }
 
-void ModuleSystem::ClobberExistingNativeHandler(const std::string& name) {
-  NativeHandlerMap::iterator existing_handler = native_handler_map_.find(name);
-  if (existing_handler != native_handler_map_.end()) {
-    clobbered_native_handlers_.push_back(existing_handler->second);
-    native_handler_map_.erase(existing_handler);
-  }
-}
-
 }  // namespace extensions