Some linked_ptr -> unique_ptr conversion in extensions/browser.

extensions/browser/guest_view/app_view/app_view_guest.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/browser/guest_view/app_view/app_view_guest.h"
 
 #include <utility>
 
 #include "base/command_line.h"
 #include "base/memory/ptr_util.h"
@@ skipping 35 matching lines @@
   ResponseInfo(const Extension* guest_extension,
                const base::WeakPtr<AppViewGuest>& app_view_guest,
                const GuestViewBase::WebContentsCreatedCallback& callback)
       : guest_extension(guest_extension),
         app_view_guest(app_view_guest),
         callback(callback) {}
 
   ~ResponseInfo() {}
 };
 
-typedef std::map<int, linked_ptr<ResponseInfo> > PendingResponseMap;
+using PendingResponseMap = std::map<int, std::unique_ptr<ResponseInfo>>;
 static base::LazyInstance<PendingResponseMap> pending_response_map =
     LAZY_INSTANCE_INITIALIZER;
 
 }  // namespace
 
 // static.
 const char AppViewGuest::Type[] = "appview";
 
 // static.
 bool AppViewGuest::CompletePendingRequest(
     content::BrowserContext* browser_context,
     const GURL& url,
     int guest_instance_id,
     const std::string& guest_extension_id,
     content::RenderProcessHost* guest_render_process_host) {
   PendingResponseMap* response_map = pending_response_map.Pointer();
   PendingResponseMap::iterator it = response_map->find(guest_instance_id);
   // Kill the requesting process if it is not the real guest.
   if (it == response_map->end()) {
     // The requester used an invalid |guest_instance_id|.
     bad_message::ReceivedBadMessage(guest_render_process_host,
                                     bad_message::AVG_BAD_INST_ID);
     return false;
   }
 
-  linked_ptr<ResponseInfo> response_info = it->second;
+  const std::unique_ptr<ResponseInfo>& response_info = it->second;

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

ditto re maybe using a raw ptr

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

Done.

   if (!response_info->app_view_guest ||
       (response_info->guest_extension->id() != guest_extension_id)) {
     // The app is trying to communicate with an <appview> not assigned to it, or
     // the <appview> is already dead "nullptr".
     bad_message::BadMessageReason reason = !response_info->app_view_guest
                                                ? bad_message::AVG_NULL_AVG
                                                : bad_message::AVG_BAD_EXT_ID;
     bad_message::ReceivedBadMessage(guest_render_process_host, reason);
     return false;
   }
@@ skipping 91 matching lines @@
   const Extension* guest_extension = enabled_extensions.GetByID(app_id);
   const Extension* embedder_extension =
       enabled_extensions.GetByID(GetOwnerSiteURL().host());
 
   if (!guest_extension || !guest_extension->is_platform_app() ||
       !embedder_extension | !embedder_extension->is_platform_app()) {
     callback.Run(nullptr);
     return;
   }
 
-  pending_response_map.Get().insert(
-      std::make_pair(guest_instance_id(),
-                     make_linked_ptr(new ResponseInfo(
-                                        guest_extension,
-                                        weak_ptr_factory_.GetWeakPtr(),
-                                        callback))));
+  pending_response_map.Get().insert(std::make_pair(
+      guest_instance_id(),
+      base::MakeUnique<ResponseInfo>(
+          guest_extension, weak_ptr_factory_.GetWeakPtr(), callback)));
 
   LazyBackgroundTaskQueue* queue =
       LazyBackgroundTaskQueue::Get(browser_context());
   if (queue->ShouldEnqueueTask(browser_context(), guest_extension)) {
     queue->AddPendingTask(
         browser_context(), guest_extension->id(),
         base::Bind(&AppViewGuest::LaunchAppAndFireEvent,
                    weak_ptr_factory_.GetWeakPtr(),
                    base::Passed(base::WrapUnique(data->DeepCopy())), callback));
     return;
@@ skipping 71 matching lines @@
 
 std::vector<int> AppViewGuest::GetAllRegisteredInstanceIdsForTesting() {
   std::vector<int> instances;
   for (const auto& key_value : pending_response_map.Get()) {
     instances.push_back(key_value.first);
   }
   return instances;
 }
 
 }  // namespace extensions