refactor: rename the atom directory to shell

shell/browser/notifications/mac/cocoa_notification.h

@@ -0,0 +1,49 @@
+// Copyright (c) 2015 GitHub, Inc.
+// Use of this source code is governed by the MIT license that can be
+// found in the LICENSE file.
+
+#ifndef ATOM_BROWSER_NOTIFICATIONS_MAC_COCOA_NOTIFICATION_H_
+#define ATOM_BROWSER_NOTIFICATIONS_MAC_COCOA_NOTIFICATION_H_
+
+#import <Foundation/Foundation.h>
+
+#include <map>
+#include <string>
+#include <vector>
+
+#include "atom/browser/notifications/notification.h"
+#include "base/mac/scoped_nsobject.h"
+
+namespace atom {
+
+class CocoaNotification : public Notification {
+ public:
+  CocoaNotification(NotificationDelegate* delegate,
+                    NotificationPresenter* presenter);
+  ~CocoaNotification() override;
+
+  // Notification:
+  void Show(const NotificationOptions& options) override;
+  void Dismiss() override;
+
+  void NotificationDisplayed();
+  void NotificationReplied(const std::string& reply);
+  void NotificationActivated();
+  void NotificationActivated(NSUserNotificationAction* action);
+  void NotificationDismissed();
+
+  NSUserNotification* notification() const { return notification_; }
+
+ private:
+  void LogAction(const char* action);
+
+  base::scoped_nsobject<NSUserNotification> notification_;
+  std::map<std::string, unsigned> additional_action_indices_;
+  unsigned action_index_;
+
+  DISALLOW_COPY_AND_ASSIGN(CocoaNotification);
+};
+
+}  // namespace atom
+
+#endif  // ATOM_BROWSER_NOTIFICATIONS_MAC_COCOA_NOTIFICATION_H_

shell/browser/notifications/mac/cocoa_notification.mm

