Linux native notifications: Support image notifications

chrome/browser/notifications/notification_platform_bridge_linux.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 <algorithm>
 #include <memory>
 #include <set>
 #include <unordered_map>
@@ skipping 16 matching lines @@
 #include "chrome/browser/notifications/native_notification_display_service.h"
 #include "chrome/browser/notifications/notification.h"
 #include "chrome/browser/notifications/notification_display_service_factory.h"
 #include "chrome/browser/profiles/profile_manager.h"
 #include "chrome/browser/shell_integration_linux.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/notification_service.h"
 #include "dbus/bus.h"
 #include "dbus/message.h"
 #include "dbus/object_proxy.h"
+#include "skia/ext/image_operations.h"
 #include "ui/gfx/image/image_skia.h"
 
 namespace {
 
 const char kFreedesktopNotificationsName[] = "org.freedesktop.Notifications";
 const char kFreedesktopNotificationsPath[] = "/org/freedesktop/Notifications";
 
 const char kDefaultButtonId[] = "default";
 const char kSettingsButtonId[] = "settings";
 
+// Specified in FDO notification specification.
+const int kMaxImageWidth = 200;
+const int kMaxImageHeight = 100;

[Peter Beverloo, 2017/05/10 12:54:40]

This is tiny! Developers have to provide images with a width of 1440 pixels for
modern phones. Screen density makes a huge difference here, so it'd be
interesting to learn how this'll work out in practice.

[Tom (Use chromium acct), 2017/05/11 00:07:04]

Yeah, but the only notification server that actually supports inline images
(LXQt notification daemon) sort of goes crazy when you give it a larger image.

+
 // The values in this enumeration correspond to those of the
 // Linux.NotificationPlatformBridge.InitializationStatus histogram, so
 // the ordering should not be changed.  New error codes should be
 // added at the end, before NUM_ITEMS.
 enum class ConnectionInitializationStatusCode {
   SUCCESS = 0,
   NATIVE_NOTIFICATIONS_NOT_SUPPORTED = 1,
   MISSING_REQUIRED_CAPABILITIES = 2,
   COULD_NOT_CONNECT_TO_SIGNALS = 3,
   INCOMPATIBLE_SPEC_VERSION = 4,
   NUM_ITEMS
 };
 
+int ClampInt(int v, int lo, int hi) {
+  if (v < lo)
+    return lo;
+  if (v > hi)
+    return hi;
+  return v;
+}
+
 gfx::Image DeepCopyImage(const gfx::Image& image) {
   if (image.IsEmpty())
     return gfx::Image();
   std::unique_ptr<gfx::ImageSkia> image_skia(image.CopyImageSkia());
   return gfx::Image(*image_skia);
 }
 
 int NotificationPriorityToFdoUrgency(int priority) {
   enum FdoUrgency {
     LOW = 0,
@@ skipping 121 matching lines @@
                bool is_incognito,
                const Notification& notification) override {
     DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
     // Notifications contain gfx::Image's which have reference counts
     // that are not thread safe.  Because of this, we duplicate the
     // notification and its images.  Wrap the notification in a
     // unique_ptr to transfer ownership of the notification (and the
     // non-thread-safe reference counts) to the task runner thread.
     auto notification_copy = base::MakeUnique<Notification>(notification);
     notification_copy->set_icon(DeepCopyImage(notification_copy->icon()));
-    notification_copy->set_image(gfx::Image());
+    if (body_images_supported_ != BODY_IMAGES_NOT_SUPPORTED &&
+        !notification_copy->image().IsEmpty()) {
+      int width = notification_copy->image().Width();
+      int height = notification_copy->image().Height();
+      if (width <= kMaxImageWidth && height <= kMaxImageHeight) {
+        notification_copy->set_image(DeepCopyImage(notification_copy->image()));
+      } else {
+        const SkBitmap* image_bitmap = notification_copy->image().ToSkBitmap();
+        double scale = std::min(static_cast<double>(kMaxImageWidth) / width,
+                                static_cast<double>(kMaxImageHeight) / height);
+        width = ClampInt(scale * width, 1, kMaxImageWidth);
+        height = ClampInt(scale * height, 1, kMaxImageHeight);
+        notification_copy->set_image(gfx::Image(
+            gfx::ImageSkia::CreateFrom1xBitmap(skia::ImageOperations::Resize(
+                *image_bitmap, skia::ImageOperations::RESIZE_LANCZOS3, width,
+                height))));

[Peter Beverloo, 2017/05/10 12:54:40]

Since these images potentially can be huge, we shouldn't do this on the UI
thread. Can the task runner thread be used for the resize? That'd avoid the
multi-thread warning at the member declaration site below.

[Tom (Use chromium acct), 2017/05/11 00:07:04]

Done.

+      }
+    }
     notification_copy->set_small_image(gfx::Image());
     for (size_t i = 0; i < notification_copy->buttons().size(); i++)
       notification_copy->SetButtonIcon(i, gfx::Image());
 
     PostTaskToTaskRunnerThread(base::BindOnce(
         &NotificationPlatformBridgeLinuxImpl::DisplayOnTaskRunner, this,
         notification_type, notification_id, profile_id, is_incognito,
         base::Passed(&notification_copy)));
   }
 
@@ skipping 130 matching lines @@
         notification_proxy_->CallMethodAndBlock(
             &get_capabilities_call, dbus::ObjectProxy::TIMEOUT_USE_DEFAULT);
     if (capabilities_response) {
       dbus::MessageReader reader(capabilities_response.get());
       std::vector<std::string> capabilities;
       reader.PopArrayOfStrings(&capabilities);
       for (const std::string& capability : capabilities)
         capabilities_.insert(capability);
     }
     RecordMetricsForCapabilities();
+    body_images_supported_ = base::ContainsKey(capabilities_, "body-images")
+                                 ? BODY_IMAGES_SUPPORTED
+                                 : BODY_IMAGES_NOT_SUPPORTED;
 
     dbus::MethodCall get_server_information_call(kFreedesktopNotificationsName,
                                                  "GetServerInformation");
     std::unique_ptr<dbus::Response> server_information_response =
         notification_proxy_->CallMethodAndBlock(
             &get_server_information_call,
             dbus::ObjectProxy::TIMEOUT_USE_DEFAULT);
     if (server_information_response) {
       dbus::MessageReader reader(server_information_response.get());
       std::string spec_version;
@@ skipping 88 matching lines @@
         for (const auto& item : notification->items()) {
           if (!body.empty())
             body += "\n";
           const std::string title = base::UTF16ToUTF8(item.title);
           const std::string message = base::UTF16ToUTF8(item.message);
           if (body_markup)
             body += "<b>" + title + "</b> " + message;
           else
             body += title + " - " + message;
         }
+      } else if (notification->type() ==
+                 message_center::NOTIFICATION_TYPE_IMAGE) {
+        std::unique_ptr<ResourceFile> image_file =
+            WriteDataToTmpFile(notification->image().As1xPNGBytes());
+        if (image_file) {
+          if (!body.empty())
+            body += "\n";
+          body +=
+              "<img src=\"" + image_file->file_path().value() + "\" alt=\"\"/>";

[Peter Beverloo, 2017/05/10 12:54:40]

Is a data: URL an option here? If the toast requires full HTML rendering anyway
I wouldn't expect that to be significantly slower.

[Tom (Use chromium acct), 2017/05/11 00:07:04]

No, the spec says "Images referenced must always be local files."

Also: "A full-blown HTML implementation is not required of this spec, and
notifications should never take advantage of tags that are not listed above. As
notifications are not a substitute for web browsers or complex dialogs, advanced
layout is not necessary, and may in fact limit the number of systems that
notification services can run on, due to memory usage and screen space. Such
examples are PDAs, certain cell phones, and slow PCs or laptops with little
memory."

+          data->resource_files.push_back(std::move(image_file));
+        }
       }
     }
     writer.AppendString(body);
 
     // Even-indexed elements in this vector are action IDs passed back to
     // us in OnActionInvoked().  Odd-indexed ones contain the button text.
     std::vector<std::string> actions;
     if (base::ContainsKey(capabilities_, "actions")) {
       data->action_start = data->action_end;
       for (const auto& button_info : notification->buttons()) {
@@ skipping 291 matching lines @@
   base::Closure connected_signals_barrier_;
 
   // 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_;
 
+  //////////////////////////////////////////////////////////////////////////////
+  // Members used on both the UI thread and the task runner thread.
+
+  // Notification servers very rarely have the 'body-images'
+  // capability, so try to avoid an image copy/resize if possible.
+  // Reads and writes to |body_images_supported_| should be atomic, so
+  // no locking is necessary.
+  enum {
+    BODY_IMAGES_UNKNOWN,
+    BODY_IMAGES_SUPPORTED,
+    BODY_IMAGES_NOT_SUPPORTED,
+  } body_images_supported_ = BODY_IMAGES_UNKNOWN;

[Peter Beverloo, 2017/05/10 12:54:40]

It looks like you're considering base::Optional<bool> semantics here? Could even
simplify that and just default to false until line 382 executes.

[Tom (Use chromium acct), 2017/05/11 00:07:04]

Done.

+
   DISALLOW_COPY_AND_ASSIGN(NotificationPlatformBridgeLinuxImpl);
 };
 
 NotificationPlatformBridgeLinux::NotificationPlatformBridgeLinux()
     : NotificationPlatformBridgeLinux(nullptr) {}
 
 NotificationPlatformBridgeLinux::NotificationPlatformBridgeLinux(
     scoped_refptr<dbus::Bus> bus)
     : impl_(new NotificationPlatformBridgeLinuxImpl(bus)) {
   impl_->Init();
@@ skipping 25 matching lines @@
 }
 
 void NotificationPlatformBridgeLinux::SetReadyCallback(
     NotificationBridgeReadyCallback callback) {
   impl_->SetReadyCallback(std::move(callback));
 }
 
 void NotificationPlatformBridgeLinux::CleanUp() {
   impl_->CleanUp();
 }