Mandate unique_ptr for base::IDMap in IDMapOwnPointer mode.

content/child/notifications/notification_manager.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/child/notifications/notification_manager.h"
 
 #include <utility>
 
 #include "base/lazy_instance.h"
 #include "base/metrics/histogram_macros.h"
@@ skipping 104 matching lines @@
     blink::WebNotificationShowCallbacks* callbacks) {
   DCHECK(service_worker_registration);
   DCHECK_EQ(notification_data.actions.size(),
             notification_resources->actionIcons.size());
 
   int64_t service_worker_registration_id =
       static_cast<WebServiceWorkerRegistrationImpl*>(
           service_worker_registration)
           ->registrationId();
 
   std::unique_ptr<blink::WebNotificationShowCallbacks> owned_callbacks(

[danakj, 2016/11/30 00:34:00]

this variable should go away, and pass a unique_ptr to this method. we even had
a unique_ptr on the other side and release()d it heh

       callbacks);
 
   // Verify that the author-provided payload size does not exceed our limit.
   // This is an implementation-defined limit to prevent abuse of notification
   // data as a storage mechanism. A UMA histogram records the requested sizes,
   // which enables us to track how much data authors are attempting to store.
   //
   // If the size exceeds this limit, reject the showNotification() promise. This
   // is outside of the boundaries set by the specification, but it gives authors
   // an indication that something has gone wrong.
   size_t author_data_size = notification_data.data.size();
 
   UMA_HISTOGRAM_COUNTS_1000("Notifications.AuthorDataSize", author_data_size);
 
   if (author_data_size > PlatformNotificationData::kMaximumDeveloperDataSize) {
     owned_callbacks->onError();
     return;
   }
 
   // TODO(peter): GenerateNotificationId is more of a request id. Consider
   // renaming the method in the NotificationDispatcher if this makes sense.
   int request_id =
       notification_dispatcher_->GenerateNotificationId(CurrentWorkerId());
 
-  pending_show_notification_requests_.AddWithID(owned_callbacks.release(),
+  pending_show_notification_requests_.AddWithID(std::move(owned_callbacks),
                                                 request_id);
 
   // TODO(mkwst): This is potentially doing the wrong thing with unique
   // origins. Perhaps also 'file:', 'blob:' and 'filesystem:'. See
   // https://crbug.com/490074 for detail.
   thread_safe_sender_->Send(new PlatformNotificationHostMsg_ShowPersistent(
       request_id, service_worker_registration_id, url::Origin(origin).GetURL(),
       ToPlatformNotificationData(notification_data),
       ToNotificationResources(std::move(notification_resources))));
 }
 
 void NotificationManager::getNotifications(
     const blink::WebString& filter_tag,
     blink::WebServiceWorkerRegistration* service_worker_registration,
-    blink::WebNotificationGetCallbacks* callbacks) {
+    std::unique_ptr<blink::WebNotificationGetCallbacks> callbacks) {
   DCHECK(service_worker_registration);
   DCHECK(callbacks);
 
   WebServiceWorkerRegistrationImpl* service_worker_registration_impl =
       static_cast<WebServiceWorkerRegistrationImpl*>(
           service_worker_registration);
 
   GURL origin = GURL(service_worker_registration_impl->scope()).GetOrigin();
   int64_t service_worker_registration_id =
       service_worker_registration_impl->registrationId();
 
   // TODO(peter): GenerateNotificationId is more of a request id. Consider
   // renaming the method in the NotificationDispatcher if this makes sense.
   int request_id =
       notification_dispatcher_->GenerateNotificationId(CurrentWorkerId());
 
-  pending_get_notification_requests_.AddWithID(callbacks, request_id);
+  pending_get_notification_requests_.AddWithID(std::move(callbacks),
+                                               request_id);
 
   thread_safe_sender_->Send(new PlatformNotificationHostMsg_GetNotifications(
       request_id, service_worker_registration_id, origin,
       base::UTF16ToUTF8(base::StringPiece16(filter_tag))));
 }
 
 void NotificationManager::close(blink::WebNotificationDelegate* delegate) {
   for (auto& iter : active_page_notifications_) {
     if (iter.second.delegate != delegate)
       continue;
@@ skipping 111 matching lines @@
 
     notifications[i] = web_notification_info;
   }
 
   callbacks->onSuccess(notifications);
 
   pending_get_notification_requests_.Remove(request_id);
 }
 
 }  // namespace content