Adding upstream version 110.0.1.upstream/110.0.1upstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 183 insertions, 0 deletions

diff --git a/dom/serviceworkers/ServiceWorkerInfo.h b/dom/serviceworkers/ServiceWorkerInfo.h
new file mode 100644
index 0000000000..03a9eb6aff
--- /dev/null
+++ b/dom/serviceworkers/ServiceWorkerInfo.h
@@ -0,0 +1,183 @@
+/* -*- 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_serviceworkerinfo_h
+#define mozilla_dom_serviceworkerinfo_h
+
+#include "MainThreadUtils.h"
+#include "mozilla/dom/ServiceWorkerBinding.h"  // For ServiceWorkerState
+#include "mozilla/dom/ServiceWorkerDescriptor.h"
+#include "mozilla/dom/WorkerCommon.h"
+#include "mozilla/OriginAttributes.h"
+#include "mozilla/TimeStamp.h"
+#include "nsIServiceWorkerManager.h"
+
+namespace mozilla::dom {
+
+class ClientInfoAndState;
+class ClientState;
+class ServiceWorkerCloneData;
+class ServiceWorkerPrivate;
+
+/*
+ * Wherever the spec treats a worker instance and a description of said worker
+ * as the same thing; i.e. "Resolve foo with
+ * _GetNewestWorker(serviceWorkerRegistration)", we represent the description
+ * by this class and spawn a ServiceWorker in the right global when required.
+ */
+class ServiceWorkerInfo final : public nsIServiceWorkerInfo {
+ private:
+  nsCOMPtr<nsIPrincipal> mPrincipal;
+  ServiceWorkerDescriptor mDescriptor;
+  const nsString mCacheName;
+  OriginAttributes mOriginAttributes;
+  const nsString mWorkerPrivateId;
+
+  // This LoadFlags is only applied to imported scripts, since the main script
+  // has already been downloaded when performing the bytecheck. This LoadFlag is
+  // composed of three parts:
+  //   1. nsIChannel::LOAD_BYPASS_SERVICE_WORKER
+  //   2. (Optional) nsIRequest::VALIDATE_ALWAYS
+  //      depends on ServiceWorkerUpdateViaCache of its registration.
+  //   3. (optional) nsIRequest::LOAD_BYPASS_CACHE
+  //      depends on whether the update timer is expired.
+  const nsLoadFlags mImportsLoadFlags;
+
+  // Timestamp to track SW's state
+  PRTime mCreationTime;
+  TimeStamp mCreationTimeStamp;
+
+  // The time of states are 0, if SW has not reached that state yet. Besides, we
+  // update each of them after UpdateState() is called in SWRegistrationInfo.
+  PRTime mInstalledTime;
+  PRTime mActivatedTime;
+  PRTime mRedundantTime;
+
+  RefPtr<ServiceWorkerPrivate> mServiceWorkerPrivate;
+  bool mSkipWaitingFlag;
+
+  enum { Unknown, Enabled, Disabled } mHandlesFetch;
+
+  uint32_t mNavigationFaultCount;
+
+  // Testing helper to trigger fetch event cancellation when not NS_OK.
+  // See `nsIServiceWorkerInfo::testingInjectCancellation`.
+  nsresult mTestingInjectCancellation;
+
+  ~ServiceWorkerInfo();
+
+  // Generates a unique id for the service worker, with zero being treated as
+  // invalid.
+  uint64_t GetNextID() const;
+
+ public:
+  NS_DECL_ISUPPORTS
+  NS_DECL_NSISERVICEWORKERINFO
+
+  void PostMessage(RefPtr<ServiceWorkerCloneData>&& aData,
+                   const ClientInfo& aClientInfo,
+                   const ClientState& aClientState);
+
+  class ServiceWorkerPrivate* WorkerPrivate() const {
+    MOZ_ASSERT(mServiceWorkerPrivate);
+    return mServiceWorkerPrivate;
+  }
+
+  nsIPrincipal* Principal() const { return mPrincipal; }
+
+  const nsCString& ScriptSpec() const { return mDescriptor.ScriptURL(); }
+
+  const nsCString& Scope() const { return mDescriptor.Scope(); }
+
+  bool SkipWaitingFlag() const {
+    MOZ_ASSERT(NS_IsMainThread());
+    return mSkipWaitingFlag;
+  }
+
+  void SetSkipWaitingFlag() {
+    MOZ_ASSERT(NS_IsMainThread());
+    mSkipWaitingFlag = true;
+  }
+
+  void ReportNavigationFault() {
+    MOZ_ASSERT(NS_IsMainThread());
+    mNavigationFaultCount++;
+  }
+
+  ServiceWorkerInfo(nsIPrincipal* aPrincipal, const nsACString& aScope,
+                    uint64_t aRegistrationId, uint64_t aRegistrationVersion,
+                    const nsACString& aScriptSpec, const nsAString& aCacheName,
+                    nsLoadFlags aLoadFlags);
+
+  ServiceWorkerState State() const { return mDescriptor.State(); }
+
+  const OriginAttributes& GetOriginAttributes() const {
+    return mOriginAttributes;
+  }
+
+  const nsString& CacheName() const { return mCacheName; }
+
+  nsLoadFlags GetImportsLoadFlags() const { return mImportsLoadFlags; }
+
+  uint64_t ID() const { return mDescriptor.Id(); }
+
+  const ServiceWorkerDescriptor& Descriptor() const { return mDescriptor; }
+
+  nsresult TestingInjectCancellation() { return mTestingInjectCancellation; }
+
+  void UpdateState(ServiceWorkerState aState);
+
+  // Only used to set initial state when loading from disk!
+  void SetActivateStateUncheckedWithoutEvent(ServiceWorkerState aState) {
+    MOZ_ASSERT(NS_IsMainThread());
+    mDescriptor.SetState(aState);
+  }
+
+  void SetHandlesFetch(bool aHandlesFetch) {
+    MOZ_ASSERT(NS_IsMainThread());
+    MOZ_DIAGNOSTIC_ASSERT(mHandlesFetch == Unknown);
+    mHandlesFetch = aHandlesFetch ? Enabled : Disabled;
+    mDescriptor.SetHandlesFetch(aHandlesFetch);
+  }
+
+  void SetRegistrationVersion(uint64_t aVersion);
+
+  bool HandlesFetch() const {
+    MOZ_ASSERT(NS_IsMainThread());
+    MOZ_DIAGNOSTIC_ASSERT(mHandlesFetch != Unknown);
+    return mHandlesFetch != Disabled;
+  }
+
+  void UpdateInstalledTime();
+
+  void UpdateActivatedTime();
+
+  void UpdateRedundantTime();
+
+  int64_t GetInstalledTime() const { return mInstalledTime; }
+
+  void SetInstalledTime(const int64_t aTime) {
+    if (aTime == 0) {
+      return;
+    }
+
+    mInstalledTime = aTime;
+  }
+
+  int64_t GetActivatedTime() const { return mActivatedTime; }
+
+  void SetActivatedTime(const int64_t aTime) {
+    if (aTime == 0) {
+      return;
+    }
+
+    mActivatedTime = aTime;
+  }
+};
+
+}  // namespace mozilla::dom
+
+#endif  // mozilla_dom_serviceworkerinfo_h