gecko-dev/dom/serviceworkers/ServiceWorkerPrivate.h

/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
/* vim: set ts=8 sts=2 et sw=2 tw=80: */
/* This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */

#ifndef mozilla_dom_serviceworkerprivate_h
#define mozilla_dom_serviceworkerprivate_h

#include <type_traits>

#include "nsCOMPtr.h"
#include "mozilla/dom/WorkerPrivate.h"
#include "mozilla/MozPromise.h"

#define NOTIFICATION_CLICK_EVENT_NAME u"notificationclick"
#define NOTIFICATION_CLOSE_EVENT_NAME u"notificationclose"

class nsIInterceptedChannel;
class nsIWorkerDebugger;

namespace mozilla {

class JSObjectHolder;

namespace dom {

class ClientInfoAndState;
class ServiceWorkerCloneData;
class ServiceWorkerInfo;
class ServiceWorkerPrivate;
class ServiceWorkerPrivateImpl;
class ServiceWorkerRegistrationInfo;

namespace ipc {
class StructuredCloneData;
}  // namespace ipc

class LifeCycleEventCallback : public Runnable {
 public:
  LifeCycleEventCallback() : Runnable("dom::LifeCycleEventCallback") {}

  // Called on the worker thread.
  virtual void SetResult(bool aResult) = 0;
};

// Used to keep track of pending waitUntil as well as in-flight extendable
// events. When the last token is released, we attempt to terminate the worker.
class KeepAliveToken final : public nsISupports {
 public:
  NS_DECL_ISUPPORTS

  explicit KeepAliveToken(ServiceWorkerPrivate* aPrivate);

 private:
  ~KeepAliveToken();

  RefPtr<ServiceWorkerPrivate> mPrivate;
};

// ServiceWorkerPrivate is a wrapper for managing the on-demand aspect of
// service workers. It handles all event dispatching to the worker and ensures
// the worker thread is running when needed.
//
// Lifetime management: To spin up the worker thread we own a |WorkerPrivate|
// object which can be cancelled if no events are received for a certain
// amount of time. The worker is kept alive by holding a |KeepAliveToken|
// reference.
//
// Extendable events hold tokens for the duration of their handler execution
// and until their waitUntil promise is resolved, while ServiceWorkerPrivate
// will hold a token for |dom.serviceWorkers.idle_timeout| seconds after each
// new event.
//
// Note: All timer events must be handled on the main thread because the
// worker may block indefinitely the worker thread (e. g. infinite loop in the
// script).
//
// There are 3 cases where we may ignore keep alive tokens:
// 1. When ServiceWorkerPrivate's token expired, if there are still waitUntil
// handlers holding tokens, we wait another
// |dom.serviceWorkers.idle_extended_timeout| seconds before forcibly
// terminating the worker.
// 2. If the worker stopped controlling documents and it is not handling push
// events.
// 3. The content process is shutting down.
//
// Adding an API function for a new event requires calling |SpawnWorkerIfNeeded|
// with an appropriate reason before any runnable is dispatched to the worker.
// If the event is extendable then the runnable should inherit
// ExtendableEventWorkerRunnable.
class ServiceWorkerPrivate final {
  friend class KeepAliveToken;
  friend class ServiceWorkerPrivateImpl;

 public:
  NS_IMETHOD_(MozExternalRefCountType) AddRef();
  NS_IMETHOD_(MozExternalRefCountType) Release();
  NS_DECL_CYCLE_COLLECTION_NATIVE_CLASS(ServiceWorkerPrivate)

  using HasThreadSafeRefCnt = std::false_type;

 protected:
  nsCycleCollectingAutoRefCnt mRefCnt;
  NS_DECL_OWNINGTHREAD

 public:
  // TODO: remove this class. There's one (and only should be one) concrete
  // class that derives this abstract base class.
  class Inner {
   public:
    NS_INLINE_DECL_PURE_VIRTUAL_REFCOUNTING

    virtual nsresult SendMessageEvent(
        RefPtr<ServiceWorkerCloneData>&& aData,
        const ClientInfoAndState& aClientInfoAndState) = 0;

    virtual nsresult CheckScriptEvaluation(
        RefPtr<LifeCycleEventCallback> aScriptEvaluationCallback) = 0;

    virtual nsresult SendLifeCycleEvent(
        const nsAString& aEventName,
        RefPtr<LifeCycleEventCallback> aCallback) = 0;

    virtual nsresult SendPushEvent(
        RefPtr<ServiceWorkerRegistrationInfo> aRegistration,
        const nsAString& aMessageId, const Maybe<nsTArray<uint8_t>>& aData) = 0;

    virtual nsresult SendPushSubscriptionChangeEvent() = 0;

    virtual nsresult SendNotificationEvent(
        const nsAString& aEventName, const nsAString& aID,
        const nsAString& aTitle, const nsAString& aDir, const nsAString& aLang,
        const nsAString& aBody, const nsAString& aTag, const nsAString& aIcon,
        const nsAString& aData, const nsAString& aBehavior,
        const nsAString& aScope, uint32_t aDisableOpenClickDelay) = 0;

    virtual nsresult SendFetchEvent(
        RefPtr<ServiceWorkerRegistrationInfo> aRegistration,
        nsCOMPtr<nsIInterceptedChannel> aChannel, const nsAString& aClientId,
        const nsAString& aResultingClientId) = 0;

    virtual nsresult SpawnWorkerIfNeeded() = 0;

    virtual void TerminateWorker() = 0;

    virtual void UpdateState(ServiceWorkerState aState) = 0;

    virtual void NoteDeadOuter() = 0;

    virtual bool WorkerIsDead() const = 0;
  };