@@ -0,0 +1,173 @@
+// Copyright (c) 2015 GitHub, Inc.
+// Use of this source code is governed by the MIT license that can be
+// found in the LICENSE file.
+
+#include "atom/browser/notifications/mac/cocoa_notification.h"
+
+#include <string>
+#include <utility>
+
+#include "atom/browser/notifications/notification_delegate.h"
+#include "atom/browser/notifications/notification_presenter.h"
+#include "base/mac/mac_util.h"
+#include "base/strings/sys_string_conversions.h"
+#include "base/strings/utf_string_conversions.h"
+#include "skia/ext/skia_utils_mac.h"
+
+namespace atom {
+
+CocoaNotification::CocoaNotification(NotificationDelegate* delegate,
+                                     NotificationPresenter* presenter)
+    : Notification(delegate, presenter) {}
+
+CocoaNotification::~CocoaNotification() {
+  if (notification_)
+    [NSUserNotificationCenter.defaultUserNotificationCenter
+        removeDeliveredNotification:notification_];
+}
+
+void CocoaNotification::Show(const NotificationOptions& options) {
+  notification_.reset([[NSUserNotification alloc] init]);
+
+  NSString* identifier =
+      [NSString stringWithFormat:@"%@:notification:%@",
+                                 [[NSBundle mainBundle] bundleIdentifier],
+                                 [[[NSUUID alloc] init] UUIDString]];
+
+  [notification_ setTitle:base::SysUTF16ToNSString(options.title)];
+  [notification_ setSubtitle:base::SysUTF16ToNSString(options.subtitle)];
+  [notification_ setInformativeText:base::SysUTF16ToNSString(options.msg)];
+  [notification_ setIdentifier:identifier];
+
+  if (getenv("ELECTRON_DEBUG_NOTIFICATIONS")) {
+    LOG(INFO) << "Notification created (" << [identifier UTF8String] << ")";
+  }
+
+  if (!options.icon.drawsNothing()) {
+    NSImage* image = skia::SkBitmapToNSImageWithColorSpace(
+        options.icon, base::mac::GetGenericRGBColorSpace());
+    [notification_ setContentImage:image];
+  }
+
+  if (options.silent) {
+    [notification_ setSoundName:nil];
+  } else if (options.sound.empty()) {
+    [notification_ setSoundName:NSUserNotificationDefaultSoundName];
+  } else {
+    [notification_ setSoundName:base::SysUTF16ToNSString(options.sound)];
+  }
+
+  [notification_ setHasActionButton:false];
+
+  int i = 0;
+  action_index_ = UINT_MAX;
+  NSMutableArray* additionalActions =
+      [[[NSMutableArray alloc] init] autorelease];
+  for (const auto& action : options.actions) {
+    if (action.type == base::ASCIIToUTF16("button")) {
+      if (action_index_ == UINT_MAX) {
+        // First button observed is the displayed action
+        [notification_ setHasActionButton:true];
+        [notification_
+            setActionButtonTitle:base::SysUTF16ToNSString(action.text)];
+        action_index_ = i;
+      } else {
+        // All of the rest are appended to the list of additional actions
+        NSString* actionIdentifier =
+            [NSString stringWithFormat:@"%@Action%d", identifier, i];
+        NSUserNotificationAction* notificationAction = [NSUserNotificationAction
+            actionWithIdentifier:actionIdentifier
+                           title:base::SysUTF16ToNSString(action.text)];
+        [additionalActions addObject:notificationAction];
+        additional_action_indices_.insert(
+            std::make_pair(base::SysNSStringToUTF8(actionIdentifier), i));
+      }
+    }
+    i++;
+  }
+  if ([additionalActions count] > 0) {
+    [notification_ setAdditionalActions:additionalActions];
+  }
+
+  if (options.has_reply) {
+    [notification_ setResponsePlaceholder:base::SysUTF16ToNSString(
+                                              options.reply_placeholder)];
+    [notification_ setHasReplyButton:true];
+  }
+
+  if (!options.close_button_text.empty()) {
+    [notification_ setOtherButtonTitle:base::SysUTF16ToNSString(
+                                           options.close_button_text)];
+  }
+
+  [NSUserNotificationCenter.defaultUserNotificationCenter
+      deliverNotification:notification_];
+}
+
+void CocoaNotification::Dismiss() {
+  if (notification_)
+    [NSUserNotificationCenter.defaultUserNotificationCenter
+        removeDeliveredNotification:notification_];
+
+  NotificationDismissed();
+
+  this->LogAction("dismissed");
+
+  notification_.reset(nil);
+}
+
+void CocoaNotification::NotificationDisplayed() {
+  if (delegate())
+    delegate()->NotificationDisplayed();
+
+  this->LogAction("displayed");
+}
+
+void CocoaNotification::NotificationReplied(const std::string& reply) {
+  if (delegate())
+    delegate()->NotificationReplied(reply);
+
+  this->LogAction("replied to");
+}
+
+void CocoaNotification::NotificationActivated() {
+  if (delegate())
+    delegate()->NotificationAction(action_index_);
+
+  this->LogAction("button clicked");
+}
+
+void CocoaNotification::NotificationActivated(
+    NSUserNotificationAction* action) {
+  if (delegate()) {
+    unsigned index = action_index_;
+    std::string identifier = base::SysNSStringToUTF8(action.identifier);
+    for (const auto& it : additional_action_indices_) {
+      if (it.first == identifier) {
+        index = it.second;
+        break;
+      }
+    }
+
+    delegate()->NotificationAction(index);
+  }
+
+  this->LogAction("button clicked");
+}
+
+void CocoaNotification::NotificationDismissed() {
+  if (delegate())
+    delegate()->NotificationClosed();
+
+  this->LogAction("dismissed");
+}
+
+void CocoaNotification::LogAction(const char* action) {
+  if (getenv("ELECTRON_DEBUG_NOTIFICATIONS")) {
+    NSString* identifier = [notification_ valueForKey:@"identifier"];
+    LOG(INFO) << "Notification " << action << " (" << [identifier UTF8String]
+              << ")";
+  }
+}
+
+}  // namespace atom

