Add the NotificationDatabaseData structure and protobuf

content/browser/notifications/notification_database_data_unittest.cc

Index: content/browser/notifications/notification_database_data_unittest.cc
diff --git a/content/browser/notifications/notification_database_data_unittest.cc b/content/browser/notifications/notification_database_data_unittest.cc
new file mode 100644
index 0000000000000000000000000000000000000000..fb4a215e96188c91caf6f38d8d03d2eeb217a9c7
--- /dev/null
+++ b/content/browser/notifications/notification_database_data_unittest.cc
@@ -0,0 +1,105 @@
+// 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_data.h"
+
+#include "base/strings/utf_string_conversions.h"
+#include "content/browser/notifications/notification_database_data.pb.h"
+#include "testing/gtest/include/gtest/gtest.h"
+
+namespace content {
+namespace {

[Bernhard Bauer, 2015/03/12 18:11:14]

Nit: You don't strictly need the anonymous namespace here, as constants
automatically get internal linkage.

[Peter Beverloo, 2015/03/12 21:09:52]

Do they have internal linkage unless they've been declared as being exported,
like command line flags?

Having constants such as this in an anonymous namespace is far more common,
though, according to codesearch. Happy to change it if you feel strongly.

[Bernhard Bauer, 2015/03/13 12:27:19]

Exactly. (This allows you to declare a constant in a header, without violating
the ODR.)
It is, because very few people seem to know about this :) And TBH, a large
reason why I always point this out is to increase awareness. I think it allows
removing a couple of lines of code, so I personally prefer leaving out the
anonymous namespace, but I don't have a strong opinion.

+
+const int64_t kNotificationId = 42;
+const int64_t kServiceWorkerRegistrationId = 9001;
+
+const char kOrigin[] = "https://example.com/";
+const char kNotificationTitle[] = "My Notification";
+const char kNotificationLang[] = "nl";
+const char kNotificationBody[] = "Hello, world!";
+const char kNotificationTag[] = "my_tag";
+const char kNotificationIconUrl[] = "https://example.com/icon.png";
+
+}  // namespace
+
+using NotificationDatabaseDataTest = ::testing::Test;
+
+TEST_F(NotificationDatabaseDataTest, ToProtocolBufferMessage) {
+  PlatformNotificationData notification_data;
+  notification_data.title = base::ASCIIToUTF16(kNotificationTitle);
+  notification_data.direction =
+      PlatformNotificationData::NotificationDirectionRightToLeft;
+  notification_data.lang = kNotificationLang;
+  notification_data.body = base::ASCIIToUTF16(kNotificationBody);
+  notification_data.tag = kNotificationTag;
+  notification_data.icon = GURL(kNotificationIconUrl);
+  notification_data.silent = true;
+
+  NotificationDatabaseData database_data;
+  database_data.notification_id = kNotificationId;
+  database_data.origin = GURL(kOrigin);
+  database_data.service_worker_registration_id = kServiceWorkerRegistrationId;
+  database_data.notification_data = notification_data;
+
+  NotificationDatabaseDataProto message =
+      ToNotificationDatabaseDataProto(database_data);
+
+  EXPECT_EQ(kNotificationId, message.notification_id());
+  EXPECT_EQ(kOrigin, message.origin());
+  EXPECT_EQ(kServiceWorkerRegistrationId,
+            message.service_worker_registration_id());
+
+  const NotificationDatabaseDataProto::NotificationData& payload =
+      message.notification_data();
+
+  EXPECT_EQ(kNotificationTitle, payload.title());
+  EXPECT_EQ(NotificationDatabaseDataProto::NotificationData::RIGHT_TO_LEFT,
+            payload.direction());
+  EXPECT_EQ(kNotificationLang, payload.lang());
+  EXPECT_EQ(kNotificationBody, payload.body());
+  EXPECT_EQ(kNotificationTag, payload.tag());
+  EXPECT_EQ(kNotificationIconUrl, payload.icon());
+  EXPECT_TRUE(payload.silent());
+}
+
+TEST_F(NotificationDatabaseDataTest, FromProtocolBuffer) {
+  scoped_ptr<NotificationDatabaseDataProto::NotificationData> payload(
+      new NotificationDatabaseDataProto::NotificationData());
+
+  payload->set_title(kNotificationTitle);
+  payload->set_direction(
+      NotificationDatabaseDataProto::NotificationData::RIGHT_TO_LEFT);
+  payload->set_lang(kNotificationLang);
+  payload->set_body(kNotificationBody);
+  payload->set_tag(kNotificationTag);
+  payload->set_icon(kNotificationIconUrl);
+  payload->set_silent(true);
+
+  NotificationDatabaseDataProto message;
+  message.set_notification_id(kNotificationId);
+  message.set_origin(kOrigin);
+  message.set_service_worker_registration_id(kServiceWorkerRegistrationId);
+  message.set_allocated_notification_data(payload.release());
+
+  NotificationDatabaseData database_data = ToNotificationDatabaseData(message);
+
+  EXPECT_EQ(kNotificationId, database_data.notification_id);
+  EXPECT_EQ(kOrigin, database_data.origin.spec());
+  EXPECT_EQ(kServiceWorkerRegistrationId,
+            database_data.service_worker_registration_id);
+
+  const PlatformNotificationData& notification_data =
+      database_data.notification_data;
+
+  EXPECT_EQ(kNotificationTitle, base::UTF16ToASCII(notification_data.title));
+  EXPECT_EQ(PlatformNotificationData::NotificationDirectionRightToLeft,
+            notification_data.direction);
+  EXPECT_EQ(kNotificationLang, notification_data.lang);
+  EXPECT_EQ(kNotificationBody, base::UTF16ToASCII(notification_data.body));
+  EXPECT_EQ(kNotificationTag, notification_data.tag);
+  EXPECT_EQ(kNotificationIconUrl, notification_data.icon.spec());
+  EXPECT_TRUE(notification_data.silent);
+}
+
+}  // namespace content