Make //content responsible for generating notification Ids

content/browser/notifications/notification_database.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 <string>
 
 #include "base/files/file_util.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/stringprintf.h"
 #include "content/browser/notifications/notification_database_data_conversions.h"
 #include "content/common/service_worker/service_worker_types.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/notification_database_data.h"
 #include "storage/common/database/database_identifier.h"
 #include "third_party/leveldatabase/env_chromium.h"
 #include "third_party/leveldatabase/src/helpers/memenv/memenv.h"
 #include "third_party/leveldatabase/src/include/leveldb/db.h"
 #include "third_party/leveldatabase/src/include/leveldb/env.h"
 #include "third_party/leveldatabase/src/include/leveldb/filter_policy.h"
 #include "third_party/leveldatabase/src/include/leveldb/write_batch.h"
 #include "url/gurl.h"
 
 // Notification LevelDB database schema (in alphabetized order)
 // =======================
 //
 // key: "DATA:" <origin identifier> '\x00' <notification_id>

[johnme, 2016/09/02 15:07:44]

persistent_notification_id

[Peter Beverloo, 2016/09/05 15:11:01]

Done.

 // value: String containing the NotificationDatabaseDataProto protocol buffer
 //        in serialized form.
 //
+// key: "ASSOC:" <notification id>
+// value: String containing the associated persistent notification id as an
+//        int64_t in textual representation.
+//
 // key: "NEXT_NOTIFICATION_ID"
 // value: Decimal string which fits into an int64_t.
 
 namespace content {
 namespace {
 
 // Keys of the fields defined in the database.
 const char kNextNotificationIdKey[] = "NEXT_NOTIFICATION_ID";
 const char kDataKeyPrefix[] = "DATA:";
+const char kAssociatedKeyPrefix[] = "ASSOC:";
 
 // Separates the components of compound keys.
 const char kKeySeparator = '\x00';
 
 // The first notification id which to be handed out by the database.
 const int64_t kFirstNotificationId = 1;
 
 // Converts the LevelDB |status| to one of the notification database's values.
 NotificationDatabase::Status LevelDBStatusToStatus(
     const leveldb::Status& status) {
@@ skipping 17 matching lines @@
 std::string CreateDataPrefix(const GURL& origin) {
   if (!origin.is_valid())
     return kDataKeyPrefix;
 
   return base::StringPrintf("%s%s%c", kDataKeyPrefix,
                             storage::GetIdentifierFromOrigin(origin).c_str(),
                             kKeySeparator);
 }
 
 // Creates the compound data key in which notification data is stored.
-std::string CreateDataKey(const GURL& origin, int64_t notification_id) {
+std::string CreateDataKey(const GURL& origin,
+                          int64_t persistent_notification_id) {
   DCHECK(origin.is_valid());
-  return CreateDataPrefix(origin) + base::Int64ToString(notification_id);
+  return CreateDataPrefix(origin) +
+         base::Int64ToString(persistent_notification_id);
+}
+
+// Creates the compound key for mapping the given |notification_id| to the
+// latest persistent notification id in the database.
+std::string CreateAssociatedKey(const std::string& notification_id) {
+  return base::StringPrintf("%s%s", kAssociatedKeyPrefix,
+                            notification_id.c_str());
 }
 
 // Deserializes data in |serialized_data| to |notification_database_data|.
 // Will return if the deserialization was successful.
 NotificationDatabase::Status DeserializedNotificationData(
     const std::string& serialized_data,
     NotificationDatabaseData* notification_database_data) {
   DCHECK(notification_database_data);
   if (DeserializeNotificationDatabaseData(serialized_data,
                                           notification_database_data)) {
@@ skipping 43 matching lines @@
   if (status != STATUS_OK)
     return status;
 
   state_ = STATE_INITIALIZED;
   db_.reset(db);
 
   return ReadNextNotificationId();
 }
 
 NotificationDatabase::Status NotificationDatabase::ReadNotificationData(
-    int64_t notification_id,
+    int64_t persistent_notification_id,
     const GURL& origin,
     NotificationDatabaseData* notification_database_data) const {
   DCHECK(sequence_checker_.CalledOnValidSequence());
   DCHECK_EQ(STATE_INITIALIZED, state_);
-  DCHECK_GE(notification_id, kFirstNotificationId);
+  DCHECK_GE(persistent_notification_id, kFirstNotificationId);
   DCHECK(origin.is_valid());
   DCHECK(notification_database_data);
 
-  std::string key = CreateDataKey(origin, notification_id);
+  std::string key = CreateDataKey(origin, persistent_notification_id);
   std::string serialized_data;
 
   Status status = LevelDBStatusToStatus(
       db_->Get(leveldb::ReadOptions(), key, &serialized_data));
   if (status != STATUS_OK)
     return status;
 
   return DeserializedNotificationData(serialized_data,
                                       notification_database_data);
 }
@@ skipping 18 matching lines @@
     const GURL& origin,
     int64_t service_worker_registration_id,
     std::vector<NotificationDatabaseData>* notification_data_vector) const {
   return ReadAllNotificationDataInternal(origin, service_worker_registration_id,
                                          notification_data_vector);
 }
 
 NotificationDatabase::Status NotificationDatabase::WriteNotificationData(
     const GURL& origin,
     const NotificationDatabaseData& notification_database_data,
-    int64_t* notification_id) {
+    int64_t* persistent_notification_id) {
   DCHECK(sequence_checker_.CalledOnValidSequence());
   DCHECK_EQ(STATE_INITIALIZED, state_);
-  DCHECK(notification_id);
+  DCHECK(persistent_notification_id);
   DCHECK(origin.is_valid());
 
   DCHECK_GE(next_notification_id_, kFirstNotificationId);
 
   NotificationDatabaseData storage_data = notification_database_data;
   storage_data.notification_id = next_notification_id_;

[johnme, 2016/09/02 15:07:44]

Please also rename notification_id in
content/browser/notifications/notification_database_data.proto to
persistent_notification_id

[Peter Beverloo, 2016/09/05 15:11:01]

Done, also in the NotificationDatabaseData class, and the next_notification_id_
member here.

 
   std::string serialized_data;
   if (!SerializeNotificationDatabaseData(storage_data, &serialized_data)) {
     DLOG(ERROR) << "Unable to serialize data for a notification belonging "
                 << "to: " << origin;
     return STATUS_ERROR_FAILED;
   }
 
   leveldb::WriteBatch batch;
   batch.Put(CreateDataKey(origin, next_notification_id_), serialized_data);
   batch.Put(kNextNotificationIdKey,
             base::Int64ToString(next_notification_id_ + 1));
 
   Status status =
       LevelDBStatusToStatus(db_->Write(leveldb::WriteOptions(), &batch));
   if (status != STATUS_OK)
     return status;
 
-  *notification_id = next_notification_id_++;
+  *persistent_notification_id = next_notification_id_++;
   return STATUS_OK;
 }
 
 NotificationDatabase::Status NotificationDatabase::DeleteNotificationData(
-    int64_t notification_id,
+    int64_t persistent_notification_id,
     const GURL& origin) {
   DCHECK(sequence_checker_.CalledOnValidSequence());
   DCHECK_EQ(STATE_INITIALIZED, state_);
-  DCHECK_GE(notification_id, kFirstNotificationId);
+  DCHECK_GE(persistent_notification_id, kFirstNotificationId);
   DCHECK(origin.is_valid());
 
-  std::string key = CreateDataKey(origin, notification_id);
+  std::string key = CreateDataKey(origin, persistent_notification_id);
   return LevelDBStatusToStatus(db_->Delete(leveldb::WriteOptions(), key));
 }
 
 NotificationDatabase::Status
 NotificationDatabase::DeleteAllNotificationDataForOrigin(
     const GURL& origin,
     const std::string& tag,
     std::set<int64_t>* deleted_notification_set) {
   return DeleteAllNotificationDataInternal(origin, tag,
                                            kInvalidServiceWorkerRegistrationId,
                                            deleted_notification_set);
 }
 
 NotificationDatabase::Status
 NotificationDatabase::DeleteAllNotificationDataForServiceWorkerRegistration(
     const GURL& origin,
     int64_t service_worker_registration_id,
     std::set<int64_t>* deleted_notification_set) {
   return DeleteAllNotificationDataInternal(origin, "" /* tag */,
                                            service_worker_registration_id,
                                            deleted_notification_set);
 }
 
+NotificationDatabase::Status NotificationDatabase::StoreIdAssociation(
+    const std::string& notification_id,
+    int64_t persistent_notification_id) {
+  DCHECK(sequence_checker_.CalledOnValidSequence());
+
+  std::string key = CreateAssociatedKey(notification_id);
+  std::string serialized_persistent_notification_id =
+      base::Int64ToString(persistent_notification_id);
+
+  Status status = LevelDBStatusToStatus(db_->Put(
+      leveldb::WriteOptions(), key, serialized_persistent_notification_id));
+
+  return status;
+}
+
+NotificationDatabase::Status NotificationDatabase::ReadIdAssociation(
+    const std::string& notification_id,
+    int64_t* persistent_notification_id) {
+  DCHECK(sequence_checker_.CalledOnValidSequence());
+
+  std::string key = CreateAssociatedKey(notification_id);
+  std::string serialized_persistent_notification_id;
+
+  Status status = LevelDBStatusToStatus(db_->Get(
+      leveldb::ReadOptions(), key, &serialized_persistent_notification_id));
+
+  if (status != STATUS_OK)
+    return status;
+
+  if (!base::StringToInt64(serialized_persistent_notification_id,
+                           persistent_notification_id)) {
+    return STATUS_ERROR_CORRUPTED;
+  }
+
+  return status;
+}
+
+NotificationDatabase::Status NotificationDatabase::DeleteIdAssociation(
+    const std::string& notification_id) {
+  DCHECK(sequence_checker_.CalledOnValidSequence());
+
+  std::string key = CreateAssociatedKey(notification_id);
+
+  return LevelDBStatusToStatus(db_->Delete(leveldb::WriteOptions(), key));
+}
+
 NotificationDatabase::Status NotificationDatabase::Destroy() {
   DCHECK(sequence_checker_.CalledOnValidSequence());
 
   leveldb::Options options;
   if (IsInMemoryDatabase()) {
     if (!env_)
       return STATUS_OK;  // The database has not been initialized.
 
     options.env = env_.get();
   }
@@ skipping 102 matching lines @@
               kInvalidServiceWorkerRegistrationId &&
           notification_database_data.service_worker_registration_id !=
               service_worker_registration_id) {
         continue;
       }
     }
 
     leveldb::Slice notification_id_slice = iter->key();
     notification_id_slice.remove_prefix(prefix_slice.size());
 
-    int64_t notification_id = 0;
+    int64_t persistent_notification_id = 0;
     if (!base::StringToInt64(notification_id_slice.ToString(),
-                             &notification_id)) {
+                             &persistent_notification_id)) {
       return STATUS_ERROR_CORRUPTED;
     }
 
-    deleted_notification_set->insert(notification_id);
+    deleted_notification_set->insert(persistent_notification_id);
     batch.Delete(iter->key());
   }
 
   if (deleted_notification_set->empty())
     return STATUS_OK;
 
   return LevelDBStatusToStatus(db_->Write(leveldb::WriteOptions(), &batch));
 }
 
 }  // namespace content