Initial client side implementation of the XPC service

chrome/browser/notifications/notification_platform_bridge_mac.mm

 // Copyright 2015 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_mac.h"
 
 #include <utility>
 
+#include "base/bind.h"
+#include "base/bind_helpers.h"
+#include "base/mac/bundle_locations.h"
 #include "base/mac/foundation_util.h"
 #include "base/mac/mac_util.h"
+#include "base/mac/scoped_nsobject.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/sys_string_conversions.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/notifications/native_notification_display_service.h"
 #include "chrome/browser/notifications/notification.h"
 #include "chrome/browser/notifications/notification_common.h"
 #include "chrome/browser/notifications/notification_display_service_factory.h"
 #include "chrome/browser/notifications/persistent_notification_delegate.h"
 #include "chrome/browser/notifications/platform_notification_service_impl.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/profiles/profile_manager.h"
 #include "chrome/browser/ui/cocoa/notifications/notification_builder_mac.h"
+#import "chrome/browser/ui/cocoa/notifications/notification_delivery.h"
 #include "chrome/browser/ui/cocoa/notifications/notification_constants_mac.h"
 #import "chrome/browser/ui/cocoa/notifications/notification_response_builder_mac.h"
+#include "chrome/common/features.h"
+#include "chrome/grit/generated_resources.h"
 #include "components/url_formatter/elide_url.h"
 #include "third_party/WebKit/public/platform/modules/notifications/WebNotificationConstants.h"
+#include "ui/base/l10n/l10n_util_mac.h"
 #include "url/gurl.h"
 #include "url/origin.h"
 
 @class NSUserNotification;
 @class NSUserNotificationCenter;
 
 // The mapping from web notifications to NsUserNotification works as follows
 
 // notification#title in NSUserNotification.title
 // notification#message in NSUserNotification.informativeText
@@ skipping 27 matching lines @@
   }
 
   NotificationDisplayService* display_service =
       NotificationDisplayServiceFactory::GetForProfile(profile);
 
   static_cast<NativeNotificationDisplayService*>(display_service)
       ->ProcessNotificationOperation(operation, notification_type, origin,
                                      notification_id, action_index);
 }
 
+// Loads the profile and process the Notification response
+void DoProcessNotificationResponse(NotificationCommon::Operation operation,
+                                   NotificationCommon::Type type,
+                                   const std::string& profile_id,
+                                   bool incognito,
+                                   const std::string& origin,
+                                   const std::string& notification_id,
+                                   int32_t button_index) {
+  DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
+  ProfileManager* profileManager = g_browser_process->profile_manager();
+  DCHECK(profileManager);
+
+  profileManager->LoadProfile(
+      profile_id, incognito, base::Bind(&ProfileLoadedCallback, operation, type,
+                                        origin, notification_id, button_index));
+}
+
 }  // namespace
 
 // static
 NotificationPlatformBridge* NotificationPlatformBridge::Create() {
   return new NotificationPlatformBridgeMac(
       [NSUserNotificationCenter defaultUserNotificationCenter]);
 }
 
 // A Cocoa class that represents the delegate of NSUserNotificationCenter and
 // can forward commands to C++.
 @interface NotificationCenterDelegate
     : NSObject<NSUserNotificationCenterDelegate> {
 }
 @end
 
+// Interface to communicate with the Alert XPC service.
+@interface NotificationRemoteDispatcher : NSObject
+
+- (void)dispatchNotification:(NSDictionary*)data;
+
+@end
+
 // /////////////////////////////////////////////////////////////////////////////
 
 NotificationPlatformBridgeMac::NotificationPlatformBridgeMac(
     NSUserNotificationCenter* notification_center)
     : delegate_([NotificationCenterDelegate alloc]),
