Make //content responsible for generating notification Ids

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"
@@ skipping 20 matching lines @@
       : 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;
   }
 
   // Callback to provide when writing a notification to the database.
-  void DidWriteNotificationData(bool success, int64_t notification_id) {
+  void DidWriteNotificationData(bool success,
+                                const std::string& notification_id) {
     success_ = success;
     notification_id_ = notification_id;
   }
 
   // Callback to provide when deleting notification data from the database.
   void DidDeleteNotificationData(bool success) { success_ = success; }
 
   // Callback to provide when registering a Service Worker with a Service
   // Worker Context. Will write the registration id to |store_registration_id|.
   void DidRegisterServiceWorker(int64_t* store_registration_id,
@@ skipping 52 matching lines @@
   // Returns whether the last invoked callback finished successfully.
   bool success() const { return success_; }
 
   // Returns the NotificationDatabaseData associated with the last invoked
   // ReadNotificationData callback.
   const NotificationDatabaseData& database_data() const {
     return database_data_;
   }
 
   // Returns the notification id of the notification last written.
-  int64_t notification_id() const { return notification_id_; }
+  const std::string& notification_id() const { return notification_id_; }
 
  private:
   TestBrowserThreadBundle thread_bundle_;
   TestBrowserContext browser_context_;
 
   bool success_;
   NotificationDatabaseData database_data_;
-  int64_t notification_id_;
+  std::string notification_id_;
 };
 
 TEST_F(PlatformNotificationContextTest, ReadNonExistentNotification) {
   scoped_refptr<PlatformNotificationContextImpl> context =
       CreatePlatformNotificationContext();
 
   context->ReadNotificationData(
-      42 /* notification_id */, GURL("https://example.com"),
+      "invalid-notification-id", GURL("https://example.com"),
       base::Bind(&PlatformNotificationContextTest::DidReadNotificationData,
                  base::Unretained(this)));
 
   base::RunLoop().RunUntilIdle();
 
   // The read operation should have failed, as it does not exist.
   ASSERT_FALSE(success());
 }
 
 TEST_F(PlatformNotificationContextTest, WriteReadNotification) {
   scoped_refptr<PlatformNotificationContextImpl> context =
       CreatePlatformNotificationContext();
 
   GURL origin("https://example.com");
   NotificationDatabaseData notification_database_data;
   notification_database_data.origin = origin;
 
   context->WriteNotificationData(
       origin, notification_database_data,
       base::Bind(&PlatformNotificationContextTest::DidWriteNotificationData,
                  base::Unretained(this)));
 
   base::RunLoop().RunUntilIdle();
 
   // The write operation should have succeeded with a notification id.
   ASSERT_TRUE(success());
-  EXPECT_GT(notification_id(), 0);
+  EXPECT_FALSE(notification_id().empty());
 
   context->ReadNotificationData(
       notification_id(), origin,
       base::Bind(&PlatformNotificationContextTest::DidReadNotificationData,
                  base::Unretained(this)));
 
   base::RunLoop().RunUntilIdle();
 
   // The read operation should have succeeded, with the right notification.
   ASSERT_TRUE(success());
@@ skipping 18 matching lines @@
   notification_database_data.notification_data.tag = tag;
 
   // Write the first notification with the given |tag|.
   context->WriteNotificationData(
       origin, notification_database_data,
       base::Bind(&PlatformNotificationContextTest::DidWriteNotificationData,
                  base::Unretained(this)));
 
   base::RunLoop().RunUntilIdle();
 
-  int64_t read_notification_id = notification_id();
+  std::string read_notification_id = notification_id();
 
   // The write operation should have succeeded with a notification id.
   ASSERT_TRUE(success());
-  EXPECT_GT(read_notification_id, 0);
+  EXPECT_FALSE(read_notification_id.empty());
 
   notification_database_data.notification_data.title =
       base::ASCIIToUTF16("Second");
 
   // Write the second notification with the given |tag|.
   context->WriteNotificationData(
       origin, notification_database_data,
       base::Bind(&PlatformNotificationContextTest::DidWriteNotificationData,
                  base::Unretained(this)));
 
   base::RunLoop().RunUntilIdle();
 
   ASSERT_TRUE(success());
-  ASSERT_NE(notification_id(), read_notification_id);
-  ASSERT_GT(notification_id(), 0);
+  ASSERT_FALSE(notification_id().empty());
+  ASSERT_EQ(notification_id(), read_notification_id);
 
   // Reading the notifications should only yield the second, replaced one.
   std::vector<NotificationDatabaseData> notification_database_datas;
   context->ReadAllNotificationDataForServiceWorkerRegistration(
       origin, kFakeServiceWorkerRegistrationId,
       base::Bind(&PlatformNotificationContextTest::DidReadAllNotificationDatas,
                  base::Unretained(this), &notification_database_datas));
 
   base::RunLoop().RunUntilIdle();
 
   // The read operation should have succeeded, with the right notification.
   ASSERT_TRUE(success());
 
   ASSERT_EQ(1u, notification_database_datas.size());
 
   EXPECT_EQ(tag, notification_database_datas[0].notification_data.tag);
   EXPECT_EQ(base::ASCIIToUTF16("Second"),
             notification_database_datas[0].notification_data.title);
 }
 
 TEST_F(PlatformNotificationContextTest, DeleteInvalidNotification) {
   scoped_refptr<PlatformNotificationContextImpl> context =
       CreatePlatformNotificationContext();
 
   context->DeleteNotificationData(
-      42 /* notification_id */, GURL("https://example.com"),
+      "invalid-notification-id", GURL("https://example.com"),
       base::Bind(&PlatformNotificationContextTest::DidDeleteNotificationData,
                  base::Unretained(this)));
 
   base::RunLoop().RunUntilIdle();
 
   // The notification may not have existed, but since the goal of deleting data
   // is to make sure that it's gone, the goal has been satisfied. As such,
   // deleting a non-existent notification is considered to be a success.
   EXPECT_TRUE(success());
 }
 
 TEST_F(PlatformNotificationContextTest, DeleteNotification) {
   scoped_refptr<PlatformNotificationContextImpl> context =
       CreatePlatformNotificationContext();
 
   GURL origin("https://example.com");
   NotificationDatabaseData notification_database_data;
 
   context->WriteNotificationData(
       origin, notification_database_data,
       base::Bind(&PlatformNotificationContextTest::DidWriteNotificationData,
                  base::Unretained(this)));
 
   base::RunLoop().RunUntilIdle();
 
   // The write operation should have succeeded with a notification id.
   ASSERT_TRUE(success());
-  EXPECT_GT(notification_id(), 0);
+  EXPECT_FALSE(notification_id().empty());
 
   context->DeleteNotificationData(
       notification_id(), origin,
       base::Bind(&PlatformNotificationContextTest::DidDeleteNotificationData,
                  base::Unretained(this)));
 
   base::RunLoop().RunUntilIdle();
 
   // The notification existed, so it should have been removed successfully.
   ASSERT_TRUE(success());
@@ skipping 43 matching lines @@
 
   // Create a notification for that Service Worker registration.
   notification_context->WriteNotificationData(
       origin, notification_database_data,
       base::Bind(&PlatformNotificationContextTest::DidWriteNotificationData,
                  base::Unretained(this)));
 
   base::RunLoop().RunUntilIdle();
 
   ASSERT_TRUE(success());
-  EXPECT_GT(notification_id(), 0);
+  EXPECT_FALSE(notification_id().empty());
 
   ServiceWorkerStatusCode unregister_status;
 
   // Now drop the Service Worker registration which owns that notification.
   embedded_worker_test_helper->context()->UnregisterServiceWorker(
       origin,
       base::Bind(&PlatformNotificationContextTest::DidUnregisterServiceWorker,
                  base::Unretained(this), &unregister_status));
 
   base::RunLoop().RunUntilIdle();
@@ skipping 19 matching lines @@
 
   context->WriteNotificationData(
       origin, notification_database_data,
       base::Bind(&PlatformNotificationContextTest::DidWriteNotificationData,
                  base::Unretained(this)));
 
   base::RunLoop().RunUntilIdle();
 
   // The write operation should have succeeded with a notification id.
   ASSERT_TRUE(success());
-  EXPECT_GT(notification_id(), 0);
+  EXPECT_FALSE(notification_id().empty());
 
   // Call the OnStorageWiped override from the ServiceWorkerContextObserver,
   // which indicates that the database should go away entirely.
   context->OnStorageWiped();
 
   // Verify that reading notification data fails because the data does not
   // exist anymore. Deliberately omit RunUntilIdle(), since this is unlikely to
   // be the case when OnStorageWiped gets called in production.
   context->ReadNotificationData(
       notification_id(), origin,
@@ skipping 12 matching lines @@
   // Manually construct the PlatformNotificationContextImpl because this test
   // requires the database to be created on the filesystem.
   scoped_refptr<PlatformNotificationContextImpl> context(
       new PlatformNotificationContextImpl(database_dir.path(),
                                           browser_context(), nullptr));
 
   OverrideTaskRunnerForTesting(context.get());
 
   // Trigger a read-operation to force creating the database.
   context->ReadNotificationData(
-      42 /* notification_id */, GURL("https://example.com"),
+      "invalid-notification-id", GURL("https://example.com"),
       base::Bind(&PlatformNotificationContextTest::DidReadNotificationData,
                  base::Unretained(this)));
 
   base::RunLoop().RunUntilIdle();
 
   EXPECT_FALSE(IsDirectoryEmpty(database_dir.path()));
   EXPECT_FALSE(success());
 
   // Blow away the database by faking a Service Worker Context wipe-out.
   context->OnStorageWiped();
@@ skipping 60 matching lines @@
   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