  explicit ServiceWorkerPrivate(ServiceWorkerInfo* aInfo);

  nsresult SendMessageEvent(RefPtr<ServiceWorkerCloneData>&& aData,
                            const ClientInfoAndState& aClientInfoAndState);

  // This is used to validate the worker script and continue the installation
  // process.
  nsresult CheckScriptEvaluation(LifeCycleEventCallback* aCallback);

  nsresult SendLifeCycleEvent(const nsAString& aEventType,
                              LifeCycleEventCallback* aCallback);

  nsresult SendPushEvent(const nsAString& aMessageId,
                         const Maybe<nsTArray<uint8_t>>& aData,
                         ServiceWorkerRegistrationInfo* aRegistration);

  nsresult SendPushSubscriptionChangeEvent();

  nsresult SendNotificationEvent(const nsAString& aEventName,
                                 const nsAString& aID, const nsAString& aTitle,
                                 const nsAString& aDir, const nsAString& aLang,
                                 const nsAString& aBody, const nsAString& aTag,
                                 const nsAString& aIcon, const nsAString& aData,
                                 const nsAString& aBehavior,
                                 const nsAString& aScope);

  nsresult SendFetchEvent(nsIInterceptedChannel* aChannel,
                          nsILoadGroup* aLoadGroup, const nsAString& aClientId,
                          const nsAString& aResultingClientId);

  bool MaybeStoreISupports(nsISupports* aSupports);

  void RemoveISupports(nsISupports* aSupports);

  // This will terminate the current running worker thread and drop the
  // workerPrivate reference.
  // Called by ServiceWorkerInfo when [[Clear Registration]] is invoked
  // or whenever the spec mandates that we terminate the worker.
  // This is a no-op if the worker has already been stopped.
  void TerminateWorker();

  void NoteDeadServiceWorkerInfo();

  void NoteStoppedControllingDocuments();

  void UpdateState(ServiceWorkerState aState);

  nsresult GetDebugger(nsIWorkerDebugger** aResult);

  nsresult AttachDebugger();

  nsresult DetachDebugger();

  bool IsIdle() const;

  // This promise is used schedule clearing of the owning registrations and its
  // associated Service Workers if that registration becomes "unreachable" by
  // the ServiceWorkerManager. This occurs under two conditions, which are the
  // preconditions to calling this method:
  // - The owning registration must be unregistered.
  // - The associated Service Worker must *not* be controlling clients.
  //
  // Additionally, perhaps stating the obvious, the associated Service Worker
  // must *not* be idle (whatever must be done "when idle" can just be done
  // immediately).
  RefPtr<GenericPromise> GetIdlePromise();

  void SetHandlesFetch(bool aValue);

 private:
  enum WakeUpReason {
    FetchEvent = 0,
    PushEvent,
    PushSubscriptionChangeEvent,
    MessageEvent,
    NotificationClickEvent,
    NotificationCloseEvent,
    LifeCycleEvent,
    AttachEvent,
    Unknown
  };

  // Timer callbacks
  void NoteIdleWorkerCallback(nsITimer* aTimer);

  void TerminateWorkerCallback(nsITimer* aTimer);

  void RenewKeepAliveToken(WakeUpReason aWhy);

  void ResetIdleTimeout();

  void AddToken();

  void ReleaseToken();

  nsresult SpawnWorkerIfNeeded(WakeUpReason aWhy,
                               bool* aNewWorkerCreated = nullptr,
                               nsILoadGroup* aLoadGroup = nullptr);

  ~ServiceWorkerPrivate();

  already_AddRefed<KeepAliveToken> CreateEventKeepAliveToken();

  // The info object owns us. It is possible to outlive it for a brief period
  // of time if there are pending waitUntil promises, in which case it
  // will be null and |SpawnWorkerIfNeeded| will always fail.
  ServiceWorkerInfo* MOZ_NON_OWNING_REF mInfo;

  // The WorkerPrivate object can only be closed by this class or by the
  // RuntimeService class if gecko is shutting down. Closing the worker
  // multiple times is OK, since the second attempt will be a no-op.
  RefPtr<WorkerPrivate> mWorkerPrivate;

  nsCOMPtr<nsITimer> mIdleWorkerTimer;

  // We keep a token for |dom.serviceWorkers.idle_timeout| seconds to give the
  // worker a grace period after each event.
  RefPtr<KeepAliveToken> mIdleKeepAliveToken;

  uint64_t mDebuggerCount;

  uint64_t mTokenCount;

  // Meant for keeping objects alive while handling requests from the worker
  // on the main thread. Access to this array is provided through
  // |StoreISupports| and |RemoveISupports|. Note that the array is also
  // cleared whenever the worker is terminated.
  nsTArray<nsCOMPtr<nsISupports>> mSupportsArray;

  // Array of function event worker runnables that are pending due to
  // the worker activating.  Main thread only.
  nsTArray<RefPtr<WorkerRunnable>> mPendingFunctionalEvents;

  RefPtr<Inner> mInner;

  // Used by the owning `ServiceWorkerRegistrationInfo` when it wants to call
  // `Clear` after being unregistered and isn't controlling any clients but this
  // worker (i.e. the registration's active worker) isn't idle yet. Note that
  // such an event should happen at most once in a
  // `ServiceWorkerRegistrationInfo`s lifetime, so this promise should also only
  // be obtained at most once.
  MozPromiseHolder<GenericPromise> mIdlePromiseHolder;

#ifdef DEBUG
  bool mIdlePromiseObtained = false;
#endif
};

}  // namespace dom
}  // namespace mozilla

#endif  // mozilla_dom_serviceworkerprivate_h