Clean up the Notification class in advance of merging the Close methods

third_party/WebKit/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 82 matching lines @@
     } else {
         UseCounter::count(context, UseCounter::NotificationInsecureOrigin);
         if (context->isDocument())
             UseCounter::countCrossOriginIframe(*toDocument(context),  UseCounter::NotificationAPIInsecureOriginIframe);
     }
 
     WebNotificationData data = createWebNotificationData(context, title, options, exceptionState);
     if (exceptionState.hadException())
         return nullptr;
 
-    Notification* notification = new Notification(context, data);
+    Notification* notification = new Notification(context, Type::NonPersistent, data);
     notification->schedulePrepareShow();
+
     notification->suspendIfNeeded();
-
     return notification;
 }
 
 Notification* Notification::create(ExecutionContext* context, const String& notificationId, const WebNotificationData& data, bool showing)
 {
-    Notification* notification = new Notification(context, data);
+    Notification* notification = new Notification(context, Type::Persistent, data);
+    notification->setState(showing ? State::Showing : State::Closed);
     notification->setNotificationId(notificationId);
-    notification->setState(showing ? NotificationStateShowing : NotificationStateClosed);
+
     notification->suspendIfNeeded();
-
     return notification;
 }
 
-Notification::Notification(ExecutionContext* context, const WebNotificationData& data)
+Notification::Notification(ExecutionContext* context, Type type, const WebNotificationData& data)
     : ActiveScriptWrappable(this)
     , ActiveDOMObject(context)
+    , m_type(type)
+    , m_state(State::Loading)
     , m_data(data)
-    , m_state(NotificationStateIdle)
-    , m_prepareShowMethodRunner(AsyncMethodRunner<Notification>::create(this, &Notification::prepareShow))
 {
     DCHECK(notificationManager());
 }
 
 Notification::~Notification()
 {
 }
 
 void Notification::schedulePrepareShow()
 {
-    DCHECK_EQ(m_state, NotificationStateIdle);
-    DCHECK(!m_prepareShowMethodRunner->isActive());
+    DCHECK_EQ(m_state, State::Loading);
+    DCHECK(!m_prepareShowMethodRunner);
 
+    m_prepareShowMethodRunner = AsyncMethodRunner<Notification>::create(this, &Notification::prepareShow);
     m_prepareShowMethodRunner->runAsync();
 }
 
 void Notification::prepareShow()
 {
-    DCHECK_EQ(m_state, NotificationStateIdle);
+    DCHECK_EQ(m_state, State::Loading);
     if (NotificationManager::from(getExecutionContext())->permissionStatus() != mojom::blink::PermissionStatus::GRANTED) {
         dispatchErrorEvent();
         return;
     }
 
     m_loader = new NotificationResourcesLoader(WTF::bind(&Notification::didLoadResources, wrapWeakPersistent(this)));
     m_loader->start(getExecutionContext(), m_data);
 }
 
 void Notification::didLoadResources(NotificationResourcesLoader* loader)
 {
     DCHECK_EQ(loader, m_loader.get());
 
     SecurityOrigin* origin = getExecutionContext()->getSecurityOrigin();
     DCHECK(origin);
 
     notificationManager()->show(WebSecurityOrigin(origin), m_data, loader->getResources(), this);
     m_loader.clear();
 
-    m_state = NotificationStateShowing;
+    m_state = State::Showing;
 }
 
 void Notification::close()
 {
-    if (m_state != NotificationStateShowing)
+    if (m_state != State::Showing)
         return;
 
-    if (m_notificationId.isNull()) {
-        // Fire the close event asynchronously.
+    // Schedule the "close" event to be fired for non-persistent notifications.
+    // Persistent notifications won't get such events for programmatic closes.
+    if (m_type == Type::NonPersistent) {
         getExecutionContext()->postTask(BLINK_FROM_HERE, createSameThreadTask(&Notification::dispatchCloseEvent, wrapPersistent(this)));
+        m_state = State::Closing;
 
-        m_state = NotificationStateClosing;
         notificationManager()->close(this);
-    } else {
-        m_state = NotificationStateClosed;
+        return;
+    }
 
-        SecurityOrigin* origin = getExecutionContext()->getSecurityOrigin();
-        DCHECK(origin);
+    m_state = State::Closed;
 
-        notificationManager()->closePersistent(WebSecurityOrigin(origin), m_data.tag, m_notificationId);
-    }
+    SecurityOrigin* origin = getExecutionContext()->getSecurityOrigin();
+    DCHECK(origin);
+
+    notificationManager()->closePersistent(WebSecurityOrigin(origin), m_data.tag, m_notificationId);
 }
 
 void Notification::dispatchShowEvent()
 {
     dispatchEvent(Event::create(EventTypeNames::show));
 }
 
 void Notification::dispatchClickEvent()
 {
     UserGestureIndicator gestureIndicator(DefinitelyProcessingNewUserGesture);
     ScopedWindowFocusAllowedIndicator windowFocusAllowed(getExecutionContext());
     dispatchEvent(Event::create(EventTypeNames::click));
 }
 
 void Notification::dispatchErrorEvent()
 {
     dispatchEvent(Event::create(EventTypeNames::error));
 }
 
 void Notification::dispatchCloseEvent()
 {
     // The notification will be showing when the user initiated the close, or it will be
     // closing if the developer initiated the close.
-    if (m_state != NotificationStateShowing && m_state != NotificationStateClosing)
+    if (m_state != State::Showing && m_state != State::Closing)
         return;
 
-    m_state = NotificationStateClosed;
+    m_state = State::Closed;
     dispatchEvent(Event::create(EventTypeNames::close));
 }
 
 String Notification::title() const
 {
     return m_data.title;
 }
 
 String Notification::dir() const
 {
@@ skipping 146 matching lines @@
 
 const AtomicString& Notification::interfaceName() const
 {
     return EventTargetNames::Notification;
 }
 
 void Notification::stop()
 {
     notificationManager()->notifyDelegateDestroyed(this);
 
-    m_state = NotificationStateClosed;
+    m_state = State::Closed;
 
-    m_prepareShowMethodRunner->stop();
+    if (m_prepareShowMethodRunner)
+        m_prepareShowMethodRunner->stop();
 
     if (m_loader)
         m_loader->stop();
 }
 
 bool Notification::hasPendingActivity() const
 {
-    return m_state == NotificationStateShowing || m_prepareShowMethodRunner->isActive() || m_loader;
+    // Non-persistent notification can receive events until they've been closed.
+    // Persistent notifications should be subject to regular garbage collection.
+    if (m_type == Type::NonPersistent)
+        return m_state != State::Closed;
+
+    return false;
 }
 
 DEFINE_TRACE(Notification)
 {
     visitor->trace(m_prepareShowMethodRunner);
     visitor->trace(m_loader);
     EventTargetWithInlineData::trace(visitor);
     ActiveDOMObject::trace(visitor);
 }
 
 } // namespace blink