Quelle ServiceWorkerContainer.h Sprache: C

/* -*- 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_serviceworkercontainer_h__
#define mozilla_dom_serviceworkercontainer_h__

#include "mozilla/DOMEventTargetHelper.h"
#include "mozilla/ErrorResult.h"
#include "mozilla/dom/ServiceWorkerUtils.h"

class nsIGlobalWindow;

namespace mozilla::dom {

class ClientPostMessageArgs;
struct MessageEventInit;
class Promise;
struct RegistrationOptions;
class ServiceWorker;
class ServiceWorkerContainerChild;
class TrustedScriptURLOrUSVString;

// Lightweight serviceWorker APIs collection.
class ServiceWorkerContainer final : public DOMEventTargetHelper {
public:
  NS_DECL_ISUPPORTS_INHERITED
  NS_DECL_CYCLE_COLLECTION_CLASS_INHERITED(ServiceWorkerContainer,
                                           DOMEventTargetHelper)

  IMPL_EVENT_HANDLER(controllerchange)
  IMPL_EVENT_HANDLER(messageerror)

  // Almost a manual expansion of IMPL_EVENT_HANDLER(message), but
  // with the additional StartMessages() when setting the handler, as
  // required by the spec.
  inline mozilla::dom::EventHandlerNonNull* GetOnmessage() {
    return GetEventHandler(nsGkAtoms::onmessage);
  }
  inline void SetOnmessage(mozilla::dom::EventHandlerNonNull* aCallback) {
    SetEventHandler(nsGkAtoms::onmessage, aCallback);
    StartMessages();
  }

  static bool IsEnabled(JSContext* aCx, JSObject* aGlobal);

  static already_AddRefed<ServiceWorkerContainer> Create(
      nsIGlobalObject* aGlobal);

  virtual JSObject* WrapObject(JSContext* aCx,
                               JS::Handle<JSObject*> aGivenProto) override;

  MOZ_CAN_RUN_SCRIPT already_AddRefed<Promise> Register(
      const TrustedScriptURLOrUSVString& aScriptURL,
      const RegistrationOptions& aOptions, const CallerType aCallerType,
      ErrorResult& aRv);

  already_AddRefed<ServiceWorker> GetController();

  already_AddRefed<Promise> GetRegistration(const nsAString& aDocumentURL,
                                            ErrorResult& aRv);

  already_AddRefed<Promise> GetRegistrations(ErrorResult& aRv);

  void StartMessages();

  Promise* GetReady(ErrorResult& aRv);

  // Testing only.
  void GetScopeForUrl(const nsAString& aUrl, nsString& aScope,
                      ErrorResult& aRv);

  // DOMEventTargetHelper
  void DisconnectFromOwner() override;

  // Invalidates |mControllerWorker| and dispatches a "controllerchange"
  // event.
  void ControllerChanged(ErrorResult& aRv);

  void ReceiveMessage(const ClientPostMessageArgs& aArgs);

  void RevokeActor(ServiceWorkerContainerChild* aActor);

private:
  explicit ServiceWorkerContainer(nsIGlobalObject* aGlobal);

  ~ServiceWorkerContainer();

  // Utility method to get the global if its present and if certain
  // additional validaty checks pass.  One of these additional checks
  // verifies the global can access storage.  Since storage access can
  // vary based on user settings we want to often provide some error
  // message if the storage check fails.  This method takes an optional
  // callback that can be used to report the storage failure to the
  // devtools console.
  nsIGlobalObject* GetGlobalIfValid(
      ErrorResult& aRv,
      const std::function<void(nsIGlobalObject*)>&& aStorageFailureCB =
          nullptr) const;

  struct ReceivedMessage;

  // Dispatch a Runnable that dispatches the given message on this
  // object. When the owner of this object is a Window, the Runnable
  // is dispatched on the corresponding TabGroup.
  void EnqueueReceivedMessageDispatch(RefPtr<ReceivedMessage> aMessage);

  template <typename F>
  void RunWithJSContext(F&& aCallable);

  void DispatchMessage(RefPtr<ReceivedMessage> aMessage);

  // When it fails, returning boolean means whether it's because deserailization
  // failed or not.
  static Result<Ok, bool> FillInMessageEventInit(JSContext* aCx,
                                                 nsIGlobalObject* aGlobal,
                                                 ReceivedMessage& aMessage,
                                                 MessageEventInit& aInit,
                                                 ErrorResult& aRv);

  void Shutdown();

  RefPtr<ServiceWorkerContainerChild> mActor;
  bool mShutdown;

  // This only changes when a worker hijacks everything in its scope by calling
  // claim.
  RefPtr<ServiceWorker> mControllerWorker;

  RefPtr<Promise> mReadyPromise;
  MozPromiseRequestHolder<ServiceWorkerRegistrationPromise> mReadyPromiseHolder;

  // Set after StartMessages() has been called.
  bool mMessagesStarted = false;

  // Queue holding messages posted from service worker as long as
  // StartMessages() hasn't been called.
  nsTArray<RefPtr<ReceivedMessage>> mPendingMessages;
};

}  // namespace mozilla::dom

#endif /* mozilla_dom_serviceworkercontainer_h__ */

quality100%

¤ Dauer der Verarbeitung: 0.24 Sekunden (vorverarbeitet) ¤

Wurzel

Suchen

Beweissystem der NASA

Beweissystem Isabelle

NIST Cobol Testsuite

Cephes Mathematical Library

Wiener Entwicklungsmethode

Haftungshinweis

Die Informationen auf dieser Webseite wurden nach bestem Wissen sorgfältig zusammengestellt. Es wird jedoch weder Vollständigkeit, noch Richtigkeit, noch Qualität der bereit gestellten Informationen zugesichert.

Bemerkung:

Die farbliche Syntaxdarstellung ist noch experimentell.