Mandate unique_ptr for base::IDMap in IDMapOwnPointer mode.

content/browser/permissions/permission_service_impl.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 "content/browser/permissions/permission_service_impl.h"
 
 #include <stddef.h>
+
+#include <memory>
 #include <utility>
 
 #include "base/bind.h"
+#include "base/memory/ptr_util.h"
 #include "content/public/browser/browser_context.h"
 #include "content/public/browser/permission_manager.h"
 #include "content/public/browser/permission_type.h"
 
 using blink::mojom::PermissionDescriptorPtr;
 using blink::mojom::PermissionName;
 using blink::mojom::PermissionStatus;
 
 namespace content {
 
@@ skipping 102 matching lines @@
   // any UI, we want to still return something relevant so the current
   // permission status is returned.
   BrowserContext* browser_context = context_->GetBrowserContext();
   DCHECK(browser_context);
   if (!context_->render_frame_host() ||
       !browser_context->GetPermissionManager()) {
     callback.Run(GetPermissionStatus(permission, origin));
     return;
   }
 
-  int pending_request_id = pending_requests_.Add(new PendingRequest(
-      base::Bind(&PermissionRequestResponseCallbackWrapper, callback), 1));
+  int pending_request_id =
+      pending_requests_.Add(base::MakeUnique<PendingRequest>(
+          base::Bind(&PermissionRequestResponseCallbackWrapper, callback), 1));
   int id = browser_context->GetPermissionManager()->RequestPermission(
       PermissionDescriptorToPermissionType(permission),
       context_->render_frame_host(), origin.GetURL(), user_gesture,
       base::Bind(&PermissionServiceImpl::OnRequestPermissionResponse,
                  weak_factory_.GetWeakPtr(), pending_request_id));
 
   // Check if the request still exists. It might have been removed by the
   // callback if it was run synchronously.
   PendingRequest* pending_request = pending_requests_.Lookup(
       pending_request_id);
@@ skipping 30 matching lines @@
       result[i] = GetPermissionStatus(permissions[i], origin);
     callback.Run(result);
     return;
   }
 
   std::vector<PermissionType> types(permissions.size());
   for (size_t i = 0; i < types.size(); ++i)
     types[i] = PermissionDescriptorToPermissionType(permissions[i]);
 
   int pending_request_id = pending_requests_.Add(
-      new PendingRequest(callback, permissions.size()));
+      base::MakeUnique<PendingRequest>(callback, permissions.size()));
   int id = browser_context->GetPermissionManager()->RequestPermissions(
       types, context_->render_frame_host(), origin.GetURL(), user_gesture,
       base::Bind(&PermissionServiceImpl::OnRequestPermissionsResponse,
                  weak_factory_.GetWeakPtr(), pending_request_id));
 
   // Check if the request still exists. It may have been removed by the
   // the response callback.
   PendingRequest* pending_request = pending_requests_.Lookup(
       pending_request_id);
   if (!pending_request)
@@ skipping 84 matching lines @@
     callback.Run(current_status);
     return;
   }
 
   PermissionType permission_type =
       PermissionDescriptorToPermissionType(permission);
 
   // We need to pass the id of PendingSubscription in pending_subscriptions_
   // to the callback but SubscribePermissionStatusChange() will also return an
   // id which is different.
-  PendingSubscription* subscription =
-      new PendingSubscription(permission_type, origin, callback);
-  int pending_subscription_id = pending_subscriptions_.Add(subscription);
+  auto subscription =
+      base::MakeUnique<PendingSubscription>(permission_type, origin, callback);
+  PendingSubscription* subscription_raw = subscription.get();
+  int pending_subscription_id =
+      pending_subscriptions_.Add(std::move(subscription));
 
   GURL requesting_origin(origin.Serialize());
   GURL embedding_origin = context_->GetEmbeddingOrigin();
-  subscription->id =
+  subscription_raw->id =
       browser_context->GetPermissionManager()->SubscribePermissionStatusChange(
           permission_type, requesting_origin,
           // If the embedding_origin is empty, we,ll use the |origin| instead.
           embedding_origin.is_empty() ? requesting_origin : embedding_origin,
           base::Bind(&PermissionServiceImpl::OnPermissionStatusChanged,
                      weak_factory_.GetWeakPtr(), pending_subscription_id));
 }
 
 PermissionStatus PermissionServiceImpl::GetPermissionStatus(
     const PermissionDescriptorPtr& permission,
@@ skipping 48 matching lines @@
 
   PermissionStatusCallback callback = subscription->callback;
 
   subscription->callback.Reset();
   pending_subscriptions_.Remove(pending_subscription_id);
 
   callback.Run(status);
 }
 
 }  // namespace content