Test the platform notification context synchronize operation

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 <stdint.h>
 
 #include "base/bind.h"
 #include "base/files/file_util.h"
 #include "base/files/scoped_temp_dir.h"
 #include "base/run_loop.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/threading/thread_task_runner_handle.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/common/notification_resources.h"
 #include "content/public/test/test_browser_context.h"
 #include "content/public/test/test_browser_thread_bundle.h"
+#include "content/test/mock_platform_notification_service.h"
+#include "content/test/test_content_browser_client.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "url/gurl.h"
 
 namespace content {
 
 // Fake Service Worker registration id to use in tests requiring one.
 const int64_t kFakeServiceWorkerRegistrationId = 42;
 
+class NotificationBrowserClient : public TestContentBrowserClient {
+ public:
+  NotificationBrowserClient()
+      : platform_notification_service_(new MockPlatformNotificationService()) {}
+
+  PlatformNotificationService* GetPlatformNotificationService() override {
+    return platform_notification_service_.get();
+  }
+
+ private:
+  std::unique_ptr<PlatformNotificationService> platform_notification_service_;
+};
+
 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;
     database_data_ = database_data;
@@ skipping 439 matching lines @@
   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);
   }
 }
 
+TEST_F(PlatformNotificationContextTest, SynchronizeNotifications) {
+  NotificationBrowserClient notification_browser_client;
+  SetBrowserClientForTesting(&notification_browser_client);
+
+  scoped_refptr<PlatformNotificationContextImpl> context =
+      CreatePlatformNotificationContext();
+
+  GURL origin("https://example.com");
+  NotificationDatabaseData notification_database_data;
+  notification_database_data.service_worker_registration_id =
+      kFakeServiceWorkerRegistrationId;
+  PlatformNotificationData notification_data;
+  content::NotificationResources notification_resources;
+  notification_resources.action_icons.resize(notification_data.actions.size());

[Peter Beverloo, 2017/02/08 14:05:11]

Why is this line necessary? Neither |notification_data| nor
|notification_resources| have actions at this point - this should be a no-op?

[Miguel Garcia, 2017/02/08 17:03:41]

it's not needed.

+
+  context->WriteNotificationData(
+      origin, notification_database_data,
+      base::Bind(&PlatformNotificationContextTest::DidWriteNotificationData,
+                 base::Unretained(this)));
+
+  base::RunLoop().RunUntilIdle();
+  ASSERT_TRUE(success());
+  EXPECT_FALSE(notification_id().empty());
+
+  PlatformNotificationService* service =
+      notification_browser_client.GetPlatformNotificationService();
+
+  service->DisplayPersistentNotification(browser_context(), notification_id(),
+                                         origin, origin, notification_data,
+                                         notification_resources);
+
+  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(1u, notification_database_datas.size());
+
+  // Delete the notification from the display service without removing it from
+  // the database. It should automatically synchronize on the next read.
+  service->ClosePersistentNotification(browser_context(), notification_id());
+  context->ReadAllNotificationDataForServiceWorkerRegistration(
+      origin, kFakeServiceWorkerRegistrationId,
+      base::Bind(&PlatformNotificationContextTest::DidReadAllNotificationDatas,
+                 base::Unretained(this), &notification_database_datas));
+  base::RunLoop().RunUntilIdle();
+
+  ASSERT_TRUE(success());
+  ASSERT_EQ(0u, notification_database_datas.size());
+
+  context->ReadNotificationData(
+      notification_id(), origin,
+      base::Bind(&PlatformNotificationContextTest::DidReadNotificationData,
+                 base::Unretained(this)));
+
+  base::RunLoop().RunUntilIdle();
+
+  // The notification was removed, so we shouldn't be able to read it from
+  // the database anymore.
+  EXPECT_FALSE(success());
+}
+
 }  // namespace content