Some linked_ptr -> unique_ptr conversion in extensions/browser.

extensions/browser/api/api_resource_manager.h

 // 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.
 
 #ifndef EXTENSIONS_BROWSER_API_API_RESOURCE_MANAGER_H_
 #define EXTENSIONS_BROWSER_API_API_RESOURCE_MANAGER_H_
 
 #include <map>
 #include <memory>
 
 #include "base/containers/hash_tables.h"
-#include "base/memory/linked_ptr.h"
+#include "base/memory/ptr_util.h"
 #include "base/memory/ref_counted.h"
 #include "base/scoped_observer.h"
 #include "base/threading/non_thread_safe.h"
 #include "components/keyed_service/core/keyed_service.h"
 #include "content/public/browser/browser_thread.h"
 #include "extensions/browser/browser_context_keyed_api_factory.h"
 #include "extensions/browser/extension_registry.h"
 #include "extensions/browser/extension_registry_observer.h"
 #include "extensions/browser/process_manager.h"
 #include "extensions/browser/process_manager_observer.h"
@@ skipping 150 matching lines @@
   friend class api::UDPSocketEventDispatcher;
   friend class BrowserContextKeyedAPIFactory<ApiResourceManager<T> >;
 
   static const bool kServiceHasOwnInstanceInIncognito = true;
   static const bool kServiceIsNULLWhileTesting = true;
 
   // ApiResourceData class handles resource bookkeeping on a thread
   // where resource lifetime is handled.
   class ApiResourceData : public base::RefCountedThreadSafe<ApiResourceData> {
    public:
-    typedef std::map<int, linked_ptr<T> > ApiResourceMap;
+    typedef std::map<int, std::unique_ptr<T>> ApiResourceMap;
     // Lookup map from extension id's to allocated resource id's.
     typedef std::map<std::string, base::hash_set<int> > ExtensionToResourceMap;
 
     ApiResourceData() : next_id_(1) {}
 
     int Add(T* api_resource) {

[Devlin, 2016/08/30 19:21:53]

here, too, add a TODO to make this (and Add() on line 114) take unique ptrs. 
(Wouldn't recommend doing that change in this CL - it's a little bit more
far-reaching.)

[lazyboy, 2016/08/30 20:30:56]

Done.

       DCHECK(ThreadingTraits::IsCalledOnValidThread());
       int id = GenerateId();
       if (id > 0) {
-        linked_ptr<T> resource_ptr(api_resource);
-        api_resource_map_[id] = resource_ptr;
+        api_resource_map_[id] = base::WrapUnique<T>(api_resource);
 
         const std::string& extension_id = api_resource->owner_extension_id();
         ExtensionToResourceMap::iterator it =
             extension_resource_map_.find(extension_id);
         if (it == extension_resource_map_.end()) {
           it = extension_resource_map_.insert(
               std::make_pair(extension_id, base::hash_set<int>())).first;
         }
         it->second.insert(id);
         return id;
@@ skipping 19 matching lines @@
     // Change the resource mapped to this |extension_id| at this
     // |api_resource_id| to |resource|. Returns true and succeeds unless
     // |api_resource_id| does not already identify a resource held by
     // |extension_id|.
     bool Replace(const std::string& extension_id,
                  int api_resource_id,
                  T* api_resource) {
       DCHECK(ThreadingTraits::IsCalledOnValidThread());
       T* old_resource = api_resource_map_[api_resource_id].get();
       if (old_resource && extension_id == old_resource->owner_extension_id()) {
-        api_resource_map_[api_resource_id] = linked_ptr<T>(api_resource);
+        api_resource_map_[api_resource_id] = base::WrapUnique<T>(api_resource);
         return true;
       }
       return false;
     }
 
     base::hash_set<int>* GetResourceIds(const std::string& extension_id) {
       DCHECK(ThreadingTraits::IsCalledOnValidThread());
       return GetOwnedResourceIds(extension_id);
     }
 
@@ skipping 29 matching lines @@
             FROM_HERE, base::Bind(&ApiResourceData::Cleanup, this));
       }
     }
 
    private:
     friend class base::RefCountedThreadSafe<ApiResourceData>;
 
     virtual ~ApiResourceData() {}
 
     T* GetOwnedResource(const std::string& extension_id, int api_resource_id) {
-      linked_ptr<T> ptr = api_resource_map_[api_resource_id];
+      const std::unique_ptr<T>& ptr = api_resource_map_[api_resource_id];
       T* resource = ptr.get();
       if (resource && extension_id == resource->owner_extension_id())
         return resource;
       return NULL;
     }
 
     base::hash_set<int>* GetOwnedResourceIds(const std::string& extension_id) {
       DCHECK(ThreadingTraits::IsCalledOnValidThread());
       ExtensionToResourceMap::iterator it =
           extension_resource_map_.find(extension_id);
@@ skipping 23 matching lines @@
 
       // Remove all resources, or the non persistent ones only if |remove_all|
       // is false.
       base::hash_set<int>& resource_ids = it->second;
       for (base::hash_set<int>::iterator it = resource_ids.begin();
            it != resource_ids.end();) {
         bool erase = false;
         if (remove_all) {
           erase = true;
         } else {
-          linked_ptr<T> ptr = api_resource_map_[*it];
+          std::unique_ptr<T>& ptr = api_resource_map_[*it];
           T* resource = ptr.get();
           erase = (resource && !resource->IsPersistent());
         }
 
         if (erase) {
           api_resource_map_.erase(*it);
           resource_ids.erase(it++);
         } else {
           ++it;
         }
@@ skipping 90 matching lines @@
         ->GetSequencedTaskRunnerWithShutdownBehavior(
             content::BrowserThread::GetBlockingPool()->GetNamedSequenceToken(
                 T::kSequenceToken),
             T::kShutdownBehavior);
   }
 };
 
 }  // namespace extensions
 
 #endif  // EXTENSIONS_BROWSER_API_API_RESOURCE_MANAGER_H_