tor-browser

ServiceWorkerInfo.h (5915B)

---

/* -*- 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/OriginAttributes.h"
#include "mozilla/TimeStamp.h"
#include "mozilla/dom/ServiceWorkerBinding.h"  // For ServiceWorkerState
#include "mozilla/dom/ServiceWorkerDescriptor.h"
#include "mozilla/dom/ServiceWorkerLifetimeExtension.h"
#include "mozilla/dom/WorkerCommon.h"
#include "nsIServiceWorkerManager.h"

namespace mozilla::dom {

class ClientInfo;
class PostMessageSource;
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 PostMessageSource& aSource);

 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(); }
 WorkerType Type() const { return mDescriptor.Type(); }
 Maybe<ClientInfo> GetClientInfo();

 // Pass-through of ServiceWorkerPrivate::GetLifetimeDeadline(); note that
 // we have an XPCOM variation that returns a double for testing purposes.
 TimeStamp LifetimeDeadline();

 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,
                   const WorkerType& aType, uint64_t aRegistrationId,
                   uint64_t aRegistrationVersion,
                   const nsACString& aScriptSpec, const nsAString& aCacheName,
                   nsLoadFlags aImportsLoadFlags);

 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