Some linked_ptr -> unique_ptr conversion in extensions/browser.

extensions/browser/event_listener_map.cc

 // Copyright 2013 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/browser/event_listener_map.h"
 
 #include <stddef.h>
 
 #include <utility>
 
@@ skipping 87 matching lines @@
     return false;
   if (listener->filter()) {
     std::unique_ptr<EventMatcher> matcher(
         ParseEventMatcher(listener->filter()));
     MatcherID id = event_filter_.AddEventMatcher(listener->event_name(),
                                                  std::move(matcher));
     listener->set_matcher_id(id);
     listeners_by_matcher_id_[id] = listener.get();
     filtered_events_.insert(listener->event_name());
   }
-  linked_ptr<EventListener> listener_ptr(listener.release());
-  listeners_[listener_ptr->event_name()].push_back(listener_ptr);
+  EventListener* listener_ptr = listener.get();
+  listeners_[listener->event_name()].push_back(std::move(listener));
 
-  delegate_->OnListenerAdded(listener_ptr.get());
+  delegate_->OnListenerAdded(listener_ptr);
 
   return true;
 }
 
 std::unique_ptr<EventMatcher> EventListenerMap::ParseEventMatcher(
     DictionaryValue* filter_dict) {
   return std::unique_ptr<EventMatcher>(new EventMatcher(
       base::WrapUnique(filter_dict->DeepCopy()), MSG_ROUTING_NONE));
 }
 
@@ skipping 60 matching lines @@
   return false;
 }
 
 void EventListenerMap::RemoveListenersForExtension(
     const std::string& extension_id) {
   for (ListenerMap::iterator it = listeners_.begin(); it != listeners_.end();
        it++) {
     for (ListenerList::iterator it2 = it->second.begin();
          it2 != it->second.end();) {
       if ((*it2)->extension_id() == extension_id) {
-        linked_ptr<EventListener> listener(*it2);
-        CleanupListener(listener.get());
+        std::unique_ptr<EventListener> listener_removed = std::move(*it2);
+        CleanupListener(listener_removed.get());
         it2 = it->second.erase(it2);
-        delegate_->OnListenerRemoved(listener.get());
+        delegate_->OnListenerRemoved(listener_removed.get());
       } else {
         it2++;
       }
     }
   }
 }
 
 void EventListenerMap::LoadUnfilteredLazyListeners(
     const std::string& extension_id,
     const std::set<std::string>& event_names) {
@@ skipping 48 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) {
-        linked_ptr<EventListener> listener(*it2);
-        CleanupListener(it2->get());
+        std::unique_ptr<EventListener> listener_removed = std::move(*it2);
+        CleanupListener(listener_removed.get());
         it2 = it->second.erase(it2);
-        delegate_->OnListenerRemoved(listener.get());
+        delegate_->OnListenerRemoved(listener_removed.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