shell/browser/notifications/mac/notification_center_delegate.h

@@ -0,0 +1,22 @@
+// Copyright (c) 2015 GitHub, Inc.
+// Use of this source code is governed by the MIT license that can be
+// found in the LICENSE file.
+
+#ifndef ATOM_BROWSER_NOTIFICATIONS_MAC_NOTIFICATION_CENTER_DELEGATE_H_
+#define ATOM_BROWSER_NOTIFICATIONS_MAC_NOTIFICATION_CENTER_DELEGATE_H_
+
+#import <Foundation/Foundation.h>
+
+namespace atom {
+class NotificationPresenterMac;
+}
+
+@interface NotificationCenterDelegate
+    : NSObject <NSUserNotificationCenterDelegate> {
+ @private
+  atom::NotificationPresenterMac* presenter_;
+}
+- (instancetype)initWithPresenter:(atom::NotificationPresenterMac*)presenter;
+@end
+
+#endif  // ATOM_BROWSER_NOTIFICATIONS_MAC_NOTIFICATION_CENTER_DELEGATE_H_

shell/browser/notifications/mac/notification_center_delegate.mm

@@ -0,0 +1,90 @@
+// Copyright (c) 2015 GitHub, Inc.
+// Use of this source code is governed by the MIT license that can be
+// found in the LICENSE file.
+
+#include "atom/browser/notifications/mac/notification_center_delegate.h"
+
+#include <string>
+
+#include "atom/browser/notifications/mac/cocoa_notification.h"
+#include "atom/browser/notifications/mac/notification_presenter_mac.h"
+
+@implementation NotificationCenterDelegate
+
+- (instancetype)initWithPresenter:(atom::NotificationPresenterMac*)presenter {
+  self = [super init];
+  if (!self)
+    return nil;
+
+  presenter_ = presenter;
+  return self;
+}
+
+- (void)userNotificationCenter:(NSUserNotificationCenter*)center
+        didDeliverNotification:(NSUserNotification*)notif {
+  auto* notification = presenter_->GetNotification(notif);
+  if (notification)
+    notification->NotificationDisplayed();
+}
+
+- (void)userNotificationCenter:(NSUserNotificationCenter*)center
+       didActivateNotification:(NSUserNotification*)notif {
+  auto* notification = presenter_->GetNotification(notif);
+
+  if (getenv("ELECTRON_DEBUG_NOTIFICATIONS")) {
+    LOG(INFO) << "Notification activated (" << [notif.identifier UTF8String]
+              << ")";
+  }
+
+  if (notification) {
+    // Ref:
+    // https://developer.apple.com/documentation/foundation/nsusernotificationactivationtype?language=objc
+    if (notif.activationType ==
+        NSUserNotificationActivationTypeContentsClicked) {
+      notification->NotificationClicked();
+    } else if (notif.activationType ==
+               NSUserNotificationActivationTypeActionButtonClicked) {
+      notification->NotificationActivated();
+    } else if (notif.activationType ==
+               NSUserNotificationActivationTypeReplied) {
+      notification->NotificationReplied([notif.response.string UTF8String]);
+    } else {
+      if (notif.activationType ==
+          NSUserNotificationActivationTypeAdditionalActionClicked) {
+        notification->NotificationActivated([notif additionalActivationAction]);
+      }
+    }
+  }
+}
+
+- (BOOL)userNotificationCenter:(NSUserNotificationCenter*)center
+     shouldPresentNotification:(NSUserNotification*)notification {
+  // Display notifications even if the app is active.
+  return YES;
+}
+
+#if !defined(MAS_BUILD)
+// This undocumented method notifies us if a user closes "Alert" notifications
+// https://chromium.googlesource.com/chromium/src/+/lkgr/chrome/browser/notifications/notification_platform_bridge_mac.mm
+- (void)userNotificationCenter:(NSUserNotificationCenter*)center
+               didDismissAlert:(NSUserNotification*)notif {
+  auto* notification = presenter_->GetNotification(notif);
+  if (notification)
+    notification->NotificationDismissed();
+}
+#endif
+
+#if !defined(MAS_BUILD)
+// This undocumented method notifies us if a user closes "Banner" notifications
+// https://github.com/mozilla/gecko-dev/blob/master/widget/cocoa/OSXNotificationCenter.mm
+- (void)userNotificationCenter:(NSUserNotificationCenter*)center
+    didRemoveDeliveredNotifications:(NSArray*)notifications {
+  for (NSUserNotification* notif in notifications) {
+    auto* notification = presenter_->GetNotification(notif);
+    if (notification)
+      notification->NotificationDismissed();
+  }
+}
+#endif
+
+@end

