Eagerly delete replaced notifications from the database

content/browser/notifications/notification_database_unittest.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/notification_database.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include "base/files/scoped_temp_dir.h"
 #include "base/macros.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/utf_string_conversions.h"
 #include "content/public/browser/notification_database_data.h"
 #include "content/public/common/platform_notification_data.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "third_party/leveldatabase/src/include/leveldb/db.h"
 #include "third_party/leveldatabase/src/include/leveldb/write_batch.h"
 #include "url/gurl.h"
 
 namespace content {
 
 const int kExampleServiceWorkerRegistrationId = 42;
 
 const struct {
   const char* origin;
+  const char* tag;
   int64_t service_worker_registration_id;
 } kExampleNotificationData[] = {
-    {"https://example.com", 0},
-    {"https://example.com", kExampleServiceWorkerRegistrationId},
-    {"https://example.com", kExampleServiceWorkerRegistrationId},
-    {"https://example.com", kExampleServiceWorkerRegistrationId + 1},
-    {"https://chrome.com", 0},
-    {"https://chrome.com", 0},
-    {"https://chrome.com", kExampleServiceWorkerRegistrationId}};
+    {"https://example.com", "" /* tag */, 0},
+    {"https://example.com", "" /* tag */, kExampleServiceWorkerRegistrationId},
+    {"https://example.com", "" /* tag */, kExampleServiceWorkerRegistrationId},
+    {"https://example.com", "" /* tag */,
+     kExampleServiceWorkerRegistrationId + 1},
+    {"https://chrome.com", "" /* tag */, 0},
+    {"https://chrome.com", "" /* tag */, 0},
+    {"https://chrome.com", "" /* tag */, kExampleServiceWorkerRegistrationId},
+    {"https://chrome.com", "foo" /* tag */, 0}};
 
 class NotificationDatabaseTest : public ::testing::Test {
  protected:
   // Creates a new NotificationDatabase instance in memory.
   NotificationDatabase* CreateDatabaseInMemory() {
     return new NotificationDatabase(base::FilePath());
   }
 
   // Creates a new NotificationDatabase instance in |path|.
   NotificationDatabase* CreateDatabaseOnFileSystem(const base::FilePath& path) {
     return new NotificationDatabase(path);
   }
 
   // Creates a new notification for |service_worker_registration_id| belonging
   // to |origin| and writes it to the database. The written notification id
   // will be stored in |notification_id|.
   void CreateAndWriteNotification(NotificationDatabase* database,
                                   const GURL& origin,
+                                  const std::string& tag,
                                   int64_t service_worker_registration_id,
                                   int64_t* notification_id) {
     NotificationDatabaseData database_data;
     database_data.origin = origin;
     database_data.service_worker_registration_id =
         service_worker_registration_id;
+    database_data.notification_data.tag = tag;
 
     ASSERT_EQ(NotificationDatabase::STATUS_OK,
               database->WriteNotificationData(origin, database_data,
                                               notification_id));
   }
 
   // Populates |database| with a series of example notifications that differ in
   // their origin and Service Worker registration id.
   void PopulateDatabaseWithExampleData(NotificationDatabase* database) {
     int64_t notification_id;
     for (size_t i = 0; i < arraysize(kExampleNotificationData); ++i) {
       ASSERT_NO_FATAL_FAILURE(CreateAndWriteNotification(
           database, GURL(kExampleNotificationData[i].origin),
+          kExampleNotificationData[i].tag,
           kExampleNotificationData[i].service_worker_registration_id,
           &notification_id));
     }
   }
 
   // Returns if |database| has been opened.
   bool IsDatabaseOpen(NotificationDatabase* database) {
     return database->IsOpen();
   }
 
@@ skipping 90 matching lines @@
 
   ASSERT_EQ(NotificationDatabase::STATUS_OK,
             database->Open(true /* create_if_missing */));
 
   GURL origin("https://example.com");
 
   int64_t notification_id = 0;
 
   // Verify that getting two ids on the same database instance results in
   // incrementing values. Notification ids will start at 1.
-  ASSERT_NO_FATAL_FAILURE(CreateAndWriteNotification(
-      database.get(), origin, 0 /* sw_registration_id */, &notification_id));
+  ASSERT_NO_FATAL_FAILURE(
+      CreateAndWriteNotification(database.get(), origin, "" /* tag */,
+                                 0 /* sw_registration_id */, &notification_id));
   EXPECT_EQ(notification_id, 1);
 
-  ASSERT_NO_FATAL_FAILURE(CreateAndWriteNotification(
-      database.get(), origin, 0 /* sw_registration_id */, &notification_id));
+  ASSERT_NO_FATAL_FAILURE(
+      CreateAndWriteNotification(database.get(), origin, "" /* tag */,
+                                 0 /* sw_registration_id */, &notification_id));
   EXPECT_EQ(notification_id, 2);
 
   database.reset(CreateDatabaseOnFileSystem(database_dir.path()));
   ASSERT_EQ(NotificationDatabase::STATUS_OK,
             database->Open(false /* create_if_missing */));
 
   // Verify that the next notification id was stored in the database, and
   // continues where we expect it to be, even after closing and opening it.
-  ASSERT_NO_FATAL_FAILURE(CreateAndWriteNotification(
-      database.get(), origin, 0 /* sw_registration_id */, &notification_id));
+  ASSERT_NO_FATAL_FAILURE(
+      CreateAndWriteNotification(database.get(), origin, "" /* tag */,
+                                 0 /* sw_registration_id */, &notification_id));
   EXPECT_EQ(notification_id, 3);
 }
 
 TEST_F(NotificationDatabaseTest, NotificationIdIncrementsStorage) {
   std::unique_ptr<NotificationDatabase> database(CreateDatabaseInMemory());
   ASSERT_EQ(NotificationDatabase::STATUS_OK,
             database->Open(true /* create_if_missing */));
 
   GURL origin("https://example.com");
 
@@ skipping 151 matching lines @@
   ASSERT_EQ(NotificationDatabase::STATUS_OK,
             database->Open(true /* create_if_missing */));
 
   GURL origin("https://example.com");
   int64_t notification_id = 0;
 
   // Write ten notifications to the database, each with a unique title and
   // notification id (it is the responsibility of the user to increment this).
   for (int i = 1; i <= 10; ++i) {
     ASSERT_NO_FATAL_FAILURE(CreateAndWriteNotification(
-        database.get(), origin, i /* sw_registration_id */, &notification_id));
+        database.get(), origin, "" /* tag */, i /* sw_registration_id */,
+        &notification_id));
     EXPECT_EQ(notification_id, i);
   }
 
   NotificationDatabaseData database_data;
 
   // Read the ten notifications from the database, and verify that the titles
   // of each of them matches with how they were created.
   for (int i = 1; i <= 10; ++i) {
     ASSERT_EQ(NotificationDatabase::STATUS_OK,
               database->ReadNotificationData(i /* notification_id */, origin,
@@ skipping 133 matching lines @@
   ASSERT_EQ(NotificationDatabase::STATUS_OK,
             database->Open(true /* create_if_missing */));
 
   ASSERT_NO_FATAL_FAILURE(PopulateDatabaseWithExampleData(database.get()));
 
   GURL origin("https://example.com:443");
 
   std::set<int64_t> deleted_notification_set;
   ASSERT_EQ(NotificationDatabase::STATUS_OK,
             database->DeleteAllNotificationDataForOrigin(
-                origin, &deleted_notification_set));
+                origin, "" /* tag */, &deleted_notification_set));
 
   EXPECT_EQ(4u, deleted_notification_set.size());
 
   std::vector<NotificationDatabaseData> notifications;
   ASSERT_EQ(NotificationDatabase::STATUS_OK,
             database->ReadAllNotificationDataForOrigin(origin, &notifications));
 
   EXPECT_EQ(0u, notifications.size());
 }
 
