Linux native notifications: Support infinite timeouts

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 35 matching lines @@
                       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;

[Peter Beverloo, 2017/05/11 15:47:01]

nit: initialize to 0 since it's a scalar

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

Done.

 };
 
 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(&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 163 matching lines @@
   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());
+}