Notification should not leak document.

Source/modules/notifications/Notification.cpp

 /*
  * Copyright (C) 2009 Google Inc. All rights reserved.
  * Copyright (C) 2009, 2011, 2012 Apple 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.
@@ skipping 37 matching lines @@
 #include "core/workers/WorkerGlobalScope.h"
 #include "modules/notifications/DOMWindowNotifications.h"
 #include "modules/notifications/NotificationCenter.h"
 #include "modules/notifications/NotificationClient.h"
 #include "modules/notifications/NotificationController.h"
 #include "modules/notifications/NotificationPermissionCallback.h"
 
 namespace WebCore {
 
 Notification::Notification()
-    : ActiveDOMObject(0)
+    : ContextLifecycleObserver(0)
 {
     ScriptWrappable::init(this);
 }
 
 #if ENABLE(LEGACY_NOTIFICATIONS)
 Notification::Notification(const String& title, const String& body, const String& iconURI, ScriptExecutionContext* context, ExceptionState& es, PassRefPtr<NotificationCenter> provider)
-    : ActiveDOMObject(context)
+    : ContextLifecycleObserver(context)
     , m_title(title)
     , m_body(body)
     , m_state(Idle)
     , m_notificationCenter(provider)
 {
     ScriptWrappable::init(this);
     if (m_notificationCenter->checkPermission() != NotificationClient::PermissionAllowed) {
         es.throwDOMException(SecurityError);
         return;
     }
 
     m_icon = iconURI.isEmpty() ? KURL() : scriptExecutionContext()->completeURL(iconURI);
     if (!m_icon.isEmpty() && !m_icon.isValid()) {
         es.throwDOMException(SyntaxError);
         return;
     }
 }
 #endif
 
 #if ENABLE(NOTIFICATIONS)
 Notification::Notification(ScriptExecutionContext* context, const String& title)
-    : ActiveDOMObject(context)
+    : ContextLifecycleObserver(context)
     , m_title(title)
     , m_state(Idle)
     , m_taskTimer(adoptPtr(new Timer<Notification>(this, &Notification::taskTimerFired)))
 {
     ScriptWrappable::init(this);
     m_notificationCenter = DOMWindowNotifications::webkitNotifications(toDocument(context)->domWindow());
 
     ASSERT(m_notificationCenter->client());
     m_taskTimer->startOneShot(0);
 }
 #endif
 
 Notification::~Notification()
 {
 }
 
 #if ENABLE(LEGACY_NOTIFICATIONS)
 PassRefPtr<Notification> Notification::create(const String& title, const String& body, const String& iconURI, ScriptExecutionContext* context, ExceptionState& es, PassRefPtr<NotificationCenter> provider)
 {
     RefPtr<Notification> notification(adoptRef(new Notification(title, body, iconURI, context, es, provider)));
-    notification->suspendIfNeeded();
     return notification.release();
 }
 #endif
 
 #if ENABLE(NOTIFICATIONS)
 PassRefPtr<Notification> Notification::create(ScriptExecutionContext* context, const String& title, const Dictionary& options)
 {
     RefPtr<Notification> notification(adoptRef(new Notification(context, title)));
     String argument;
     if (options.get("body", argument))
         notification->setBody(argument);
     if (options.get("tag", argument))
         notification->setTag(argument);
     if (options.get("lang", argument))
         notification->setLang(argument);
     if (options.get("dir", argument))
         notification->setDir(argument);
     if (options.get("icon", argument)) {
         KURL iconURI = argument.isEmpty() ? KURL() : context->completeURL(argument);
         if (!iconURI.isEmpty() && iconURI.isValid())
             notification->setIconURL(iconURI);
     }
 
-    notification->suspendIfNeeded();
     return notification.release();
 }
 #endif
 
 const AtomicString& Notification::interfaceName() const
 {
     return eventNames().interfaceForNotification;
 }
 
 void Notification::show()
 {
     // prevent double-showing
     if (m_state == Idle && m_notificationCenter->client()) {
 #if ENABLE(NOTIFICATIONS)
         if (!toDocument(scriptExecutionContext())->page())
             return;
         if (NotificationController::from(toDocument(scriptExecutionContext())->page())->client()->checkPermission(scriptExecutionContext()) != NotificationClient::PermissionAllowed) {
             dispatchErrorEvent();
             return;
         }
 #endif
         if (m_notificationCenter->client()->show(this)) {
             m_state = Showing;
-            setPendingActivity(this);
         }
     }
 }
 
 void Notification::close()
 {
     switch (m_state) {
     case Idle:
         break;
     case Showing:
@@ skipping 10 matching lines @@
     return &m_eventTargetData;
 }
 
 EventTargetData* Notification::ensureEventTargetData()
 {
     return &m_eventTargetData;
 }
 
 void Notification::contextDestroyed()
 {
-    ActiveDOMObject::contextDestroyed();
+    ContextLifecycleObserver::contextDestroyed();
     if (m_notificationCenter->client())
         m_notificationCenter->client()->notificationObjectDestroyed(this);
 }
 
-void Notification::finalize()
-{
-    if (m_state == Closed)
-        return;
-    m_state = Closed;
-    unsetPendingActivity(this);
-}
-
 void Notification::dispatchShowEvent()
 {
+#if ENABLE(LEGACY_NOTIFICATIONS)
+    dispatchEvent(Event::create(eventNames().displayEvent, false, false));
+#endif
     dispatchEvent(Event::create(eventNames().showEvent, false, false));
 }
 
 void Notification::dispatchClickEvent()
 {
+    UserGestureIndicator gestureIndicator(DefinitelyProcessingNewUserGesture);
     WindowFocusAllowedIndicator windowFocusAllowed;
     dispatchEvent(Event::create(eventNames().clickEvent, false, false));
 }
 
 void Notification::dispatchCloseEvent()
 {
     dispatchEvent(Event::create(eventNames().closeEvent, false, false));
-    finalize();
+    m_state = Closed;
 }
 
 void Notification::dispatchErrorEvent()
 {
     dispatchEvent(Event::create(eventNames().errorEvent, false, false));
 }
 
 #if ENABLE(NOTIFICATIONS)
 void Notification::taskTimerFired(Timer<Notification>* timer)
 {
@@ skipping 33 matching lines @@
 void Notification::requestPermission(ScriptExecutionContext* context, PassRefPtr<NotificationPermissionCallback> callback)
 {
     ASSERT(toDocument(context)->page());
     NotificationController::from(toDocument(context)->page())->client()->requestPermission(context, callback);
 }
 #endif
 
 } // namespace WebCore
 
 #endif // ENABLE(NOTIFICATIONS) || ENABLE(LEGACY_NOTIFICATIONS)