Introduce a new API to handle native notification clicks

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/mac/foundation_util.h"
 #include "base/mac/mac_util.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_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"
 #include "chrome/browser/ui/cocoa/notifications/notification_constants_mac.h"
 #import "chrome/browser/ui/cocoa/notifications/notification_response_builder_mac.h"
 #include "chrome/grit/generated_resources.h"
@@ skipping 15 matching lines @@
 // notification#icon in NSUserNotification.contentImage (10.9)
 // Site settings button is implemented as NSUserNotification's action button
 // Not possible to implement:
 // -notification.requireInteraction
 // -The event associated to the close button
 
 // TODO(miguelg) implement the following features
 // - Sound names can be implemented by setting soundName in NSUserNotification
 //   NSUserNotificationDefaultSoundName gives you the platform default.
 
+namespace {
+// Callback to run once the profile has been loaded in order to perform a
+// given |operation| in a notification.
+void ProfileLoadedCallback(
+    notification_operation_common::NotificationOperation operation,
+    notification_operation_common::NotificationHandlerType notification_type,
+    const std::string& origin,
+    const std::string& notification_id,
+    int action_index,
+    Profile* profile) {
+  if (!profile) {
+    // TODO(miguelg): Add UMA for this condition.
+    // Perhaps propagate this through PersistentNotificationStatus.
+    LOG(WARNING) << "Profile not loaded correctly";
+    return;
+  }
+
+  NotificationDisplayService* display_service =
+      NotificationDisplayServiceFactory::GetForProfile(profile);
+
+  static_cast<NativeNotificationDisplayService*>(display_service)
+      ->ProcessNotificationOperation(operation, notification_type, origin,
+                                     notification_id, action_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
@@ skipping 10 matching lines @@
   [notification_center_ setDelegate:delegate_.get()];
 }
 
 NotificationPlatformBridgeMac::~NotificationPlatformBridgeMac() {
   [notification_center_ setDelegate:nil];
 
   // TODO(miguelg) lift this restriction if possible.
   [notification_center_ removeAllDeliveredNotifications];
 }
 
-void NotificationPlatformBridgeMac::Display(const std::string& notification_id,
-                                            const std::string& profile_id,
-                                            bool incognito,
-                                            const Notification& notification) {
+void NotificationPlatformBridgeMac::Display(
+    notification_operation_common::NotificationHandlerType notification_type,
+    const std::string& notification_id,
+    const std::string& profile_id,
+    bool incognito,
+    const Notification& notification) {
   base::scoped_nsobject<NotificationBuilder> builder(
       [[NotificationBuilder alloc] init]);
 
   [builder setTitle:base::SysUTF16ToNSString(notification.title())];
   [builder setContextMessage:base::SysUTF16ToNSString(notification.message())];
 
   base::string16 subtitle =
       notification.context_message().empty()
           ? url_formatter::FormatOriginForSecurityDisplay(
                 url::Origin(notification.origin_url()),
@@ skipping 35 matching lines @@
           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]];
 
   NSUserNotification* toast = [builder buildUserNotification];
   [notification_center_ deliverNotification:toast];
 }
 
 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 =
         [toast.userInfo objectForKey:notification_constants::kNotificationId];
-
     NSString* persistent_profile_id = [toast.userInfo
         objectForKey:notification_constants::kNotificationProfileId];
 
-    if (toast_id == candidate_id &&
-        persistent_profile_id == current_profile_id) {
+    if ([toast_id isEqualToString:candidate_id] &&
+        [persistent_profile_id isEqualToString:current_profile_id]) {
       [notification_center_ removeDeliveredNotification:toast];
     }
   }
 }
 
 bool NotificationPlatformBridgeMac::GetDisplayed(
     const std::string& profile_id,
     bool incognito,
     std::set<std::string>* notifications) const {
   DCHECK(notifications);
 
   NSString* current_profile_id = base::SysUTF8ToNSString(profile_id);
   for (NSUserNotification* toast in
        [notification_center_ deliveredNotifications]) {
     NSString* toast_profile_id = [toast.userInfo
         objectForKey:notification_constants::kNotificationProfileId];
     if (toast_profile_id == current_profile_id) {
       notifications->insert(base::SysNSStringToUTF8([toast.userInfo
           objectForKey:notification_constants::kNotificationId]));
     }
   }
   return true;
 }
 
 bool NotificationPlatformBridgeMac::SupportsNotificationCenter() const {
   return true;
 }
 
+// static
+bool NotificationPlatformBridgeMac::VerifyNotificationData(
+    NSDictionary* response) {
+  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];
+  NSString* profileId =
+      [response objectForKey:notification_constants::kNotificationProfileId];
+  NSNumber* notificationType =
+      [response objectForKey:notification_constants::kNotificationType];
+
+  if (buttonIndex.intValue < -1 ||
+      buttonIndex.intValue >=
+          static_cast<int>(blink::kWebNotificationMaxActions)) {
+    LOG(ERROR) << "Invalid number of buttons supplied " << buttonIndex.intValue;
+    return false;
+  }
+
+  if (operation.unsignedIntValue >
+      notification_operation_common::NOTIFICATION_OPERATION_MAX) {
+    LOG(ERROR) << operation.unsignedIntValue
+               << " Does not correspond to a valid operation.";
+    return false;
+  }
+
+  if (notificationId.length <= 0) {
+    LOG(ERROR) << "NotificationId not provided";
+    return false;
+  }
+
+  if (profileId.length <= 0) {
+    LOG(ERROR) << "ProfileId not provided";
+    return false;
+  }
+
+  if (notificationType.unsignedIntValue >
+      notification_operation_common::NOTIFICATION_HANDLER_TYPE_LAST) {
+    LOG(ERROR) << notificationType.unsignedIntValue
+               << " Does not correspond to a valid operation.";
+    return false;
+  }
+
+  return true;
+}
+
 // /////////////////////////////////////////////////////////////////////////////
 
 @implementation NotificationCenterDelegate
 - (void)userNotificationCenter:(NSUserNotificationCenter*)center
        didActivateNotification:(NSUserNotification*)notification {
   NSDictionary* response =
       [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 = [notification.userInfo
-      objectForKey:notification_constants::kNotificationId];
+  NSString* notificationId =
+      [response objectForKey:notification_constants::kNotificationId];
   std::string persistentNotificationId =
       base::SysNSStringToUTF8(notificationId);
-  int64_t persistentId;
-  if (!base::StringToInt64(persistentNotificationId, &persistentId)) {
-    LOG(ERROR) << "Unable to convert notification ID: "
-               << persistentNotificationId << " to integer.";
-    return;
-  }
   std::string profileId = base::SysNSStringToUTF8(
       [response objectForKey:notification_constants::kNotificationProfileId]);
   NSNumber* isIncognito =
       [response objectForKey:notification_constants::kNotificationIncognito];
+  NSNumber* notificationType =
+      [response objectForKey:notification_constants::kNotificationType];
 
-  GURL origin(notificationOrigin);
+  ProfileManager* profileManager = g_browser_process->profile_manager();
+  DCHECK(profileManager);
 
-  PlatformNotificationServiceImpl::GetInstance()
-      ->ProcessPersistentNotificationOperation(
-          static_cast<PlatformNotificationServiceImpl::NotificationOperation>(
-              operation.intValue),
-          profileId, [isIncognito boolValue], origin, persistentId,
-          buttonIndex.intValue);
+  profileManager->LoadProfile(
+      profileId, [isIncognito boolValue],
+      base::Bind(
+          &ProfileLoadedCallback,
+          static_cast<notification_operation_common::NotificationOperation>(
+              operation.unsignedIntValue),
+          static_cast<notification_operation_common::NotificationHandlerType>(
+              notificationType.unsignedIntValue),
+          notificationOrigin, persistentNotificationId, buttonIndex.intValue));
 }
 
 - (BOOL)userNotificationCenter:(NSUserNotificationCenter*)center
      shouldPresentNotification:(NSUserNotification*)nsNotification {
   // Always display notifications, regardless of whether the app is foreground.
   return YES;
 }
 
 @end