Correct the OnListenerRemoved semantic of EventListenerMap::Delegate

chrome/browser/extensions/event_listener_map.cc

 // Copyright (c) 2012 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 "chrome/browser/extensions/event_listener_map.h"
 
 #include "base/values.h"
 
 #include "chrome/browser/extensions/event_router.h"
 
@@ skipping 62 matching lines @@
     DictionaryValue* filter_dict) {
   return scoped_ptr<EventMatcher>(new EventMatcher(
       scoped_ptr<DictionaryValue>(filter_dict->DeepCopy())));
 }
 
 bool EventListenerMap::RemoveListener(const EventListener* listener) {
   ListenerList& listeners = listeners_[listener->event_name];
   for (ListenerList::iterator it = listeners.begin(); it != listeners.end();
        it++) {
     if ((*it)->Equals(listener)) {
-      delegate_->OnListenerRemoved(it->get());
       CleanupListener(it->get());
       // Popping from the back should be cheaper than erase(it).
       std::swap(*it, listeners.back());
       listeners.pop_back();
+      delegate_->OnListenerRemoved(listener);
       return true;
     }
   }
   return false;
 }
 
 bool EventListenerMap::HasListenerForEvent(const std::string& event_name) {
   ListenerMap::iterator it = listeners_.find(event_name);
   return it != listeners_.end() && !it->second.empty();
 }
@@ skipping 110 matching lines @@
 }
 
 void EventListenerMap::RemoveListenersForProcess(
     const content::RenderProcessHost* process) {
   CHECK(process);
   for (ListenerMap::iterator it = listeners_.begin(); it != listeners_.end();
        it++) {
     for (ListenerList::iterator it2 = it->second.begin();
          it2 != it->second.end();) {
       if ((*it2)->process == process) {
-        delegate_->OnListenerRemoved(it2->get());
+        linked_ptr<EventListener> listener(*it2);
         CleanupListener(it2->get());
         it2 = it->second.erase(it2);
+        delegate_->OnListenerRemoved(listener.get());
       } else {
         it2++;
       }
     }
   }
 }
 
 void EventListenerMap::CleanupListener(EventListener* listener) {
   // If the listener doesn't have a filter then we have nothing to clean up.
   if (listener->matcher_id == -1)
     return;
   event_filter_.RemoveEventMatcher(listener->matcher_id);
   CHECK_EQ(1u, listeners_by_matcher_id_.erase(listener->matcher_id));
 }
 
 bool EventListenerMap::IsFilteredEvent(const Event& event) const {
   return filtered_events_.count(event.event_name) > 0u;
 }
 
 }  // namespace extensions