[NOT FOR COMMIT] Ownership clean-up for 2534443002

content/browser/notifications/platform_notification_context_impl.cc

 // Copyright 2015 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/notifications/platform_notification_context_impl.h"
 
 #include "base/bind_helpers.h"
 #include "base/files/file_util.h"
 #include "base/memory/ptr_util.h"
 #include "base/metrics/histogram_macros.h"
@@ skipping 168 matching lines @@
   BrowserThread::PostTask(
       BrowserThread::IO, FROM_HERE,
       base::Bind(callback, false /* success */, NotificationDatabaseData()));
 }
 
 void PlatformNotificationContextImpl::
     SynchronizeDisplayedNotificationsForServiceWorkerRegistration(
         const GURL& origin,
         int64_t service_worker_registration_id,
         const ReadAllResultCallback& callback,
-        std::set<std::string>* notification_ids,
+        std::unique_ptr<std::set<std::string>> notification_ids,
         bool sync_supported) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   LazyInitialize(
       base::Bind(&PlatformNotificationContextImpl::
                      DoReadAllNotificationDataForServiceWorkerRegistration,
                  this, origin, service_worker_registration_id, callback,
-                 base::Unretained(notification_ids), sync_supported),
+                 base::Passed(&notification_ids), sync_supported),
       base::Bind(callback, false /* success */,
                  std::vector<NotificationDatabaseData>()));
 }
 
 void PlatformNotificationContextImpl::
     ReadAllNotificationDataForServiceWorkerRegistration(
         const GURL& origin,
         int64_t service_worker_registration_id,
         const ReadAllResultCallback& callback) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
-  // notification_ids becomes owned by
-  // DoReadAllNotificationDataForServiceWorkerRegistration
-  std::set<std::string>* notification_ids = new std::set<std::string>();
+  std::unique_ptr<std::set<std::string>> notification_ids =
+      base::MakeUnique<std::set<std::string>>();
+
   PlatformNotificationService* service =
       GetContentClient()->browser()->GetPlatformNotificationService();
 
   if (!service) {
     // Rely on the database only
     SynchronizeDisplayedNotificationsForServiceWorkerRegistration(
-        origin, service_worker_registration_id, callback, notification_ids,
-        false /* sync_supported */);
+        origin, service_worker_registration_id, callback,
+        std::move(notification_ids), false /* sync_supported */);
     return;
   }
 
+  std::set<std::string>* notification_ids_ptr = notification_ids.get();
+
   BrowserThread::PostTaskAndReplyWithResult(
       BrowserThread::UI, FROM_HERE,
       base::Bind(&PlatformNotificationService::GetDisplayedNotifications,
                  base::Unretained(service), browser_context_,
-                 base::Unretained(notification_ids)),
+                 notification_ids_ptr),
       base::Bind(
           &PlatformNotificationContextImpl::
               SynchronizeDisplayedNotificationsForServiceWorkerRegistration,
           this, origin, service_worker_registration_id, callback,
-          base::Unretained(notification_ids)));
+          base::Passed(&notification_ids)));
 }
 
 void PlatformNotificationContextImpl::
     DoReadAllNotificationDataForServiceWorkerRegistration(
         const GURL& origin,
         int64_t service_worker_registration_id,
         const ReadAllResultCallback& callback,
-        std::set<std::string>* displayed_notifications,
+        std::unique_ptr<std::set<std::string>> displayed_notifications,
         bool synchronization_supported) {
   DCHECK(task_runner_->RunsTasksOnCurrentThread());
-  std::unique_ptr<std::set<std::string>> displayed_ids =
-      base::WrapUnique(displayed_notifications);
+  DCHECK(displayed_notifications);
 
   std::vector<NotificationDatabaseData> notification_datas;
 
   NotificationDatabase::Status status =
       database_->ReadAllNotificationDataForServiceWorkerRegistration(
           origin, service_worker_registration_id, &notification_datas);
 
   UMA_HISTOGRAM_ENUMERATION("Notifications.Database.ReadForServiceWorkerResult",
                             status, NotificationDatabase::STATUS_COUNT);
 
   if (status == NotificationDatabase::STATUS_OK) {
     if (synchronization_supported) {
-      DCHECK(displayed_ids);
       // Filter out notifications that are not actually on display anymore.
       // TODO(miguelg) synchronize the database if there are inconsistencies.
       for (auto it = notification_datas.begin();
            it != notification_datas.end();) {
         if (NotificationIdGenerator::IsPersistentNotification(
                 it->notification_id) &&
-            displayed_ids->count(it->notification_id)) {
+            displayed_notifications->count(it->notification_id)) {
           ++it;
         } else {
           it = notification_datas.erase(it);
         }
       }
     }
 
     BrowserThread::PostTask(
         BrowserThread::IO, FROM_HERE,
         base::Bind(callback, true /* success */, notification_datas));
@@ skipping 259 matching lines @@
 
   return path_.Append(kPlatformNotificationsDirectory);
 }
 
 void PlatformNotificationContextImpl::SetTaskRunnerForTesting(
     const scoped_refptr<base::SequencedTaskRunner>& task_runner) {
   task_runner_ = task_runner;
 }
 
 }  // namespace content