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

third_party/WebKit/Source/modules/notifications/Notification.h

 /*
  * 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 34 matching lines @@
 #include "platform/weborigin/KURL.h"
 #include "public/platform/WebVector.h"
 #include "public/platform/modules/notifications/WebNotificationData.h"
 #include "public/platform/modules/notifications/WebNotificationDelegate.h"
 #include "public/platform/modules/permissions/permission.mojom-blink.h"
 #include "public/platform/modules/permissions/permission_status.mojom-blink.h"
 
 namespace blink {
 
 class ExecutionContext;
-class NotificationAction;
-class NotificationManager;
 class NotificationOptions;
 class NotificationPermissionCallback;
 class NotificationResourcesLoader;
 class ScriptState;
 
 class MODULES_EXPORT Notification final : public EventTargetWithInlineData, public ActiveScriptWrappable, public ActiveDOMObject, public WebNotificationDelegate {
     USING_GARBAGE_COLLECTED_MIXIN(Notification);
     DEFINE_WRAPPERTYPEINFO();
 public:
-    // Used for JavaScript instantiations of the Notification object. Will automatically schedule for
-    // the notification to be displayed to the user when the developer-provided data is valid.
+    // Used for JavaScript instantiations of non-persistent notifications. Will
+    // automatically schedule for the notification to be displayed to the user
+    // when the developer-provided data is valid.
     static Notification* create(ExecutionContext*, const String& title, const NotificationOptions&, ExceptionState&);
 
-    // Used for embedder-created Notification objects. If |showing| is true, will initialize the
-    // Notification's state as showing, or as closed otherwise.
+    // Used for embedder-created persistent notifications. Initializes the state
+    // of the notification as either Showing or Closed based on |showing|.
     static Notification* create(ExecutionContext*, const String& notificationId, const WebNotificationData&, bool showing);
 
     ~Notification() override;
 
     void close();
 
     DEFINE_ATTRIBUTE_EVENT_LISTENER(click);
     DEFINE_ATTRIBUTE_EVENT_LISTENER(show);
     DEFINE_ATTRIBUTE_EVENT_LISTENER(error);
     DEFINE_ATTRIBUTE_EVENT_LISTENER(close);
@@ skipping 36 matching lines @@
     // ScriptWrappable interface.
     bool hasPendingActivity() const final;
 
     DECLARE_VIRTUAL_TRACE();
 
 protected:
     // EventTarget interface.
     DispatchEventResult dispatchEventInternal(Event*) final;
 
 private:
-    Notification(ExecutionContext*, const WebNotificationData&);
+    // The type of notification this instance represents. Non-persistent
+    // notifications will have events delivered to their instance, whereas
+    // persistent notification will be using a Service Worker.
+    enum class Type {
+        NonPersistent,
+        Persistent
+    };
+
+    // The current phase of the notification in its lifecycle.
+    enum class State {
+        Loading,
+        Showing,
+        Closing,
+        Closed
+    };
+
+    Notification(ExecutionContext*, Type, const WebNotificationData&);
+
+    // Sets the state of the notification in its lifecycle.
+    void setState(State state) { m_state = state; }
+
+    // Sets the notification ID to |notificationId|. This should be done once
+    // the notification has shown for non-persistent notifications, and at
+    // object initialisation time for persistent notifications.
+    void setNotificationId(const String& notificationId) { m_notificationId = notificationId; }
 
     // Schedules an asynchronous call to |prepareShow|, allowing the constructor
     // to return so that events can be fired on the notification object.
     void schedulePrepareShow();
 
-    // Checks permission and loads any necessary resources (this may be async)
-    // before showing the notification.
+    // Verifies that permission has been granted, then asynchronously starts
+    // loading the resources associated with this notification.
     void prepareShow();
 
-    // Shows the notification, using the resources loaded by the
-    // NotificationResourcesLoader.
+    // Shows the notification through the embedder using the loaded resources.
     void didLoadResources(NotificationResourcesLoader*);
 
-    void setNotificationId(const String& notificationId) { m_notificationId = notificationId; }
+    Type m_type;
+    State m_state;
 
     WebNotificationData m_data;
 
-    // Notifications can either be bound to the page, which means they're identified by
-    // their delegate, or persistent, which means they're identified by a persistent Id
-    // given to us by the embedder. This influences how we close the notification.
     String m_notificationId;
 
-    enum NotificationState {
-        NotificationStateIdle,
-        NotificationStateShowing,
-        NotificationStateClosing,
-        NotificationStateClosed
-    };
-
-    // Only to be used by the Notification::create() method when notifications were created
-    // by the embedder rather than by Blink.
-    void setState(NotificationState state) { m_state = state; }
-
-    NotificationState m_state;
-
     Member<AsyncMethodRunner<Notification>> m_prepareShowMethodRunner;
 
     Member<NotificationResourcesLoader> m_loader;
 };
 
 } // namespace blink
 
 #endif // Notification_h