+TEST_F(NotificationDatabaseTest, DeleteAllNotificationDataForOriginWithTag) {
+  std::unique_ptr<NotificationDatabase> database(CreateDatabaseInMemory());
+  ASSERT_EQ(NotificationDatabase::STATUS_OK,
+            database->Open(true /* create_if_missing */));
+
+  ASSERT_NO_FATAL_FAILURE(PopulateDatabaseWithExampleData(database.get()));
+
+  GURL origin("https://chrome.com");
+
+  std::vector<NotificationDatabaseData> notifications;
+  ASSERT_EQ(NotificationDatabase::STATUS_OK,
+            database->ReadAllNotificationDataForOrigin(origin, &notifications));
+
+  const std::string& tag = "foo";
+
+  size_t notifications_with_tag = 0;
+  size_t notifications_without_tag = 0;
+
+  for (const auto& database_data : notifications) {
+    if (database_data.notification_data.tag == tag)
+      ++notifications_with_tag;
+    else
+      ++notifications_without_tag;
+  }
+
+  ASSERT_GT(notifications_with_tag, 0u);
+  ASSERT_GT(notifications_without_tag, 0u);
+
+  std::set<int64_t> deleted_notification_set;
+  ASSERT_EQ(NotificationDatabase::STATUS_OK,
+            database->DeleteAllNotificationDataForOrigin(
+                origin, "foo" /* tag */, &deleted_notification_set));
+
+  EXPECT_EQ(notifications_with_tag, deleted_notification_set.size());
+
+  std::vector<NotificationDatabaseData> updated_notifications;
+  ASSERT_EQ(NotificationDatabase::STATUS_OK,
+            database->ReadAllNotificationDataForOrigin(origin,
+                                                       &updated_notifications));
+
+  EXPECT_EQ(notifications_without_tag, updated_notifications.size());
+
+  size_t updated_notifications_with_tag = 0;
+  size_t updated_notifications_without_tag = 0;
+
+  for (const auto& database_data : updated_notifications) {
+    if (database_data.notification_data.tag == tag)
+      ++updated_notifications_with_tag;
+    else
+      ++updated_notifications_without_tag;
+  }
+
+  EXPECT_EQ(0u, updated_notifications_with_tag);
+  EXPECT_EQ(notifications_without_tag, updated_notifications_without_tag);
+}
+
 TEST_F(NotificationDatabaseTest, DeleteAllNotificationDataForOriginEmpty) {
   std::unique_ptr<NotificationDatabase> database(CreateDatabaseInMemory());
   ASSERT_EQ(NotificationDatabase::STATUS_OK,
             database->Open(true /* create_if_missing */));
 
   GURL origin("https://example.com");
 
   std::set<int64_t> deleted_notification_set;
   ASSERT_EQ(NotificationDatabase::STATUS_OK,
             database->DeleteAllNotificationDataForOrigin(
-                origin, &deleted_notification_set));
+                origin, "" /* tag */, &deleted_notification_set));
 
   EXPECT_EQ(0u, deleted_notification_set.size());
 }
 
 TEST_F(NotificationDatabaseTest,
        DeleteAllNotificationDataForServiceWorkerRegistration) {
   std::unique_ptr<NotificationDatabase> database(CreateDatabaseInMemory());
   ASSERT_EQ(NotificationDatabase::STATUS_OK,
             database->Open(true /* create_if_missing */));
 
@@ skipping 10 matching lines @@
 
   std::vector<NotificationDatabaseData> notifications;
   ASSERT_EQ(NotificationDatabase::STATUS_OK,
             database->ReadAllNotificationDataForServiceWorkerRegistration(
                 origin, kExampleServiceWorkerRegistrationId, &notifications));
 
   EXPECT_EQ(0u, notifications.size());
 }
 
 }  // namespace content