Store the actual notification data in the notification database.

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.h"
 #include "content/public/browser/browser_thread.h"
+#include "storage/common/database/database_identifier.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/write_batch.h"
+#include "url/gurl.h"
 
 // Notification LevelDB database schema (in alphabetized order)
 // =======================
 //
+// key: "DATA:" <origin identifier> '\x00' <notification_id>
+// value: String containing the NotificationDatabaseDataProto protocol buffer
+//        in serialized form.
+//
 // 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:";
+
+// 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) {
   if (status.ok())
     return NotificationDatabase::STATUS_OK;
   else if (status.IsNotFound())
     return NotificationDatabase::STATUS_ERROR_NOT_FOUND;
   else if (status.IsCorruption())
     return NotificationDatabase::STATUS_ERROR_CORRUPTED;
 
   return NotificationDatabase::STATUS_ERROR_FAILED;
 }
 
+// Creates the compound data key in which notification data is stored.
+std::string CreateDataKey(int64_t notification_id, const GURL& origin) {
+  return base::StringPrintf("%s%s%c%s",
+                            kDataKeyPrefix,
+                            storage::GetIdentifierFromOrigin(origin).c_str(),
+                            kKeySeparator,
+                            base::Int64ToString(notification_id).c_str());
+}
+
 }  // namespace
 
 NotificationDatabase::NotificationDatabase(const base::FilePath& path)
     : path_(path),
       state_(STATE_UNINITIALIZED) {
   sequence_checker_.DetachFromSequence();
 }
 
 NotificationDatabase::~NotificationDatabase() {
   DCHECK(sequence_checker_.CalledOnValidSequencedThread());
@@ skipping 25 matching lines @@
       leveldb::DB::Open(options, path_.AsUTF8Unsafe(), &db));
   if (status != STATUS_OK)
     return status;
 
   state_ = STATE_INITIALIZED;
   db_.reset(db);
 
   return STATUS_OK;
 }
 
-NotificationDatabase::Status NotificationDatabase::GetNextNotificationId(
-    int64_t* notification_id) const {
+NotificationDatabase::Status NotificationDatabase::ReadNotificationData(
+    int64_t notification_id,
+    const GURL& origin,
+    NotificationDatabaseData* notification_database_data) const {
   DCHECK(sequence_checker_.CalledOnValidSequencedThread());
-  DCHECK_EQ(state_, STATE_INITIALIZED);
+  DCHECK_EQ(STATE_INITIALIZED, state_);
+  DCHECK_GE(notification_id, kFirstNotificationId);
+  DCHECK(origin.is_valid());
+  DCHECK(notification_database_data);
+
+  std::string key = CreateDataKey(notification_id, origin);
+  std::string serialized_data;
+
+  Status status = LevelDBStatusToStatus(
+      db_->Get(leveldb::ReadOptions(), key, &serialized_data));
+  if (status != STATUS_OK)
+    return status;
+
+  if (notification_database_data->ParseFromString(serialized_data))
+    return STATUS_OK;
+
+  DLOG(ERROR) << "Unable to deserialize data for notification "
+              << notification_id << " belonging to " << origin << ".";
+  return STATUS_ERROR_CORRUPTED;
+}
+
+NotificationDatabase::Status NotificationDatabase::WriteNotificationData(
+    const GURL& origin,
+    const NotificationDatabaseData& notification_database_data,
+    int64_t* notification_id) {
+  DCHECK(sequence_checker_.CalledOnValidSequencedThread());
+  DCHECK_EQ(STATE_INITIALIZED, state_);
   DCHECK(notification_id);
+  DCHECK(origin.is_valid());
+
+  std::string serialized_data;
+  if (!notification_database_data.SerializeToString(&serialized_data)) {
+    DLOG(ERROR) << "Unable to serialize data for notification "
+                << notification_id << " belonging to " << origin << ".";
+    return STATUS_ERROR_FAILED;
+  }
+
+  leveldb::WriteBatch batch;
+  Status status = GetAndIncrementNextNotificationId(&batch, notification_id);

[cmumford, 2015/03/13 21:03:40]

What about just getting the next notification ID once, when the db is opened,
and keeping in a member variable. And then when WriteNotificationData is called,
you'd increment and write it out in the batch. Basically what you do now, but
w/o a db.get on every write?

[Peter Beverloo, 2015/03/16 11:56:45]

Awesome, even better :) Thanks for the suggestion - done!

+  if (status != STATUS_OK)
+    return status;
+
+  batch.Put(CreateDataKey(*notification_id, origin), serialized_data);
+
+  return LevelDBStatusToStatus(db_->Write(leveldb::WriteOptions(), &batch));
+}
+
+NotificationDatabase::Status NotificationDatabase::DeleteNotificationData(
+    int64_t notification_id,
+    const GURL& origin) {
+  DCHECK(sequence_checker_.CalledOnValidSequencedThread());
+  DCHECK_EQ(STATE_INITIALIZED, state_);
+  DCHECK_GE(notification_id, kFirstNotificationId);
+  DCHECK(origin.is_valid());
+
+  std::string key = CreateDataKey(notification_id, origin);
+
+  // TODO(peter): Instead of validating the existence of the data by reading the
+  // notification data, the notification list for |origin| should be considered
+  // instead. That list hasn't been implemented yet, however.
 
   std::string value;
   Status status = LevelDBStatusToStatus(
-      db_->Get(leveldb::ReadOptions(), kNextNotificationIdKey, &value));
-
-  if (status == STATUS_ERROR_NOT_FOUND) {
-    *notification_id = kFirstNotificationId;
-    return STATUS_OK;
-  }
-
+      db_->Get(leveldb::ReadOptions(), key, &value));
   if (status != STATUS_OK)
     return status;
 