-      notification_center_(notification_center) {
+      notification_center_(notification_center),
+#if BUILDFLAG(ENABLE_XPC_NOTIFICATIONS)
+      notification_remote_dispatcher_(
+          [[NotificationRemoteDispatcher alloc] init])
+#else
+      notification_remote_dispatcher_(nullptr)
+#endif  // ENABLE_XPC_NOTIFICATIONS
+{
   [notification_center_ setDelegate:delegate_.get()];
 }
 
 NotificationPlatformBridgeMac::~NotificationPlatformBridgeMac() {
   [notification_center_ setDelegate:nil];
 
-  // TODO(miguelg) lift this restriction if possible.
+  // TODO(miguelg) remove only alerts shown by the XPC service.
+  // TODO(miguelg) do not remove banners if possible.
   [notification_center_ removeAllDeliveredNotifications];
 }
 
 void NotificationPlatformBridgeMac::Display(
     NotificationCommon::Type notification_type,
     const std::string& notification_id,
     const std::string& profile_id,
     bool incognito,
     const Notification& notification) {
   base::scoped_nsobject<NotificationBuilder> builder(
@@ skipping 20 matching lines @@
     NSString* buttonOne = SysUTF16ToNSString(buttons[0].title);
     NSString* buttonTwo = nullptr;
     if (buttons.size() > 1)
       buttonTwo = SysUTF16ToNSString(buttons[1].title);
     [builder setButtons:buttonOne secondaryButton:buttonTwo];
   }
 
   // Tag
   if (!notification.tag().empty()) {
     [builder setTag:base::SysUTF8ToNSString(notification.tag())];
+
     // If renotify is needed, delete the notification with the same tag
     // from the notification center before displaying this one.
     // TODO(miguelg): This will need to work for alerts as well via XPC
     // once supported.
     if (notification.renotify()) {
       NSUserNotificationCenter* notification_center =
           [NSUserNotificationCenter defaultUserNotificationCenter];
       for (NSUserNotification* existing_notification in
            [notification_center deliveredNotifications]) {
         NSString* identifier =
             [existing_notification valueForKey:@"identifier"];
         if ([identifier
                 isEqualToString:base::SysUTF8ToNSString(notification.tag())]) {
           [notification_center
               removeDeliveredNotification:existing_notification];
           break;
         }
       }
     }
   }
 
   [builder setOrigin:base::SysUTF8ToNSString(notification.origin_url().spec())];
   [builder setNotificationId:base::SysUTF8ToNSString(notification_id)];
   [builder setProfileId:base::SysUTF8ToNSString(profile_id)];
   [builder setIncognito:incognito];
   [builder setNotificationType:[NSNumber numberWithInteger:notification_type]];
 
+#if BUILDFLAG(ENABLE_XPC_NOTIFICATIONS)
+  // Send persistent notifications to the XPC service so they
+  // can be displayed as alerts. Chrome itself can only display
+  // banners.
+  if (notification.never_timeout()) {
+    NSDictionary* dict = [builder buildDictionary];
+    [notification_remote_dispatcher_ dispatchNotification:dict];
+  } else {
+    NSUserNotification* toast = [builder buildUserNotification];
+    [notification_center_ deliverNotification:toast];
+  }
+#else
   NSUserNotification* toast = [builder buildUserNotification];
   [notification_center_ deliverNotification:toast];
+#endif  // ENABLE_XPC_NOTIFICATIONS
 }
 
 void NotificationPlatformBridgeMac::Close(const std::string& profile_id,
                                           const std::string& notification_id) {
   NSString* candidate_id = base::SysUTF8ToNSString(notification_id);
 
   NSString* current_profile_id = base::SysUTF8ToNSString(profile_id);
   for (NSUserNotification* toast in
        [notification_center_ deliveredNotifications]) {
     NSString* toast_id =
@@ skipping 26 matching lines @@
     }
   }
   return true;
 }
 
 bool NotificationPlatformBridgeMac::SupportsNotificationCenter() const {
   return true;
 }
 
 // static
+void NotificationPlatformBridgeMac::ProcessNotificationResponse(
+    NSDictionary* response) {
+  if (!NotificationPlatformBridgeMac::VerifyNotificationData(response))
+    return;
+
+  NSNumber* button_index =
+      [response objectForKey:notification_constants::kNotificationButtonIndex];
+  NSNumber* operation =
+      [response objectForKey:notification_constants::kNotificationOperation];
+
+  std::string notification_origin = base::SysNSStringToUTF8(
+      [response objectForKey:notification_constants::kNotificationOrigin]);
+  std::string notification_id = base::SysNSStringToUTF8(
+      [response objectForKey:notification_constants::kNotificationId]);
+  std::string profile_id = base::SysNSStringToUTF8(
+      [response objectForKey:notification_constants::kNotificationProfileId]);
+  NSNumber* is_incognito =
+      [response objectForKey:notification_constants::kNotificationIncognito];
+  NSNumber* notification_type =
+      [response objectForKey:notification_constants::kNotificationType];
+
+  content::BrowserThread::PostTask(
+      content::BrowserThread::UI, FROM_HERE,
+      base::Bind(DoProcessNotificationResponse,
+                 static_cast<NotificationCommon::Operation>(
+                     operation.unsignedIntValue),
+                 static_cast<NotificationCommon::Type>(
+                     notification_type.unsignedIntValue),
+                 profile_id, [is_incognito boolValue], notification_origin,
+                 notification_id, button_index.intValue));
+}
+
+// static
 bool NotificationPlatformBridgeMac::VerifyNotificationData(
     NSDictionary* response) {
   if (![response
           objectForKey:notification_constants::kNotificationButtonIndex] ||
       ![response objectForKey:notification_constants::kNotificationOperation] ||
       ![response objectForKey:notification_constants::kNotificationId] ||
       ![response objectForKey:notification_constants::kNotificationProfileId] ||
       ![response objectForKey:notification_constants::kNotificationIncognito] ||
       ![response objectForKey:notification_constants::kNotificationType]) {
     LOG(ERROR) << "Missing required key";
@@ skipping 48 matching lines @@
     std::string notificationOrigin = base::SysNSStringToUTF8(origin);
     GURL url(notificationOrigin);
     if (!url.is_valid())
       return false;
   }
 
   return true;
 }
 
 // /////////////////////////////////////////////////////////////////////////////
