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"
+#include "base/files/file_util.h"
 #include "base/i18n/number_formatting.h"
 #include "base/logging.h"
 #include "base/memory/ptr_util.h"
 #include "base/memory/ref_counted.h"
 #include "base/strings/utf_string_conversions.h"
 #include "chrome/browser/notifications/notification.h"
 #include "chrome/browser/notifications/notification_test_util.h"
 #include "content/public/test/test_browser_thread_bundle.h"
 #include "content/public/test/test_utils.h"
 #include "dbus/mock_bus.h"
 #include "dbus/mock_object_proxy.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
+#include "third_party/re2/src/re2/re2.h"
+#include "ui/gfx/image/image_skia.h"
 
 using testing::_;
 using testing::Return;
 using testing::StrictMock;
 
 namespace {
 
 const char kFreedesktopNotificationsName[] = "org.freedesktop.Notifications";
 const char kFreedesktopNotificationsPath[] = "/org/freedesktop/Notifications";
 
 class NotificationBuilder {
  public:
   explicit NotificationBuilder(const std::string& id)
       : notification_(message_center::NOTIFICATION_TYPE_SIMPLE,
                       base::string16(),
                       base::string16(),
                       gfx::Image(),
                       message_center::NotifierId(GURL()),
                       base::string16(),
                       GURL(),
                       id,
                       message_center::RichNotificationData(),
                       new MockNotificationDelegate(id)) {}
 
   Notification GetResult() { return notification_; }
 
+  NotificationBuilder& SetImage(const gfx::Image& image) {
+    notification_.set_image(image);
+    return *this;
+  }
+
   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;
   }
@@ skipping 16 matching lines @@
  private:
   Notification notification_;
 };
 
 struct NotificationRequest {
   std::string summary;
   std::string body;
   int32_t expire_timeout = 0;
 };
 
+const SkBitmap CreateBitmap(int width, int height) {
+  SkBitmap bitmap;
+  bitmap.allocN32Pixels(width, height);
+  bitmap.eraseARGB(255, 0, 255, 0);
+  return bitmap;
+}
+
+gfx::ImageSkia CreateImageSkia(int width, int height) {
+  return gfx::ImageSkia::CreateFrom1xBitmap(CreateBitmap(width, height));
+}
+
 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;
   EXPECT_TRUE(reader.PopString(&str));              // app_name
   EXPECT_TRUE(reader.PopUint32(&uint32));           // replaces_id
@@ skipping 96 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>{"body"}));
+        .WillOnce(
+            OnGetCapabilities(std::vector<std::string>{"body", "body-images"}));
 
     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_));
 
     EXPECT_CALL(*mock_notification_proxy_.get(),
                 ConnectToSignal(kFreedesktopNotificationsName,
                                 "NotificationClosed", _, _))
         .WillOnce(RegisterSignalCallback(&notification_closed_callback_));
   }
 
   void TearDown() override {
     EXPECT_CALL(*mock_bus_.get(), ShutdownAndBlock());
     notification_bridge_linux_->CleanUp();
     content::RunAllBlockingPoolTasksUntilIdle();
     notification_bridge_linux_.reset();
     mock_notification_proxy_ = nullptr;
     mock_bus_ = nullptr;
   }
 
  protected:
   void CreateNotificationBridgeLinux() {
     notification_bridge_linux_ =
         base::WrapUnique(new NotificationPlatformBridgeLinux(mock_bus_));
+    content::RunAllBlockingPoolTasksUntilIdle();
   }
 
   content::TestBrowserThreadBundle thread_bundle_;
 
   scoped_refptr<dbus::MockBus> mock_bus_;
   scoped_refptr<dbus::MockObjectProxy> mock_notification_proxy_;
 
   base::Callback<void(dbus::Signal*)> action_invoked_callback_;
   base::Callback<void(dbus::Signal*)> notification_closed_callback_;
 
@@ skipping 80 matching lines @@
           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());
 }
+
+TEST_F(NotificationPlatformBridgeLinuxTest, NotificationImages) {
+  const int kMaxImageWidth = 200;
+  const int kMaxImageHeight = 100;
+
+  const int original_width = kMaxImageWidth * 2;
+  const int original_height = kMaxImageHeight;
+  const int expected_width = kMaxImageWidth;
+  const int expected_height = kMaxImageHeight / 2;
+
+  gfx::Image original_image =
+      gfx::Image(CreateImageSkia(original_width, original_height));
+
+  EXPECT_CALL(*mock_notification_proxy_.get(),
+              MockCallMethodAndBlock(Calls("Notify"), _))
+      .WillOnce(OnNotify(
+          [=](const NotificationRequest& request) {
+            std::string file_name;
+            EXPECT_TRUE(RE2::FullMatch(
+                request.body, "\\<img src=\\\"(.+)\\\" alt=\\\".*\\\"/\\>",
+                &file_name));
+            std::string file_contents;
+            EXPECT_TRUE(base::ReadFileToString(base::FilePath(file_name),
+                                               &file_contents));
+            gfx::Image image = gfx::Image::CreateFrom1xPNGBytes(
+                reinterpret_cast<const unsigned char*>(file_contents.c_str()),
+                file_contents.size());
+            EXPECT_EQ(expected_width, image.Width());
+            EXPECT_EQ(expected_height, image.Height());
+          },
+          1));
+
+  CreateNotificationBridgeLinux();
+  notification_bridge_linux_->Display(
+      NotificationCommon::PERSISTENT, "", "", false,
+      NotificationBuilder("")
+          .SetType(message_center::NOTIFICATION_TYPE_IMAGE)
+          .SetImage(original_image)
+          .GetResult());
+}