summaryrefslogtreecommitdiffstats
path: root/dom/serviceworkers/ServiceWorkerInfo.cpp
diff options
context:
space:
mode:
authorDaniel Baumann <daniel.baumann@progress-linux.org>2024-04-07 19:33:14 +0000
committerDaniel Baumann <daniel.baumann@progress-linux.org>2024-04-07 19:33:14 +0000
commit36d22d82aa202bb199967e9512281e9a53db42c9 (patch)
tree105e8c98ddea1c1e4784a60a5a6410fa416be2de /dom/serviceworkers/ServiceWorkerInfo.cpp
parentInitial commit. (diff)
downloadfirefox-esr-36d22d82aa202bb199967e9512281e9a53db42c9.tar.xz
firefox-esr-36d22d82aa202bb199967e9512281e9a53db42c9.zip
Adding upstream version 115.7.0esr.upstream/115.7.0esrupstream
Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>
Diffstat (limited to 'dom/serviceworkers/ServiceWorkerInfo.cpp')
-rw-r--r--dom/serviceworkers/ServiceWorkerInfo.cpp286
1 files changed, 286 insertions, 0 deletions
diff --git a/dom/serviceworkers/ServiceWorkerInfo.cpp b/dom/serviceworkers/ServiceWorkerInfo.cpp
new file mode 100644
index 0000000000..9998cfed6b
--- /dev/null
+++ b/dom/serviceworkers/ServiceWorkerInfo.cpp
@@ -0,0 +1,286 @@
+/* -*- 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/. */
+
+#include "ServiceWorkerInfo.h"
+
+#include "ServiceWorkerUtils.h"
+#include "ServiceWorkerPrivate.h"
+#include "ServiceWorkerScriptCache.h"
+#include "mozilla/dom/ClientIPCTypes.h"
+#include "mozilla/dom/ClientState.h"
+#include "mozilla/dom/RemoteWorkerTypes.h"
+#include "mozilla/dom/WorkerPrivate.h"
+
+namespace mozilla::dom {
+
+using mozilla::ipc::PrincipalInfo;
+
+static_assert(nsIServiceWorkerInfo::STATE_PARSED ==
+ static_cast<uint16_t>(ServiceWorkerState::Parsed),
+ "ServiceWorkerState enumeration value should match state values "
+ "from nsIServiceWorkerInfo.");
+static_assert(nsIServiceWorkerInfo::STATE_INSTALLING ==
+ static_cast<uint16_t>(ServiceWorkerState::Installing),
+ "ServiceWorkerState enumeration value should match state values "
+ "from nsIServiceWorkerInfo.");
+static_assert(nsIServiceWorkerInfo::STATE_INSTALLED ==
+ static_cast<uint16_t>(ServiceWorkerState::Installed),
+ "ServiceWorkerState enumeration value should match state values "
+ "from nsIServiceWorkerInfo.");
+static_assert(nsIServiceWorkerInfo::STATE_ACTIVATING ==
+ static_cast<uint16_t>(ServiceWorkerState::Activating),
+ "ServiceWorkerState enumeration value should match state values "
+ "from nsIServiceWorkerInfo.");
+static_assert(nsIServiceWorkerInfo::STATE_ACTIVATED ==
+ static_cast<uint16_t>(ServiceWorkerState::Activated),
+ "ServiceWorkerState enumeration value should match state values "
+ "from nsIServiceWorkerInfo.");
+static_assert(nsIServiceWorkerInfo::STATE_REDUNDANT ==
+ static_cast<uint16_t>(ServiceWorkerState::Redundant),
+ "ServiceWorkerState enumeration value should match state values "
+ "from nsIServiceWorkerInfo.");
+static_assert(nsIServiceWorkerInfo::STATE_UNKNOWN ==
+ ServiceWorkerStateValues::Count,
+ "ServiceWorkerState enumeration value should match state values "
+ "from nsIServiceWorkerInfo.");
+
+NS_IMPL_ISUPPORTS(ServiceWorkerInfo, nsIServiceWorkerInfo)
+
+NS_IMETHODIMP
+ServiceWorkerInfo::GetId(nsAString& aId) {
+ MOZ_ASSERT(NS_IsMainThread());
+ aId = mWorkerPrivateId;
+ return NS_OK;
+}
+
+NS_IMETHODIMP
+ServiceWorkerInfo::GetScriptSpec(nsAString& aScriptSpec) {
+ MOZ_ASSERT(NS_IsMainThread());
+ CopyUTF8toUTF16(mDescriptor.ScriptURL(), aScriptSpec);
+ return NS_OK;
+}
+
+NS_IMETHODIMP
+ServiceWorkerInfo::GetCacheName(nsAString& aCacheName) {
+ MOZ_ASSERT(NS_IsMainThread());
+ aCacheName = mCacheName;
+ return NS_OK;
+}
+
+NS_IMETHODIMP
+ServiceWorkerInfo::GetState(uint16_t* aState) {
+ MOZ_ASSERT(aState);
+ MOZ_ASSERT(NS_IsMainThread());
+ *aState = static_cast<uint16_t>(State());
+ return NS_OK;
+}
+
+NS_IMETHODIMP
+ServiceWorkerInfo::GetDebugger(nsIWorkerDebugger** aResult) {
+ if (NS_WARN_IF(!aResult)) {
+ return NS_ERROR_FAILURE;
+ }
+
+ return mServiceWorkerPrivate->GetDebugger(aResult);
+}
+
+NS_IMETHODIMP
+ServiceWorkerInfo::GetHandlesFetchEvents(bool* aValue) {
+ MOZ_ASSERT(aValue);
+ MOZ_ASSERT(NS_IsMainThread());
+
+ if (mHandlesFetch == Unknown) {
+ return NS_ERROR_FAILURE;
+ }
+
+ *aValue = HandlesFetch();
+ return NS_OK;
+}
+
+NS_IMETHODIMP
+ServiceWorkerInfo::GetInstalledTime(PRTime* _retval) {
+ MOZ_ASSERT(NS_IsMainThread());
+ MOZ_ASSERT(_retval);
+ *_retval = mInstalledTime;
+ return NS_OK;
+}
+
+NS_IMETHODIMP
+ServiceWorkerInfo::GetActivatedTime(PRTime* _retval) {
+ MOZ_ASSERT(NS_IsMainThread());
+ MOZ_ASSERT(_retval);
+ *_retval = mActivatedTime;
+ return NS_OK;
+}
+
+NS_IMETHODIMP
+ServiceWorkerInfo::GetRedundantTime(PRTime* _retval) {
+ MOZ_ASSERT(NS_IsMainThread());
+ MOZ_ASSERT(_retval);
+ *_retval = mRedundantTime;
+ return NS_OK;
+}
+
+NS_IMETHODIMP
+ServiceWorkerInfo::GetNavigationFaultCount(uint32_t* aNavigationFaultCount) {
+ MOZ_ASSERT(NS_IsMainThread());
+ MOZ_ASSERT(aNavigationFaultCount);
+ *aNavigationFaultCount = mNavigationFaultCount;
+ return NS_OK;
+}
+
+NS_IMETHODIMP
+ServiceWorkerInfo::GetTestingInjectCancellation(
+ nsresult* aTestingInjectCancellation) {
+ MOZ_ASSERT(NS_IsMainThread());
+ MOZ_ASSERT(aTestingInjectCancellation);
+ *aTestingInjectCancellation = mTestingInjectCancellation;
+ return NS_OK;
+}
+
+NS_IMETHODIMP
+ServiceWorkerInfo::SetTestingInjectCancellation(
+ nsresult aTestingInjectCancellation) {
+ MOZ_ASSERT(NS_IsMainThread());
+ mTestingInjectCancellation = aTestingInjectCancellation;
+ return NS_OK;
+}
+
+NS_IMETHODIMP
+ServiceWorkerInfo::AttachDebugger() {
+ return mServiceWorkerPrivate->AttachDebugger();
+}
+
+NS_IMETHODIMP
+ServiceWorkerInfo::DetachDebugger() {
+ return mServiceWorkerPrivate->DetachDebugger();
+}
+
+void ServiceWorkerInfo::UpdateState(ServiceWorkerState aState) {
+ MOZ_ASSERT(NS_IsMainThread());
+#ifdef DEBUG
+ // Any state can directly transition to redundant, but everything else is
+ // ordered.
+ if (aState != ServiceWorkerState::Redundant) {
+ MOZ_ASSERT_IF(State() == ServiceWorkerState::EndGuard_,
+ aState == ServiceWorkerState::Installing);
+ MOZ_ASSERT_IF(State() == ServiceWorkerState::Installing,
+ aState == ServiceWorkerState::Installed);
+ MOZ_ASSERT_IF(State() == ServiceWorkerState::Installed,
+ aState == ServiceWorkerState::Activating);
+ MOZ_ASSERT_IF(State() == ServiceWorkerState::Activating,
+ aState == ServiceWorkerState::Activated);
+ }
+ // Activated can only go to redundant.
+ MOZ_ASSERT_IF(State() == ServiceWorkerState::Activated,
+ aState == ServiceWorkerState::Redundant);
+#endif
+ // Flush any pending functional events to the worker when it transitions to
+ // the activated state.
+ // TODO: Do we care that these events will race with the propagation of the
+ // state change?
+ if (State() != aState) {
+ mServiceWorkerPrivate->UpdateState(aState);
+ }
+ mDescriptor.SetState(aState);
+ if (State() == ServiceWorkerState::Redundant) {
+ serviceWorkerScriptCache::PurgeCache(mPrincipal, mCacheName);
+ mServiceWorkerPrivate->NoteDeadServiceWorkerInfo();
+ }
+}
+
+ServiceWorkerInfo::ServiceWorkerInfo(nsIPrincipal* aPrincipal,
+ const nsACString& aScope,
+ uint64_t aRegistrationId,
+ uint64_t aRegistrationVersion,
+ const nsACString& aScriptSpec,
+ const nsAString& aCacheName,
+ nsLoadFlags aImportsLoadFlags)
+ : mPrincipal(aPrincipal),
+ mDescriptor(GetNextID(), aRegistrationId, aRegistrationVersion,
+ aPrincipal, aScope, aScriptSpec, ServiceWorkerState::Parsed),
+ mCacheName(aCacheName),
+ mWorkerPrivateId(ComputeWorkerPrivateId()),
+ mImportsLoadFlags(aImportsLoadFlags),
+ mCreationTime(PR_Now()),
+ mCreationTimeStamp(TimeStamp::Now()),
+ mInstalledTime(0),
+ mActivatedTime(0),
+ mRedundantTime(0),
+ mServiceWorkerPrivate(new ServiceWorkerPrivate(this)),
+ mSkipWaitingFlag(false),
+ mHandlesFetch(Unknown),
+ mNavigationFaultCount(0),
+ mTestingInjectCancellation(NS_OK) {
+ MOZ_ASSERT(XRE_GetProcessType() == GeckoProcessType_Default);
+ MOZ_ASSERT(mPrincipal);
+ // cache origin attributes so we can use them off main thread
+ mOriginAttributes = mPrincipal->OriginAttributesRef();
+ MOZ_ASSERT(!mDescriptor.ScriptURL().IsEmpty());
+ MOZ_ASSERT(!mCacheName.IsEmpty());
+ MOZ_ASSERT(!mWorkerPrivateId.IsEmpty());
+
+ // Scripts of a service worker should always be loaded bypass service workers.
+ // Otherwise, we might not be able to update a service worker correctly, if
+ // there is a service worker generating the script.
+ MOZ_DIAGNOSTIC_ASSERT(mImportsLoadFlags &
+ nsIChannel::LOAD_BYPASS_SERVICE_WORKER);
+}
+
+ServiceWorkerInfo::~ServiceWorkerInfo() {
+ MOZ_ASSERT(mServiceWorkerPrivate);
+ mServiceWorkerPrivate->NoteDeadServiceWorkerInfo();
+}
+
+static uint64_t gServiceWorkerInfoCurrentID = 0;
+
+uint64_t ServiceWorkerInfo::GetNextID() const {
+ return ++gServiceWorkerInfoCurrentID;
+}
+
+void ServiceWorkerInfo::PostMessage(RefPtr<ServiceWorkerCloneData>&& aData,
+ const ClientInfo& aClientInfo,
+ const ClientState& aClientState) {
+ mServiceWorkerPrivate->SendMessageEvent(
+ std::move(aData),
+ ClientInfoAndState(aClientInfo.ToIPC(), aClientState.ToIPC()));
+}
+
+void ServiceWorkerInfo::UpdateInstalledTime() {
+ MOZ_ASSERT(State() == ServiceWorkerState::Installed);
+ MOZ_ASSERT(mInstalledTime == 0);
+
+ mInstalledTime =
+ mCreationTime +
+ static_cast<PRTime>(
+ (TimeStamp::Now() - mCreationTimeStamp).ToMicroseconds());
+}
+
+void ServiceWorkerInfo::UpdateActivatedTime() {
+ MOZ_ASSERT(State() == ServiceWorkerState::Activated);
+ MOZ_ASSERT(mActivatedTime == 0);
+
+ mActivatedTime =
+ mCreationTime +
+ static_cast<PRTime>(
+ (TimeStamp::Now() - mCreationTimeStamp).ToMicroseconds());
+}
+
+void ServiceWorkerInfo::UpdateRedundantTime() {
+ MOZ_ASSERT(State() == ServiceWorkerState::Redundant);
+ MOZ_ASSERT(mRedundantTime == 0);
+
+ mRedundantTime =
+ mCreationTime +
+ static_cast<PRTime>(
+ (TimeStamp::Now() - mCreationTimeStamp).ToMicroseconds());
+}
+
+void ServiceWorkerInfo::SetRegistrationVersion(uint64_t aVersion) {
+ mDescriptor.SetRegistrationVersion(aVersion);
+}
+
+} // namespace mozilla::dom