Implement the ability to get all notifications in Chromium.

content/browser/notifications/platform_notification_context_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 "base/bind.h"
 #include "base/files/file_util.h"
 #include "base/files/scoped_temp_dir.h"
 #include "base/run_loop.h"
 #include "content/browser/notifications/platform_notification_context_impl.h"
 #include "content/browser/service_worker/embedded_worker_test_helper.h"
 #include "content/browser/service_worker/service_worker_context_wrapper.h"
 #include "content/common/service_worker/service_worker_types.h"
 #include "content/public/browser/notification_database_data.h"
 #include "content/public/test/test_browser_thread_bundle.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "url/gurl.h"
 
 namespace content {
 
 // Fake render process id to use in tests requiring one.
 const int kFakeRenderProcessId = 99;
 
+// Fake Service Worker registration id to use in tests requiring one.
+const int64_t kFakeServiceWorkerRegistrationId = 42;
+
 class PlatformNotificationContextTest : public ::testing::Test {
  public:
   PlatformNotificationContextTest()
       : thread_bundle_(TestBrowserThreadBundle::IO_MAINLOOP),
         success_(false) {}
 
   // Callback to provide when reading a single notification from the database.
   void DidReadNotificationData(
       bool success, const NotificationDatabaseData& database_data) {
     success_ = success;
@@ skipping 24 matching lines @@
   }
 
   // Callback to provide when unregistering a Service Worker. Will write the
   // resulting status code to |store_status|.
   void DidUnregisterServiceWorker(ServiceWorkerStatusCode* store_status,
                                   ServiceWorkerStatusCode status) {
     DCHECK(store_status);
     *store_status = status;
   }
 
+  // Callback to provide when reading multiple notifications from the database.
+  // Will store the success value in the class member, and write the read
+  // notification datas to |store_notification_datas|.
+  void DidReadAllNotificationDatas(
+      std::vector<NotificationDatabaseData>* store_notification_datas,
+      bool success,
+      const std::vector<NotificationDatabaseData>& notification_datas) {
+    DCHECK(store_notification_datas);
+
+    success_ = success;
+    *store_notification_datas = notification_datas;
+  }
+
  protected:
   // Creates a new PlatformNotificationContextImpl instance. When using this
   // method, the underlying database will always be created in memory. The
   // current message loop proxy will be used as the task runner.
   PlatformNotificationContextImpl* CreatePlatformNotificationContext() {
     PlatformNotificationContextImpl* context =
         new PlatformNotificationContextImpl(base::FilePath(), nullptr);
     context->Initialize();
 
     OverrideTaskRunnerForTesting(context);
@@ skipping 268 matching lines @@
 
   // Blow away the database by faking a Service Worker Context wipe-out.
   context->OnStorageWiped();
 
   base::RunLoop().RunUntilIdle();
 
   // The database's directory should be empty at this point.
   EXPECT_TRUE(IsDirectoryEmpty(database_dir.path()));
 }
 
+TEST_F(PlatformNotificationContextTest, ReadAllServiceWorkerDataEmpty) {
+  scoped_refptr<PlatformNotificationContextImpl> context =
+      CreatePlatformNotificationContext();
+
+  GURL origin("https://example.com");
+
+  std::vector<NotificationDatabaseData> notification_database_datas;
+  context->ReadAllNotificationDataForServiceWorkerRegistration(
+      origin,
+      kFakeServiceWorkerRegistrationId,
+      base::Bind(&PlatformNotificationContextTest::DidReadAllNotificationDatas,
+                 base::Unretained(this),
+                 &notification_database_datas));
+
+  base::RunLoop().RunUntilIdle();
+
+  EXPECT_TRUE(success());
+  EXPECT_EQ(0u, notification_database_datas.size());
+}
+
+TEST_F(PlatformNotificationContextTest, ReadAllServiceWorkerDataFilled) {
+  scoped_refptr<PlatformNotificationContextImpl> context =
+      CreatePlatformNotificationContext();
+
+  GURL origin("https://example.com");
+
+  NotificationDatabaseData notification_database_data;
+  notification_database_data.origin = origin;
+  notification_database_data.service_worker_registration_id =
+      kFakeServiceWorkerRegistrationId;
+
+  // Insert ten notifications into the database belonging to origin and the
+  // test Service Worker Registration id.
+  for (int i = 0; i < 10; ++i) {
+    context->WriteNotificationData(
+        origin,
+        notification_database_data,
+        base::Bind(&PlatformNotificationContextTest::DidWriteNotificationData,
+                   base::Unretained(this)));
+
+    base::RunLoop().RunUntilIdle();
+
+    ASSERT_TRUE(success());
+  }
+
+  // Now read the notifications from the database again. There should be ten,
+  // all set with the correct origin and Service Worker Registration id.
+  std::vector<NotificationDatabaseData> notification_database_datas;
+  context->ReadAllNotificationDataForServiceWorkerRegistration(
+      origin,
+      kFakeServiceWorkerRegistrationId,
+      base::Bind(&PlatformNotificationContextTest::DidReadAllNotificationDatas,
+                 base::Unretained(this),
+                 &notification_database_datas));
+
+  base::RunLoop().RunUntilIdle();
+
+  ASSERT_TRUE(success());
+  ASSERT_EQ(10u, notification_database_datas.size());
+
+  for (int i = 0; i < 10; ++i) {
+    EXPECT_EQ(origin, notification_database_datas[i].origin);
+    EXPECT_EQ(kFakeServiceWorkerRegistrationId,
+              notification_database_datas[i].service_worker_registration_id);
+  }
+}
+
 }  // namespace content