Linux native notifications: Support image notifications

chrome/browser/notifications/notification_platform_bridge_linux_unittest.cc

 // Copyright 2017 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 "chrome/browser/notifications/notification_platform_bridge_linux.h"
 
 #include <memory>
 #include <vector>
 
 #include "base/callback.h"
@@ skipping 29 matching lines @@
                       gfx::Image(),
                       message_center::NotifierId(GURL()),
                       base::string16(),
                       GURL(),
                       id,
                       message_center::RichNotificationData(),
                       new MockNotificationDelegate(id)) {}
 
   Notification GetResult() { return notification_; }
 
+  NotificationBuilder& SetItems(
+      const std::vector<message_center::NotificationItem>& items) {
+    notification_.set_items(items);
+    return *this;
+  }
+
+  NotificationBuilder& SetNeverTimeout(bool never_timeout) {
+    notification_.set_never_timeout(never_timeout);
+    return *this;
+  }
+
   NotificationBuilder& SetProgress(int progress) {
     notification_.set_progress(progress);
     return *this;
   }
 
   NotificationBuilder& SetTitle(const base::string16& title) {
     notification_.set_title(title);
     return *this;
   }
 
   NotificationBuilder& SetType(message_center::NotificationType type) {
     notification_.set_type(type);
     return *this;
   }
 
  private:
   Notification notification_;
 };
 
 struct NotificationRequest {
   std::string summary;
+  std::string body;
+  int32_t expire_timeout = 0;
 };
 
 NotificationRequest ParseRequest(dbus::MethodCall* method_call) {
   // The "Notify" message must have type (susssasa{sv}i).
   // https://developer.gnome.org/notification-spec/#command-notify
   NotificationRequest request;
 
   dbus::MessageReader reader(method_call);
   std::string str;
   uint32_t uint32;
-  int32_t int32;
   EXPECT_TRUE(reader.PopString(&str));              // app_name
   EXPECT_TRUE(reader.PopUint32(&uint32));           // replaces_id
   EXPECT_TRUE(reader.PopString(&str));              // app_icon
   EXPECT_TRUE(reader.PopString(&request.summary));  // summary
-  EXPECT_TRUE(reader.PopString(&str));              // body
+  EXPECT_TRUE(reader.PopString(&request.body));     // body
 
   {
     dbus::MessageReader actions_reader(nullptr);
     EXPECT_TRUE(reader.PopArray(&actions_reader));
     while (actions_reader.HasMoreData()) {
       // Actions come in pairs.
       EXPECT_TRUE(actions_reader.PopString(&str));
       EXPECT_TRUE(actions_reader.PopString(&str));
     }
   }
 
   {
     dbus::MessageReader hints_reader(nullptr);
     EXPECT_TRUE(reader.PopArray(&hints_reader));
     while (hints_reader.HasMoreData()) {
       dbus::MessageReader dict_entry_reader(nullptr);
       EXPECT_TRUE(hints_reader.PopDictEntry(&dict_entry_reader));
       EXPECT_TRUE(dict_entry_reader.PopString(&str));
       dbus::MessageReader variant_reader(nullptr);
       EXPECT_TRUE(dict_entry_reader.PopVariant(&variant_reader));
       EXPECT_FALSE(dict_entry_reader.HasMoreData());
     }
   }
 
-  EXPECT_TRUE(reader.PopInt32(&int32));  // expire_timeout
+  EXPECT_TRUE(reader.PopInt32(&request.expire_timeout));
   EXPECT_FALSE(reader.HasMoreData());
 
   return request;
 }
 
 dbus::Response* GetIdResponse(uint32_t id) {
   dbus::Response* response = dbus::Response::CreateEmpty().release();
   dbus::MessageWriter writer(response);
   writer.AppendUint32(id);
   return response;
@@ skipping 16 matching lines @@
 ACTION_P(OnGetServerInformation, spec_version) {
   dbus::Response* response = dbus::Response::CreateEmpty().release();
   dbus::MessageWriter writer(response);
   writer.AppendString("");  // name
   writer.AppendString("");  // vendor
   writer.AppendString("");  // version
   writer.AppendString(spec_version);
   return response;
 }
 
-ACTION_P(OnNotify, id) {
-  ParseRequest(arg0);
+ACTION_P2(OnNotify, verifier, id) {
+  verifier(ParseRequest(arg0));
   return GetIdResponse(id);
 }
 
 ACTION(OnCloseNotification) {
   // The "CloseNotification" message must have type (u).
   // https://developer.gnome.org/notification-spec/#command-close-notification
   dbus::MethodCall* method_call = arg0;
   dbus::MessageReader reader(method_call);
   uint32_t uint32;
   EXPECT_TRUE(reader.PopUint32(&uint32));
@@ skipping 20 matching lines @@
         mock_bus_.get(), kFreedesktopNotificationsName,
         dbus::ObjectPath(kFreedesktopNotificationsPath));
 
     EXPECT_CALL(*mock_bus_.get(),
                 GetObjectProxy(kFreedesktopNotificationsName,
                                dbus::ObjectPath(kFreedesktopNotificationsPath)))
         .WillOnce(Return(mock_notification_proxy_.get()));
 
     EXPECT_CALL(*mock_notification_proxy_.get(),
                 MockCallMethodAndBlock(Calls("GetCapabilities"), _))
-        .WillOnce(OnGetCapabilities(std::vector<std::string>()));
+        .WillOnce(OnGetCapabilities(std::vector<std::string>{"body"}));
 
     EXPECT_CALL(*mock_notification_proxy_.get(),
                 MockCallMethodAndBlock(Calls("GetServerInformation"), _))
         .WillOnce(OnGetServerInformation("1.2"));
 
     EXPECT_CALL(
         *mock_notification_proxy_.get(),
         ConnectToSignal(kFreedesktopNotificationsName, "ActionInvoked", _, _))
         .WillOnce(RegisterSignalCallback(&action_invoked_callback_));
 
@@ skipping 32 matching lines @@
   DISALLOW_COPY_AND_ASSIGN(NotificationPlatformBridgeLinuxTest);
 };
 
 TEST_F(NotificationPlatformBridgeLinuxTest, SetUpAndTearDown) {
   CreateNotificationBridgeLinux();
 }
 
 TEST_F(NotificationPlatformBridgeLinuxTest, NotifyAndCloseFormat) {
   EXPECT_CALL(*mock_notification_proxy_.get(),
               MockCallMethodAndBlock(Calls("Notify"), _))
-      .WillOnce(OnNotify(1));
+      .WillOnce(OnNotify([](const NotificationRequest&) {}, 1));
   EXPECT_CALL(*mock_notification_proxy_.get(),
               MockCallMethodAndBlock(Calls("CloseNotification"), _))
       .WillOnce(OnCloseNotification());
 
   CreateNotificationBridgeLinux();
   notification_bridge_linux_->Display(NotificationCommon::PERSISTENT, "", "",
                                       false,
                                       NotificationBuilder("").GetResult());
   notification_bridge_linux_->Close("", "");
 }
 
-ACTION_P2(VerifySummary, summary, id) {
-  NotificationRequest request = ParseRequest(arg0);
-  EXPECT_EQ(summary, request.summary);
-  return GetIdResponse(id);
-}
-
 TEST_F(NotificationPlatformBridgeLinuxTest, ProgressPercentageAddedToSummary) {
   EXPECT_CALL(*mock_notification_proxy_.get(),
               MockCallMethodAndBlock(Calls("Notify"), _))
-      .WillOnce(VerifySummary(
-          base::UTF16ToUTF8(base::FormatPercent(42)) + " - The Title", 1));
+      .WillOnce(OnNotify(
+          [](const NotificationRequest& request) {
+            EXPECT_EQ(
+                base::UTF16ToUTF8(base::FormatPercent(42)) + " - The Title",
+                request.summary);
+          },
+          1));
 
   CreateNotificationBridgeLinux();
   notification_bridge_linux_->Display(
       NotificationCommon::PERSISTENT, "", "", false,
       NotificationBuilder("")
           .SetType(message_center::NOTIFICATION_TYPE_PROGRESS)
           .SetProgress(42)
           .SetTitle(base::UTF8ToUTF16("The Title"))
           .GetResult());
 }
+
+TEST_F(NotificationPlatformBridgeLinuxTest, NotificationListItemsInBody) {
+  EXPECT_CALL(*mock_notification_proxy_.get(),
+              MockCallMethodAndBlock(Calls("Notify"), _))
+      .WillOnce(OnNotify(
+          [](const NotificationRequest& request) {
+            EXPECT_EQ("abc - 123\ndef - 456", request.body);
+          },
+          1));
+
+  CreateNotificationBridgeLinux();
+  notification_bridge_linux_->Display(
+      NotificationCommon::PERSISTENT, "", "", false,
+      NotificationBuilder("")
+          .SetType(message_center::NOTIFICATION_TYPE_MULTIPLE)
+          .SetItems(std::vector<message_center::NotificationItem>{
+              {base::UTF8ToUTF16("abc"), base::UTF8ToUTF16("123")},
+              {base::UTF8ToUTF16("def"), base::UTF8ToUTF16("456")}})
+          .GetResult());
+}
+
+TEST_F(NotificationPlatformBridgeLinuxTest, NotificationTimeouts) {
+  const int32_t kExpireTimeoutDefault = -1;
+  const int32_t kExpireTimeoutNever = 0;
+  EXPECT_CALL(*mock_notification_proxy_.get(),
+              MockCallMethodAndBlock(Calls("Notify"), _))
+      .WillOnce(OnNotify(
+          [=](const NotificationRequest& request) {
+            EXPECT_EQ(kExpireTimeoutDefault, request.expire_timeout);
+          },
+          1))
+      .WillOnce(OnNotify(
+          [=](const NotificationRequest& request) {
+            EXPECT_EQ(kExpireTimeoutNever, request.expire_timeout);
+          },
+          2));
+
+  CreateNotificationBridgeLinux();
+  notification_bridge_linux_->Display(
+      NotificationCommon::PERSISTENT, "", "", false,
+      NotificationBuilder("1").SetNeverTimeout(false).GetResult());
+  notification_bridge_linux_->Display(
+      NotificationCommon::PERSISTENT, "", "", false,
+      NotificationBuilder("2").SetNeverTimeout(true).GetResult());
+}

[Peter Beverloo, 2017/05/15 16:16:00]

Should there be a test for big image here?

[Tom (Use chromium acct), 2017/05/15 19:18:39]

Done.