Linux native notifications: Support closing and updating notifications

chrome/browser/notifications/notification_platform_bridge_linux.h

 // 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.
 
 #ifndef CHROME_BROWSER_NOTIFICATIONS_NOTIFICATION_PLATFORM_BRIDGE_LINUX_H_
 #define CHROME_BROWSER_NOTIFICATIONS_NOTIFICATION_PLATFORM_BRIDGE_LINUX_H_
 
 #include <gio/gio.h>
 
+#include <unordered_map>
+
 #include "base/macros.h"
 #include "chrome/browser/notifications/notification_platform_bridge.h"
+#include "ui/base/glib/scoped_gobject.h"
 
 class NotificationPlatformBridgeLinux : public NotificationPlatformBridge {
  public:
   explicit NotificationPlatformBridgeLinux(GDBusProxy* notification_proxy);
 
   ~NotificationPlatformBridgeLinux() override;
 
   // NotificationPlatformBridge:
   void Display(NotificationCommon::Type notification_type,
                const std::string& notification_id,
                const std::string& profile_id,
                bool is_incognito,
                const Notification& notification) override;
   void Close(const std::string& profile_id,
              const std::string& notification_id) override;
   void GetDisplayed(
       const std::string& profile_id,
       bool incognito,
       const DisplayedNotificationsCallback& callback) const override;
 
  private:
-  GDBusProxy* const notification_proxy_;
+  struct NotificationData {
+    NotificationData(const std::string& notification_id,
+                     const std::string& profile_id,
+                     bool is_incognito,
+                     NotificationPlatformBridgeLinux* platform_bridge);
+
+    ~NotificationData();
+
+    // The ID used by the notification server.  Will be 0 until the
+    // first "Notify" message completes.
+    uint32_t dbus_id = 0;
+
+    // Same parameters used by NotificationPlatformBridge::Display().
+    const std::string notification_id;
+    const std::string profile_id;
+    const bool is_incognito;
+
+    NotificationPlatformBridgeLinux* platform_bridge;
+
+    // Used to cancel the initial "Notify" message so we don't call
+    // NotificationPlatformBridgeLinux::OnNotifyComplete() with a
+    // destroyed Notification.
+    ScopedGObject<GCancellable> cancellable;
+
+    // If not null, the data to update the notification with once
+    // |dbus_id| becomes available.
+    std::unique_ptr<Notification> update_data;
+    NotificationCommon::Type update_type;

[Peter Beverloo, 2017/04/06 17:56:57]

Maybe initialize this as NotificationCommon::TYPE_MAX? It's a scalar and we're
currently leaving it as uninitialized.

Alternatively base::Optional<> would work too.

[Tom (Use chromium acct), 2017/04/06 18:25:38]

Done.

+
+    // If true, indicates the notification should be closed once
+    // |dbus_id| becomes available.
+    bool should_close = false;
+  };

[Peter Beverloo, 2017/04/06 17:56:57]

(You could decide to only forward declare the struct in the header, and define
it in the implementation, if you're a fan of keeping the header files clean.)

[Tom (Use chromium acct), 2017/04/06 18:25:38]

Done.

+
+  // Callback used by GLib when the "Notify" message completes for the
+  // first time.
+  friend void OnNotifyComplete(GObject* source_object,
+                               GAsyncResult* result,
+                               gpointer user_data);
+
+  // Called from ::OnNotifyComplete().
+  void OnNotifyComplete(NotificationData* data, GVariant* value);
+
+  ScopedGObject<GDBusProxy> notification_proxy_;
+
+  // A std::set<std::unique_ptr<T>> doesn't work well because
+  // eg. std::set::erase(T) would require a std::unique_ptr<T>
+  // argument, so the data would get double-destructed.
+  template <typename T>
+  using UnorderedUniqueSet = std::unordered_map<T*, std::unique_ptr<T>>;
+
+  UnorderedUniqueSet<NotificationData> notifications_;
+
+  // Makes the "Notify" call to D-Bus.
+  void NotifyNow(uint32_t dbus_id,
+                 NotificationCommon::Type notification_type,
+                 const Notification& notification,
+                 GCancellable* cancellable,
+                 GAsyncReadyCallback callback,
+                 gpointer user_data);
+
+  // Makes the "CloseNotification" call to D-Bus.
+  void CloseNow(uint32_t dbus_id);
+
+  NotificationData* FindNotificationData(const std::string& notification_id,
+                                         const std::string& profile_id);
 
   DISALLOW_COPY_AND_ASSIGN(NotificationPlatformBridgeLinux);
 };
 
 #endif  // CHROME_BROWSER_NOTIFICATIONS_NOTIFICATION_PLATFORM_BRIDGE_LINUX_H_