[WIP] Implement Notifications through Platform instead of WebFrame.

Source/modules/notifications/Notification.cpp

 /*
  * Copyright (C) 2013 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 17 matching lines @@
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 #include "config.h"
 #include "modules/notifications/Notification.h"
 
 #include "bindings/core/v8/ScriptWrappable.h"
 #include "core/dom/Document.h"
 #include "core/events/Event.h"
 #include "core/page/WindowFocusAllowedIndicator.h"
-#include "modules/notifications/NotificationClient.h"
-#include "modules/notifications/NotificationController.h"
 #include "modules/notifications/NotificationOptions.h"
 #include "modules/notifications/NotificationPermissionClient.h"
+#include "public/platform/Platform.h"
+#include "public/platform/WebNotificationData.h"
+#include "public/platform/WebNotificationManager.h"
+#include "public/platform/WebSerializedOrigin.h"
 
 namespace blink {
 
+namespace {
+
+WebNotificationManager* notificationManager()
+{
+    return Platform::current()->notificationManager();
+}
+
+} // namespace
+
 Notification* Notification::create(ExecutionContext* context, const String& title, const NotificationOptions& options)
 {
-    NotificationClient& client = NotificationController::clientFrom(context);
-    Notification* notification = adoptRefCountedGarbageCollectedWillBeNoop(new Notification(title, context, &client));
+    Notification* notification = adoptRefCountedGarbageCollectedWillBeNoop(new Notification(title, context));
 
     notification->setBody(options.body());
     notification->setTag(options.tag());
     notification->setLang(options.lang());
     notification->setDir(options.dir());
     if (options.hasIcon()) {
         KURL iconUrl = options.icon().isEmpty() ? KURL() : context->completeURL(options.icon());
         if (!iconUrl.isEmpty() && iconUrl.isValid())
             notification->setIconUrl(iconUrl);
     }
 
     notification->suspendIfNeeded();
     return notification;
 }
 
-Notification::Notification(const String& title, ExecutionContext* context, NotificationClient* client)
+Notification::Notification(const String& title, ExecutionContext* context)
     : ActiveDOMObject(context)
     , m_title(title)
     , m_dir("auto")
     , m_state(NotificationStateIdle)
-    , m_client(client)
     , m_asyncRunner(this, &Notification::show)
 {
-    ASSERT(m_client);
+    ASSERT(notificationManager());
 
     m_asyncRunner.runAsync();
 }
 
 Notification::~Notification()
 {
 }
 
 void Notification::show()
 {
     ASSERT(m_state == NotificationStateIdle);
-    if (!toDocument(executionContext())->page())
-        return;
-
-    if (m_client->checkPermission(executionContext()) != NotificationClient::PermissionAllowed) {
+    if (Notification::checkPermission(executionContext()) != WebNotificationPermissionAllowed) {
         dispatchErrorEvent();
         return;
     }
 
-    if (m_client->show(this))
+    SecurityOrigin* origin = executionContext()->securityOrigin();
+    ASSERT(origin);
+
+    // TODO(peter): We should set the correct direction as part of this call.
+    WebNotificationData notificationData(m_title, WebNotificationData::DirectionLeftToRight, m_lang, m_body, m_tag, m_iconUrl);
+    if (notificationManager()->show(WebSerializedOrigin(*origin), notificationData, this))
         m_state = NotificationStateShowing;
 }
 
 void Notification::close()
 {
     switch (m_state) {
     case NotificationStateIdle:
         break;
     case NotificationStateShowing:
-        m_client->close(this);
+        notificationManager()->close(this);
         break;
     case NotificationStateClosed:
         break;
     }
 }
 
 void Notification::dispatchShowEvent()
 {
     dispatchEvent(Event::create(EventTypeNames::show));
 }
 
 void Notification::dispatchClickEvent()
 {
     UserGestureIndicator gestureIndicator(DefinitelyProcessingNewUserGesture);
     WindowFocusAllowedIndicator windowFocusAllowed;
+
     dispatchEvent(Event::create(EventTypeNames::click));
 }
 
 void Notification::dispatchErrorEvent()
 {
     dispatchEvent(Event::create(EventTypeNames::error));
 }
 
 void Notification::dispatchCloseEvent()
 {
     dispatchEvent(Event::create(EventTypeNames::close));
     m_state = NotificationStateClosed;
 }
 
 TextDirection Notification::direction() const
 {
     // FIXME: Resolve dir()=="auto" against the document.
     return dir() == "rtl" ? RTL : LTR;
 }
 
-const String& Notification::permissionString(NotificationClient::Permission permission)
+const String& Notification::permissionString(WebNotificationPermission permission)
 {
     DEFINE_STATIC_LOCAL(const String, allowedPermission, ("granted"));
     DEFINE_STATIC_LOCAL(const String, deniedPermission, ("denied"));
     DEFINE_STATIC_LOCAL(const String, defaultPermission, ("default"));
 
     switch (permission) {
-    case NotificationClient::PermissionAllowed:
+    case WebNotificationPermissionAllowed:
         return allowedPermission;
-    case NotificationClient::PermissionDenied:
+    case WebNotificationPermissionDenied:
         return deniedPermission;
-    case NotificationClient::PermissionNotAllowed:
+    case WebNotificationPermissionDefault:
         return defaultPermission;
     }
 
     ASSERT_NOT_REACHED();
     return deniedPermission;
 }
 
 const String& Notification::permission(ExecutionContext* context)
 {
-    return permissionString(NotificationController::clientFrom(context).checkPermission(context));
+    return permissionString(checkPermission(context));
+}
+
+WebNotificationPermission Notification::checkPermission(ExecutionContext* context)
+{
+    SecurityOrigin* origin = context->securityOrigin();
+    ASSERT(origin);
+
+    return notificationManager()->checkPermission(WebSerializedOrigin(*origin));
 }
 
 void Notification::requestPermission(ExecutionContext* context, PassOwnPtrWillBeRawPtr<NotificationPermissionCallback> callback)
 {
-    // FIXME: Assert that this code-path will only be reached for Document environments
-    // when Blink supports [Exposed] annotations on class members in IDL definitions.
-    if (NotificationPermissionClient* permissionClient = NotificationPermissionClient::from(context)) {
+    ASSERT(context->isDocument());
+    if (NotificationPermissionClient* permissionClient = NotificationPermissionClient::from(context))
         permissionClient->requestPermission(context, callback);
-        return;
-    }
 }
 
 bool Notification::dispatchEvent(PassRefPtrWillBeRawPtr<Event> event)
 {
     ASSERT(m_state != NotificationStateClosed);
 
     return EventTarget::dispatchEvent(event);
 }
 
 const AtomicString& Notification::interfaceName() const
 {
     return EventTargetNames::Notification;
 }
 
 void Notification::stop()
 {
+    notificationManager()->notifyDelegateDestroyed(this);
+
     m_state = NotificationStateClosed;
-
-    if (m_client) {
-        m_client->notificationObjectDestroyed(this);
-        m_client = 0;
-    }
-
     m_asyncRunner.stop();
 }
 
 bool Notification::hasPendingActivity() const
 {
     return m_state == NotificationStateShowing || m_asyncRunner.isActive();
 }
 
 } // namespace blink