Merge the code paths for closing different kinds of notifications.

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 119 matching lines @@
   return notification;
 }
 
 Notification::Notification(ExecutionContext* context,
                            Type type,
                            const WebNotificationData& data)
     : ActiveScriptWrappable(this),
       ActiveDOMObject(context),
       m_type(type),
       m_state(State::Loading),
-      m_data(data) {
+      m_data(data),
+      m_requestedClose(false) {
   DCHECK(notificationManager());
 }
 
 Notification::~Notification() {}
 
 void Notification::schedulePrepareShow() {
   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, State::Loading);
   if (NotificationManager::from(getExecutionContext())->permissionStatus() !=
       mojom::blink::PermissionStatus::GRANTED) {
-    dispatchErrorEvent();
+    dispatchEvent(Event::create(EventTypeNames::error));
     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 = State::Showing;
 }
 
 void Notification::close() {
-  if (m_state != State::Showing)
+  if (m_state != State::Showing) {
+    // TODO(peter): Abort the load instead of closing the notification after
+    // it's completed.
+    if (m_state == State::Loading || m_notificationId.isEmpty())
+      m_requestedClose = true;
+
     return;
+  }
 
   // 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)));
+        BLINK_FROM_HERE,
+        createSameThreadTask(&Notification::didCloseNotification,
+                             wrapPersistent(this)));
     m_state = State::Closing;
-
-    notificationManager()->close(this);
-    return;
+  } else {
+    m_state = State::Closed;
   }
 
-  m_state = State::Closed;
-
   SecurityOrigin* origin = getExecutionContext()->getSecurityOrigin();
   DCHECK(origin);
 
-  notificationManager()->closePersistent(WebSecurityOrigin(origin), m_data.tag,
-                                         m_notificationId);
+  notificationManager()->close(WebSecurityOrigin(origin), m_data.tag,
+                               m_notificationId);
 }
 
-void Notification::dispatchShowEvent() {
+void Notification::didShowNotification(const WebString& notificationId) {
+  DCHECK(m_notificationId.isEmpty());
+  m_notificationId = notificationId;
+
   dispatchEvent(Event::create(EventTypeNames::show));
+
+  if (m_requestedClose)
+    close();
 }
 
-void Notification::dispatchClickEvent() {
+void Notification::didClickNotification() {
   UserGestureIndicator gestureIndicator(
       UserGestureToken::create(UserGestureToken::NewGesture));
+
   ScopedWindowFocusAllowedIndicator windowFocusAllowed(getExecutionContext());
   dispatchEvent(Event::create(EventTypeNames::click));
 }
 
-void Notification::dispatchErrorEvent() {
-  dispatchEvent(Event::create(EventTypeNames::error));
-}
-
-void Notification::dispatchCloseEvent() {
-  // The notification should be Showing if the user initiated the close, or it
-  // should be Closing if the developer initiated the close.
+void Notification::didCloseNotification() {
+  // 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 != State::Showing && m_state != State::Closing)
     return;
 
   m_state = State::Closed;
   dispatchEvent(Event::create(EventTypeNames::close));
 }
 
 String Notification::title() const {
   return m_data.title;
 }
@@ skipping 163 matching lines @@
 }
 
 DEFINE_TRACE(Notification) {
   visitor->trace(m_prepareShowMethodRunner);
   visitor->trace(m_loader);
   EventTargetWithInlineData::trace(visitor);
   ActiveDOMObject::trace(visitor);
 }
 
 }  // namespace blink