shell/browser/notifications/mac/notification_presenter_mac.h

@@ -0,0 +1,36 @@
+// Copyright (c) 2012 The Chromium Authors. All rights reserved.
+// Copyright (c) 2013 Adam Roben <adam@roben.org>. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE-CHROMIUM file.
+
+#ifndef ATOM_BROWSER_NOTIFICATIONS_MAC_NOTIFICATION_PRESENTER_MAC_H_
+#define ATOM_BROWSER_NOTIFICATIONS_MAC_NOTIFICATION_PRESENTER_MAC_H_
+
+#include "atom/browser/notifications/mac/notification_center_delegate.h"
+#include "atom/browser/notifications/notification_presenter.h"
+#include "base/mac/scoped_nsobject.h"
+
+namespace atom {
+
+class CocoaNotification;
+
+class NotificationPresenterMac : public NotificationPresenter {
+ public:
+  CocoaNotification* GetNotification(NSUserNotification* notif);
+
+  NotificationPresenterMac();
+  ~NotificationPresenterMac() override;
+
+ private:
+  Notification* CreateNotificationObject(
+      NotificationDelegate* delegate) override;
+
+  base::scoped_nsobject<NotificationCenterDelegate>
+      notification_center_delegate_;
+
+  DISALLOW_COPY_AND_ASSIGN(NotificationPresenterMac);
+};
+
+}  // namespace atom
+
+#endif  // ATOM_BROWSER_NOTIFICATIONS_MAC_NOTIFICATION_PRESENTER_MAC_H_

shell/browser/notifications/mac/notification_presenter_mac.mm

@@ -0,0 +1,50 @@
+// Copyright (c) 2015 GitHub, Inc.
+// Use of this source code is governed by the MIT license that can be
+// found in the LICENSE file.
+
+#include "atom/browser/notifications/mac/notification_presenter_mac.h"
+
+#include "atom/browser/notifications/mac/cocoa_notification.h"
+#include "atom/browser/notifications/mac/notification_center_delegate.h"
+
+namespace atom {
+
+// static
+NotificationPresenter* NotificationPresenter::Create() {
+  return new NotificationPresenterMac;
+}
+
+CocoaNotification* NotificationPresenterMac::GetNotification(
+    NSUserNotification* ns_notification) {
+  for (Notification* notification : notifications()) {
+    auto* native_notification = static_cast<CocoaNotification*>(notification);
+    if ([native_notification->notification().identifier
+            isEqual:ns_notification.identifier])
+      return native_notification;
+  }
+
+  if (getenv("ELECTRON_DEBUG_NOTIFICATIONS")) {
+    LOG(INFO) << "Could not find notification for "
+              << [ns_notification.identifier UTF8String];
+  }
+
+  return nullptr;
+}
+
+NotificationPresenterMac::NotificationPresenterMac()
+    : notification_center_delegate_(
+          [[NotificationCenterDelegate alloc] initWithPresenter:this]) {
+  NSUserNotificationCenter.defaultUserNotificationCenter.delegate =
+      notification_center_delegate_;
+}
+
+NotificationPresenterMac::~NotificationPresenterMac() {
+  NSUserNotificationCenter.defaultUserNotificationCenter.delegate = nil;
+}
+
+Notification* NotificationPresenterMac::CreateNotificationObject(
+    NotificationDelegate* delegate) {
+  return new CocoaNotification(delegate, this);
+}
+
+}  // namespace atom