-
 @implementation NotificationCenterDelegate
 - (void)userNotificationCenter:(NSUserNotificationCenter*)center
        didActivateNotification:(NSUserNotification*)notification {
-  NSDictionary* response =
+  NSDictionary* notificationResponse =
       [NotificationResponseBuilder buildDictionary:notification];
-  if (!NotificationPlatformBridgeMac::VerifyNotificationData(response))
-    return;
-
-  NSNumber* buttonIndex =
-      [response objectForKey:notification_constants::kNotificationButtonIndex];
-  NSNumber* operation =
-      [response objectForKey:notification_constants::kNotificationOperation];
-
-  std::string notificationOrigin = base::SysNSStringToUTF8(
-      [response objectForKey:notification_constants::kNotificationOrigin]);
-  NSString* notificationId =
-      [response objectForKey:notification_constants::kNotificationId];
-  std::string persistentNotificationId =
-      base::SysNSStringToUTF8(notificationId);
-  std::string profileId = base::SysNSStringToUTF8(
-      [response objectForKey:notification_constants::kNotificationProfileId]);
-  NSNumber* isIncognito =
-      [response objectForKey:notification_constants::kNotificationIncognito];
-  NSNumber* notificationType =
-      [response objectForKey:notification_constants::kNotificationType];
-
-  ProfileManager* profileManager = g_browser_process->profile_manager();
-  DCHECK(profileManager);
-
-  profileManager->LoadProfile(
-      profileId, [isIncognito boolValue],
-      base::Bind(
-          &ProfileLoadedCallback, static_cast<NotificationCommon::Operation>(
-                                      operation.unsignedIntValue),
-          static_cast<NotificationCommon::Type>(
-              notificationType.unsignedIntValue),
-          notificationOrigin, persistentNotificationId, buttonIndex.intValue));
+  NotificationPlatformBridgeMac::ProcessNotificationResponse(
+      notificationResponse);
 }
 
 - (BOOL)userNotificationCenter:(NSUserNotificationCenter*)center
      shouldPresentNotification:(NSUserNotification*)nsNotification {
   // Always display notifications, regardless of whether the app is foreground.
   return YES;
 }
 
 @end
+
+@implementation NotificationRemoteDispatcher {
+  // The connection to the XPC server in charge of delivering alerts.
+  base::scoped_nsobject<NSXPCConnection> xpcConnection_;
+}
+
+- (instancetype)init {
+  if ((self = [super init])) {
+    xpcConnection_.reset([[NSXPCConnection alloc]
+        initWithServiceName:
+            [NSString
+                stringWithFormat:notification_constants::kAlertXPCServiceName,
+                                 [base::mac::OuterBundle() bundleIdentifier]]]);
+    xpcConnection_.get().remoteObjectInterface =
+        [NSXPCInterface interfaceWithProtocol:@protocol(NotificationDelivery)];
+
+    xpcConnection_.get().interruptionHandler = ^{
+      LOG(WARNING) << "connection interrupted: interruptionHandler: ";
+      // TODO(miguelg): perhaps add some UMA here.
+      // We will be getting this handler both when the XPC server crashes or
+      // when it decides to close the connection.
+    };
+    xpcConnection_.get().invalidationHandler = ^{
+      LOG(WARNING) << "connection invalidationHandler received";
+      // This means that the connection should be recreated if it needs
+      // to be used again. It should not really happen.
+      DCHECK(false) << "XPC Connection invalidated";
+    };
+
+    xpcConnection_.get().exportedInterface =
+        [NSXPCInterface interfaceWithProtocol:@protocol(NotificationReply)];
+    xpcConnection_.get().exportedObject = self;
+    [xpcConnection_ resume];
+  }
+
+  return self;
+}
+
+- (void)dispatchNotification:(NSDictionary*)data {
+  [[xpcConnection_ remoteObjectProxy] deliverNotification:data];
+}
+
+// NotificationReply implementation
+- (void)notificationClick:(NSDictionary*)notificationResponseData {
+  NotificationPlatformBridgeMac::ProcessNotificationResponse(
+      notificationResponseData);
+}
+
+@end