Use notification display service to collect persistent notifications.

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 42 matching lines @@
 }
 
 void PlatformNotificationContextImpl::Initialize() {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   PlatformNotificationService* service =
       GetContentClient()->browser()->GetPlatformNotificationService();
   if (service) {
     std::set<std::string> displayed_notifications;
 
     bool notification_synchronization_supported =
-        service->GetDisplayedPersistentNotifications(browser_context_,
-                                                     &displayed_notifications);
+        service->GetDisplayedNotifications(browser_context_,
+                                           &displayed_notifications);
 
     // Synchronize the notifications stored in the database with the set of
     // displaying notifications in |displayed_notifications|. This is necessary
     // because flakiness may cause a platform to inform Chrome of a notification
     // that has since been closed, or because the platform does not support
     // notifications that exceed the lifetime of the browser process.
 
     // TODO(peter): Synchronizing the actual notifications will be done when the
     // persistent notification ids are stable. For M44 we need to support the
     // case where there may be no notifications after a Chrome restart.
@@ skipping 100 matching lines @@
   // Blow away the database if reading data failed due to corruption.
   if (status == NotificationDatabase::STATUS_ERROR_CORRUPTED)
     DestroyDatabase();
 
   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,
+        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::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);
-  LazyInitialize(
-      base::Bind(&PlatformNotificationContextImpl::
-                     DoReadAllNotificationDataForServiceWorkerRegistration,
-                 this, origin, service_worker_registration_id, callback),
-      base::Bind(callback, false /* success */,
-                 std::vector<NotificationDatabaseData>()));
+
+  // notification_ids becomes owned by
+  // DoReadAllNotificationDataForServiceWorkerRegistration
+  std::set<std::string>* notification_ids = new 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 */);
+    return;
+  }
+
+  BrowserThread::PostTaskAndReplyWithResult(
+      BrowserThread::UI, FROM_HERE,
+      base::Bind(&PlatformNotificationService::GetDisplayedNotifications,
+                 base::Unretained(service), browser_context_,
+                 base::Unretained(notification_ids)),
+      base::Bind(
+          &PlatformNotificationContextImpl::
+              SynchronizeDisplayedNotificationsForServiceWorkerRegistration,
+          this, origin, service_worker_registration_id, callback,
+          base::Unretained(notification_ids)));
 }
 
 void PlatformNotificationContextImpl::
     DoReadAllNotificationDataForServiceWorkerRegistration(
         const GURL& origin,
         int64_t service_worker_registration_id,
-        const ReadAllResultCallback& callback) {
+        const ReadAllResultCallback& callback,
+        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);
 
   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)) {

[Peter Beverloo, 2016/12/13 11:41:12]

Mm. std::set<> makes this O(n log n). Could be O(n) if we'd use an
std::unordered_set<>.

Doesn't matter a huge amount anyway - in pretty much all cases |n| will be very
small.

[Miguel Garcia, 2016/12/13 16:43:10]

Yeah, and it makes the test more predictable (since they are returned in the
order they were inserted). Would prefer to leave it as is, otherwise I need to
read the notifications in the test, find one that is persistent to remove it
etc.

+          ++it;
+        } else {
+          it = notification_datas.erase(it);

[Peter Beverloo, 2016/12/13 11:41:12]

nit: drop this. Maybe DCHECK on
NotificationIdGenerator::IsPersistentNotification(). The database is *only* used
for persistent notifications.

[Miguel Garcia, 2016/12/13 16:43:10]

Done.

+        }
+      }
+    }
+
     BrowserThread::PostTask(
         BrowserThread::IO, FROM_HERE,
         base::Bind(callback, true /* success */, notification_datas));
     return;
   }
 
   // Blow away the database if reading data failed due to corruption.
   if (status == NotificationDatabase::STATUS_ERROR_CORRUPTED)
     DestroyDatabase();
 
@@ skipping 252 matching lines @@
 
   return path_.Append(kPlatformNotificationsDirectory);
 }
 
 void PlatformNotificationContextImpl::SetTaskRunnerForTesting(
     const scoped_refptr<base::SequencedTaskRunner>& task_runner) {
   task_runner_ = task_runner;
 }
 
 }  // namespace content