-  int64_t next_notification_id;
-  if (!base::StringToInt64(value, &next_notification_id) ||
-      next_notification_id < kFirstNotificationId) {
-    return STATUS_ERROR_CORRUPTED;
-  }
-
-  *notification_id = next_notification_id;
-  return STATUS_OK;
+  return LevelDBStatusToStatus(db_->Delete(leveldb::WriteOptions(), key));
 }
 
 NotificationDatabase::Status NotificationDatabase::Destroy() {
   DCHECK(sequence_checker_.CalledOnValidSequencedThread());
 
   leveldb::Options options;
   if (IsInMemoryDatabase()) {
     if (!env_)
       return STATUS_OK;  // The database has not been initialized.
 
     options.env = env_.get();
   }
 
   state_ = STATE_DISABLED;
   db_.reset();
 
   return LevelDBStatusToStatus(
       leveldb::DestroyDB(path_.AsUTF8Unsafe(), options));
 }
 
-void NotificationDatabase::WriteNextNotificationId(
+NotificationDatabase::Status
+NotificationDatabase::GetAndIncrementNextNotificationId(
     leveldb::WriteBatch* batch,
-    int64_t next_notification_id) const {
-  DCHECK_GE(next_notification_id, kFirstNotificationId);
+    int64_t* notification_id) const {
   DCHECK(batch);
+  DCHECK(notification_id);
 
-  batch->Put(kNextNotificationIdKey, base::Int64ToString(next_notification_id));
+  std::string value;
+  Status status = LevelDBStatusToStatus(
+      db_->Get(leveldb::ReadOptions(), kNextNotificationIdKey, &value));
+
+  if (status == STATUS_ERROR_NOT_FOUND) {
+    *notification_id = kFirstNotificationId;
+
+  } else if (status == STATUS_OK) {
+    int64_t next_notification_id;
+    if (!base::StringToInt64(value, &next_notification_id) ||
+        next_notification_id < kFirstNotificationId) {
+      return STATUS_ERROR_CORRUPTED;
+    }
+
+    *notification_id = next_notification_id;
+  } else {
+    return status;
+  }
+
+  batch->Put(kNextNotificationIdKey,
+             base::Int64ToString(1 + *notification_id));
+
+  return STATUS_OK;
 }
 
 }  // namespace content